devbox
你好赵伟
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

头歌作业之排序1、2、3、4_第1关:选择排序

作者：你好赵伟 | 2024-05-07 11:56:17

赞

踩

第1关:选择排序

（PS：直接拿的友友zy的）

一个不知名大学生，江湖人称菜狗
original author: jacky Li
Email : 3435673055@qq.com

Time of completion：2023.1.1
Last edited: 2023.1.1

目录

（PS：直接拿的友友的）

排序1

第1关：简单选择排序算法

任务描述

相关知识

编程要求

测试说明

参考代码

 第2关：直接插入排序实现

任务描述

相关知识

编程要求

测试说明

参考代码

 第3关：折半插入排序实现

任务描述

相关知识

编程要求

测试说明

参考代码

排序2

第1关：希尔排序实现

任务描述

编程要求

测试说明

参考代码

 第2关：冒泡排序算法实现

任务描述

编程要求

测试说明

参考代码

排序3

第1关：快速排序算法实现

任务描述

编程要求

测试说明

参考代码

第2关：选择排序算法实现

任务描述

编程要求

测试说明

参考代码

排序4

第1关：堆排序算法实现

任务描述

编程要求

测试说明

参考代码

第2关：二路归并算法实现

任务描述

编程要求

测试说明

参考代码

作者有言

排序1

第1关：简单选择排序算法

任务描述

本关任务：试以单链表为存储结构，实现简单选择排序算法。

相关知识

为了完成本关任务，你需要掌握：链表的相关操作和掌握选择排序算法。

编程要求

根据提示，在右侧编辑器补充代码。

测试说明

平台会对你编写的代码进行测试：

参考代码

  1. #include <iostream>
  2. using namespace std;
  3. #define OK 1;
  4.  
  5. typedef struct Node
  6. {
  7. 	int data;
  8. 	struct Node *next;
  9. }Node,*LinkedList;
  10.  
  11.  
  12. int LinkCreate(LinkedList &head)
  13. {
  14.    int i=0,n;
  15.    LinkedList p,rear;
  16.    head = new Node;
  17.    head->next = NULL;
  18.    rear=head;
  19.    cin>>n;
  20.    while(i<n)
  21.    {
  22.    	    i++;
  23.    	    p=new Node;
  24.    	    cin>>p->data;
  25.    	    p->next=NULL;
  26.    	    rear->next=p;   //将新结点链入到尾部
  27. 		rear=p;       //新结点变成新的尾部 	    
  28.     }
  29. 	return OK;	
  30. }
  31.  
  32. void LinkedListSelectSort(LinkedList head)
  33. //本算法一趟找出一个关键字最小的结点，其数据和当前结点进行交换;若要交换指针，则须记下
  34. //当前结点和最小结点的前驱指针
  35. {
  36. 	//###### Begin ###### 
  37. LinkedList p, q, min;
  38. 	p = head;
  39. 	while(p->next) {
  40. 		q = p->next;
  41. 		min = q;
  42. 		while(q) {
  43. 			if(q->data < min->data) {
  44. 				min = q; //min指向数据元素最小的结点 
  45. 			}
  46. 			q = q->next;		
  47. 		}
  48. 		for(q = p; q->next != min; q = q->next); //q指针指向min指针的前一个 
  49. 		q->next = min->next; 
  50. 		min->next = p->next; //min指向的结点插入到p指针后面
  51. 		p->next = min;	
  52. 		p = p->next; //p指针后移一位 
  53. 	}
  54.  
  55.     // ###### End ######
  56. }
  57. void LinkOut(LinkedList head)  //对链表的输出 
  58. {
  59. 	LinkedList p;
  60. 	p=head->next;
  61. 	while(p!=NULL)
  62. 	{
  63. 		cout<<p->data<<" ";
  64. 		p=p->next;		
  65. 	}
  66. 	cout<<endl;
  67. }
  68.  
  69. int main()
  70. {
  71. 	LinkedList head;
  72. 	if(LinkCreate(head))
  73. 		cout<<"创建成功"<<endl;
  74. 	LinkedListSelectSort(head);
  75. 	LinkOut(head);	
  76. }
  77.

 第2关：直接插入排序实现

任务描述

本关任务：编写函数实现直接插入排序算法

相关知识

为了完成本关任务，你需要掌握：直接插入排序的算法思想。

编程要求

根据提示，在右侧编辑器补充代码

测试说明

平台会对你编写的代码进行测试：

参考代码

  1. #include <iostream>
  2. using namespace std;
  3. # define MAXSIZE 20      //设记录不超过20个
  4. # define OK 1; 
  5.  
  6. typedef  struct {                       //定义顺序表的结构
  7.   int  r[MAXSIZE+1];   //存储顺序表的向量  r[0]一般作哨兵或缓冲区
  8.   int length ;       //顺序表的长度
  9. }SqList;
  10. int ListCreate(SqList &L)
  11. {
  12. 	int i=1,n;
  13. 	cin>>n;
  14. 	while(i<=n)
  15. 	{
  16. 		cin>>L.r[i];
  17. 		i++;
  18. 	}
  19. 	L.length=n;
  20. 	return OK;
  21. }
  22.  
  23. void InsertSort(SqList &L)
  24. {
  25. 	//###### Begin ###### 
  26. 	for(int i=1;i<=L.length;i++)
  27. 	{
  28. 		for(int j=i+1;j<=L.length;j++)
  29. 		{
  30. 			if(L.r[i]>=L.r[j])
  31. 			{
  32. 				swap(L.r[i],L.r[j] );
  33. 			}
  34. 		}
  35. 	}
  36.     
  37.     
  38.     // ###### End ######
  39. }
  40. void ListOut(SqList L)
  41. {
  42. 	int i;
  43. 	for(i=1;i<=L.length;i++)
  44. 	    cout<<L.r[i]<<" ";
  45. 	cout<<endl;
  46. }
  47. int main()
  48. {
  49. 	SqList L;
  50. 	if(ListCreate(L))
  51. 	    cout<<"创建成功\n";
  52. 	InsertSort(L);
  53. 	ListOut(L);	
  54. }

 第3关：折半插入排序实现

任务描述

本关任务：编写函数实现折半插入排序算法。

相关知识

为了完成本关任务，你需要掌握：折半插入排序算法。

编程要求

根据提示，在右侧编辑器补充代码

测试说明

平台会对你编写的代码进行测试：

测试输入：

5 （数字个数）

3 9 5 8 7 （数字序列）

预期输出：

创建成功

3 5 7 8 9

参考代码

  1. #include <iostream>
  2. using namespace std;
  3. # define MAXSIZE 20      //设记录不超过20个
  4. # define OK 1; 
  5.  
  6. typedef  struct {                       //定义顺序表的结构
  7.   int  r[MAXSIZE+1];   //存储顺序表的向量  r[0]一般作哨兵或缓冲区
  8.   int length ;       //顺序表的长度
  9. }SqList;
  10. int ListCreate(SqList &L)
  11. {
  12. 	int i=1,n;
  13. 	cin>>n;
  14. 	while(i<=n)
  15. 	{
  16. 		cin>>L.r[i];
  17. 		i++;
  18. 	}
  19. 	L.length=n;
  20. 	return OK;
  21. }
  22.  
  23. void  BInsertSort( SqList &L )
  24. {
  25. 	//###### Begin ###### 
  26.     int i,j;
  27.     for(i = 2;i<=L.length;i++)
  28.         {//如果遍历到的确实比前半部分最后一个大，插到尾部即可
  29.             if(L.r[i]<L.r[i-1])
  30.             {
  31.                 L.r[0] = L.r[i];//把r[0]作为哨兵，记录要执行此次插入的数据
  32.                 L.r[i] = L.r[i-1];//把i位置的数据换成i-1的数据，即已经使得前部分的数量+1
  33.                 //i-1位置的数据现在被记录到了第i个位置，本身存在无意义，可以理解为空出一个位置，看这个位置能不能插
  34.                 for(j=i-2;L.r[0]<L.r[j];--j)
  35.                 {   //这个循环是为了把要插入的空位置找到合适的地方
  36.                     //j+1=i-1
  37.                     L.r[j+1]=L.r[j];
  38.                 }
  39.                 //这个循环结束后肯定能找到合适的位置
  40.                 L.r[j+1]=L.r[0];
  41.             }
  42.         }
  43.  
  44.     
  45.     // ###### End ######
  46. }  // BInsertSort
  47. void ListOut(SqList L)
  48. {
  49. 	int i;
  50. 	for(i=1;i<=L.length;i++)
  51. 	    cout<<L.r[i]<<" ";
  52. 	cout<<endl;
  53. }
  54. int main()
  55. {
  56. 	SqList L;
  57. 	if(ListCreate(L))
  58. 	    cout<<"创建成功\n";
  59. 	BInsertSort( L );
  60. 	ListOut(L);	
  61. }

排序2

第1关：希尔排序实现

任务描述

本关任务：编写一个能实现希尔排序算法的函数。

编程要求

根据提示，在右侧编辑器补充代码

测试说明

平台会对你编写的代码进行测试：

参考代码

  1.  #include <iostream>
  2. using namespace std;
  3. # define MAXSIZE 20      //设记录不超过20个
  4. # define OK 1; 
  5.  
  6. typedef  struct {                       //定义顺序表的结构
  7.   int  r[MAXSIZE+1];   //存储顺序表的向量  r[0]一般作哨兵或缓冲区
  8.   int length ;       //顺序表的长度
  9. }SqList;
  10. int ListCreate(SqList &L)
  11. {
  12. 	int i=1,n;
  13. 	cin>>n;
  14. 	while(i<=n)
  15. 	{
  16. 		cin>>L.r[i];
  17. 		i++;
  18. 	}
  19. 	L.length=n;
  20. 	return OK;
  21. }
  22. void ShellInsert(SqList &L,int dk) 
  23. {
  24. 	//###### Begin ###### 
  25.     int i,j;
  26. 	//从dk+1开始 
  27. 	for(i=dk+1 ; i<=L.length;i++)
  28. 	{
  29. //从当前下标向前 与同一小组的数据进行比较，如果前面数据大，就把前面数据赋值给当前位置
  30. 		if( L.r[i] <L.r[i-dk] )//同一组元素中前一个相比较 
  31. 		{
  32. 			L.r[0]=L.r[i];//暂存哨兵
  33. 			for(j=i-dk; j>0 &&(L.r[0]<L.r[j]  ) ; j-=dk )
  34. 			{
  35. 				//后移
  36. 				L.r[j+dk]=L.r[j]; 
  37. 			} 
  38. 			//插入位置
  39. 			L.r[j+dk]=L.r[0]; 
  40. 		}
  41. 	}
  42.  
  43.       
  44.     // ###### End ######
  45. }
  46. void ShellSort(SqList &L,int dlta[ ],int t) //按增量序列dlta[0…t-1]对顺序表L作Shell排序
  47. {       
  48. 	for(int k=0;k<t;++k)
  49. 		ShellInsert(L,dlta[k]);//增量为dlta[k]的一趟插入排序
  50. }  // ShellSort
  51.  
  52. void ListOut(SqList L)
  53. {
  54. 	int i;
  55. 	for(i=1;i<=L.length;i++)
  56. 	    cout<<L.r[i]<<" ";
  57. 	cout<<endl;
  58. }
  59. int main()
  60. {
  61. 	SqList L;
  62. 	int dlta[3]={5,3,1};
  63. 	if(ListCreate(L))
  64. 	    cout<<"创建成功\n";
  65. 	ShellSort( L,dlta,3 );
  66. 	ListOut(L);	
  67. }

 第2关：冒泡排序算法实现

任务描述

本关任务：编写一个能实现希尔排序算法的函数。

编程要求

根据提示，在右侧编辑器补充代码

测试说明

平台会对你编写的代码进行测试：

参考代码

  1.  #include <iostream>
  2. using namespace std;
  3. # define MAXSIZE 20      //设记录不超过20个
  4. # define OK 1; 
  5.  
  6. typedef  struct {                       //定义顺序表的结构
  7.   int  r[MAXSIZE+1];   //存储顺序表的向量  r[0]一般作哨兵或缓冲区
  8.   int length ;       //顺序表的长度
  9. }SqList;
  10. int ListCreate(SqList &L)
  11. {
  12. 	int i=1,n;
  13. 	cin>>n;
  14. 	while(i<=n)
  15. 	{
  16. 		cin>>L.r[i];
  17. 		i++;
  18. 	}
  19. 	L.length=n;
  20. 	return OK;
  21. }
  22. void ShellInsert(SqList &L,int dk) 
  23. {
  24. 	//###### Begin ###### 
  25.     int i,j;
  26. 	//从dk+1开始 
  27. 	for(i=dk+1 ; i<=L.length;i++)
  28. 	{
  29. //从当前下标向前 与同一小组的数据进行比较，如果前面数据大，就把前面数据赋值给当前位置
  30. 		if( L.r[i] <L.r[i-dk] )//同一组元素中前一个相比较 
  31. 		{
  32. 			L.r[0]=L.r[i];//暂存哨兵
  33. 			for(j=i-dk; j>0 &&(L.r[0]<L.r[j]  ) ; j-=dk )
  34. 			{
  35. 				//后移
  36. 				L.r[j+dk]=L.r[j]; 
  37. 			} 
  38. 			//插入位置
  39. 			L.r[j+dk]=L.r[0]; 
  40. 		}
  41. 	}
  42.  
  43.       
  44.     // ###### End ######
  45. }
  46. void ShellSort(SqList &L,int dlta[ ],int t) //按增量序列dlta[0…t-1]对顺序表L作Shell排序
  47. {       
  48. 	for(int k=0;k<t;++k)
  49. 		ShellInsert(L,dlta[k]);//增量为dlta[k]的一趟插入排序
  50. }  // ShellSort
  51.  
  52. void ListOut(SqList L)
  53. {
  54. 	int i;
  55. 	for(i=1;i<=L.length;i++)
  56. 	    cout<<L.r[i]<<" ";
  57. 	cout<<endl;
  58. }
  59. int main()
  60. {
  61. 	SqList L;
  62. 	int dlta[3]={5,3,1};
  63. 	if(ListCreate(L))
  64. 	    cout<<"创建成功\n";
  65. 	ShellSort( L,dlta,3 );
  66. 	ListOut(L);	
  67. }

排序3

第1关：快速排序算法实现

任务描述

本关任务：编写一个能实现希尔排序算法的函数。

编程要求

根据提示，在右侧编辑器补充代码

测试说明

平台会对你编写的代码进行测试：

参考代码

  1. #include <iostream>
  2. using namespace std;
  3. # define MAXSIZE 20      //设记录不超过20个
  4. # define OK 1; 
  5.  
  6. typedef  struct {                       //定义顺序表的结构
  7.   int  r[MAXSIZE+1];   //存储顺序表的向量  r[0]一般作哨兵或缓冲区
  8.   int length ;       //顺序表的长度
  9. }SqList;
  10. int ListCreate(SqList &L)
  11. {
  12. 	int i=1,n;
  13. 	cin>>n;
  14. 	while(i<=n)
  15. 	{
  16. 		cin>>L.r[i];
  17. 		i++;
  18. 	}
  19. 	L.length=n;
  20. 	return OK;
  21. }
  22.  
  23. void QSort(SqList &L,int low, int high) 
  24. {  
  25. 	//###### Begin ###### 
  26.     if(low>=high) return ;
  27.     
  28. 	int i=low-1 ,j =high+1 , mid = L.r[low + high >>1];
  29.     while(i<j)
  30.     {
  31.     	do i++ ;while(L.r[i]<mid);
  32.     	do j-- ; while(L.r[j]>mid);
  33.     	if(i<j) 
  34.     	swap(L.r[i],L.r[j]);
  35. 	}
  36.     QSort(L,low, j);
  37.     QSort(L,j+1,high);
  38.     
  39.     // ###### End ######
  40. }
  41.  
  42.  
  43. void ListOut(SqList L)
  44. {
  45. 	int i;
  46. 	for(i=1;i<=L.length;i++)
  47. 	    cout<<L.r[i]<<" ";
  48. 	cout<<endl;
  49. }
  50. int main() 			 
  51. {
  52. 	SqList L;
  53. 	if(ListCreate(L))
  54. 	    cout<<"创建成功\n";
  55. 	QSort(L,1,L.length);
  56. 	ListOut(L);
  57. 	return 0;	
  58. }

第2关：选择排序算法实现

任务描述

本关任务：编写一个能实现希尔排序算法的函数。

编程要求

根据提示，在右侧编辑器补充代码

测试说明

平台会对你编写的代码进行测试：

参考代码

  1. #include <iostream>
  2. using namespace std;
  3. # define MAXSIZE 20      //设记录不超过20个
  4. # define OK 1; 
  5.  
  6. typedef  struct {                       //定义顺序表的结构
  7.   int  r[MAXSIZE+1];   //存储顺序表的向量  r[0]一般作哨兵或缓冲区
  8.   int length ;       //顺序表的长度
  9. }SqList;
  10. int ListCreate(SqList &L)
  11. {
  12. 	int i=1,n;
  13. 	cin>>n;
  14. 	while(i<=n)
  15. 	{
  16. 		cin>>L.r[i];
  17. 		i++;
  18. 	}
  19. 	L.length=n;
  20. 	return OK;
  21. }
  22. void SelectSort(SqList &L)
  23. { 
  24. 	//###### Begin ###### 
  25. 	int i,j,min;//min存储L.r[i...n]中最小值的下标
  26. 	for(i=1;i<L.length;i++)
  27. 	{
  28. 		min=i;
  29. 		for(j=i+1;j<=L.length;j++)
  30. 		{
  31. 			if(L.r[j]<L.r[min])
  32. 				min=j;
  33. 			
  34. 		}
  35. 		if(min!=i)//如果min较比初值发生变化，则交换
  36. 		{
  37. 			L.r[0]=L.r[i]; 
  38. 			L.r[i]=L.r[min]; 
  39. 			L.r[min]=L.r[0];
  40. 		}
  41. 	}
  42.  
  43.     
  44.     
  45.     // ###### End ######
  46. }
  47. void ListOut(SqList L)
  48. {
  49. 	int i;
  50. 	for(i=1;i<=L.length;i++)
  51. 	    cout<<L.r[i]<<" ";
  52. 	cout<<endl;
  53. }
  54. int main() 			 
  55. {
  56. 	SqList L;
  57. 	if(ListCreate(L))
  58. 	    cout<<"创建成功\n";
  59. 	SelectSort(L);
  60. 	ListOut(L);
  61. 	return 0;	
  62. }

排序4

第1关：堆排序算法实现

任务描述

本关任务：编写一个能实现希尔排序算法的函数。

编程要求

根据提示，在右侧编辑器补充代码

测试说明

平台会对你编写的代码进行测试：

参考代码

  1. #include <iostream>
  2. using namespace std;
  3. # define MAXSIZE 20      //设记录不超过20个
  4. # define OK 1; 
  5.  
  6. typedef  struct {                       //定义顺序表的结构
  7.   int  r[MAXSIZE+1];   //存储顺序表的向量  r[0]一般作哨兵或缓冲区
  8.   int length ;       //顺序表的长度
  9. }SqList;
  10. int ListCreate(SqList &L)
  11. {
  12. 	int i=1,n;
  13. 	cin>>n;
  14. 	while(i<=n)
  15. 	{
  16. 		cin>>L.r[i];
  17. 		i++;
  18. 	}
  19. 	L.length=n;
  20. 	return OK;
  21. }
  22. void HeapAdjust(SqList &H,int s,int m)
  23. {//从H中调整下标s的位置  一共M个元素 
  24. 	int j;
  25. 	int rc;
  26. 	rc=H.r[s];//将要移动的元素 暂存 
  27. 	//暂存堆顶r[s]到rc
  28. 	for(j=2*s ; j<=m; j*=2)//2*s是左孩子 
  29. 	{
  30. 		//如果左孩子<右孩子 
  31. 		if(j<m && H.r[j]<H.r[j+1] )//横比，j初值指向左孩子
  32. 		{
  33. 			++j;//就指向右孩子 
  34. 		}//如果右孩子大于左孩子，j指向右孩子，j指示关键字较大位置
  35. 		if(rc>=H.r[j])//如果基准值大于等于j的key 
  36. 			break;//纵比,如果…，定位成功
  37. 		H.r[s]=H.r[j];//指向当前结点的左孩子 
  38. 		s=j;//
  39. 		//否则,r[j]上移到s,s变为j, 然后j*=2,进入下一层
  40. 	}
  41. 	H.r[s]=rc;//插入 
  42. 	// 将调整前的堆顶记录rc到位置s中
  43. }
  44.  
  45. void HeapSort(SqList &H)
  46. {
  47. 	int i;
  48. 	int temp;
  49. 	for(i=H.length/2 ;i>0;--i)//建堆
  50. 	{
  51. 		HeapAdjust(H,i,H.length);
  52. 	}
  53. 	for(i=H.length ;i>1;--i)
  54. 	{
  55. 		//交换r[1]和r[i]
  56. 		temp=H.r[i];
  57. 		H.r[i]=H.r[1];
  58. 		H.r[1]=temp;
  59. 		HeapAdjust(H,1,i-1); //调整，使得1~i-1符合堆的定义
  60. 	}
  61.  } 
  62. void ListOut(SqList L)
  63. {
  64. 	int i;
  65. 	for(i=1;i<=L.length;i++)
  66. 	    cout<<L.r[i]<<" ";
  67. 	cout<<endl;
  68. }
  69. int main() 			 
  70. {
  71. 	SqList L;
  72. 	if(ListCreate(L))
  73. 	    cout<<"创建成功\n";
  74. 	HeapSort(L);
  75. 	ListOut(L);
  76. 	return 0;	
  77. }

第2关：二路归并算法实现

任务描述

本关任务：编写一个能实现希尔排序算法的函数。

编程要求

根据提示，在右侧编辑器补充代码

测试说明

平台会对你编写的代码进行测试：

参考代码

  1. #include <iostream>
  2. using namespace std;
  3. # define MAXSIZE 20      //设记录不超过20个
  4. # define OK 1; 
  5.  
  6. typedef  struct {                       //定义顺序表的结构
  7.   int  r[MAXSIZE+1];   //存储顺序表的向量  r[0]一般作哨兵或缓冲区
  8.   int length ;       //顺序表的长度
  9. }SqList;
  10. int ListCreate(SqList &L)
  11. {
  12. 	int i=1,n;
  13. 	cin>>n;
  14. 	while(i<=n)
  15. 	{
  16. 		cin>>L.r[i];
  17. 		i++;
  18. 	}
  19. 	L.length=n;
  20. 	return OK;
  21. }
  22.  
  23. void RedCopy(int &r1,int r2)
  24. {
  25.     //复制元素r2到r1
  26.     r1=r2;
  27. }
  28. void Merge(int R[],int T[],int low,int mid,int high)
  29. {
  30. 	 //###### Begin ######
  31.     //将相邻有序序列R[low..mid]和R[mid+1..high]归并为T[low..high]
  32.     int i=low,j=mid+1,k=low; //ijk各遍历一序列
  33.     while(i<=mid&&j<=high)
  34.     {
  35.         //选择两子序列中当前小的填入T[k]
  36.         if(R[i]<=R[j])
  37. 	    RedCopy(T[k++],R[i++]);
  38. 	else
  39.            RedCopy(T[k++],R[j++]);  
  40.     }
  41.     while(i<=mid) //剩余段复制到T
  42.         RedCopy(T[k++],R[i++]);
  43.     while(j<=high)
  44.         RedCopy(T[k++],R[j++]);
  45.     for(i=low;i<=high;i++) //将合并完的T复制到R 以便下次归并时用
  46.         RedCopy(R[i],T[i]);
  47.  
  48.     
  49.     
  50.     // ###### End ######
  51. }
  52. void MSort(int R[],int T[],int low,int high)
  53. {
  54. 	 //###### Begin ###### 
  55.     /*归并排序
  56.     若序列为1直接填入T即可，否则，将元序列一分为二，左右两侧子
  57.     序列递归排序 最后调用归并函数进行归并 将R[low..high]归并排
  58.     序到T[low..high] 下标不变*/
  59.     int mid;
  60.     if(low==high)
  61.      RedCopy(T[low],R[low]);
  62.     else
  63.     {
  64.         mid=(low+high)/2;
  65. 	MSort(R,T,low,mid); //递归排序到临时数组
  66.         MSort(R,T,mid+1,high);
  67. 	Merge(R,T,low,mid,high); //归并到目标数组
  68.     }
  69.     
  70.     
  71.     // ###### End ######
  72. }
  73.  
  74. void MergeSort(SqList &L)
  75. {
  76. 	 //###### Begin ###### 
  77.  
  78.     //归并排序 递归实现
  79.     int *T; //临时数组
  80.     if(!(T=(int *)malloc((L.length+1)*sizeof(int ))))
  81.         exit(0);
  82.     MSort(L.r,T,1,L.length);
  83.     free(T);
  84.     T=NULL;
  85.     
  86.     
  87.     // ###### End ######
  88. }
  89.  
  90. void ListOut(SqList L)
  91. {
  92. 	int i;
  93. 	for(i=1;i<=L.length;i++)
  94. 	    cout<<L.r[i]<<" ";
  95. 	cout<<endl;
  96. }
  97. int main() 			 
  98. {
  99. 	SqList L;
  100. 	if(ListCreate(L))
  101. 	    cout<<"创建成功\n";
  102. 	MergeSort(L);
  103. 	ListOut(L);
  104. 	return 0;	
  105. }

作者有言

如果感觉博主讲的对您有用，请点个关注支持一下吧，将会对此类问题持续更新……

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/你好赵伟/article/detail/549098
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号