• 直接插入排序+希尔排序+冒泡排序+快速排序+选择排序+堆排序+归并排序+基于统计的排序

    插入排序：直接插入排序、希尔排序

    交换排序：冒泡排序、快速排序

    选择排序：简单选择排序、堆排序

    其他：归并排序、基于统计的排序

    一、直接插入排序

    1. #include
    2. #include
    3. /*
    4. 直接插入排序：是就地排序，是稳定的，时间复杂度：O（n^2） 
    5. */ 
    6. int a[105]; 
    7. int n;
    8. int main()
    9. {
    10. 	int t;
    11. 	scanf("%d",&n);
    12. 	for(int i=1;i<=n;i++)
    13. 	{
    14. 		scanf("%d",&a[i]);
    15. 	}
    16. 	//认为：a[1] 是有序区域，a[2---n]是乱序区
    17. 	for(int i=2;i<=n;i++)
    18. 	{
    19. 		t=a[i];
    20. 		int j;
    21. 		for(j=i-1;j>=1;j--)
    22. 		{
    23. 			if(a[j]>t)
    24. 			{
    25. 				a[j+1]=a[j];
    26. 			 } 
    27. 			 else{
    28. 			 	break;
    29. 			 }
    30.  
    31. 		}
    32. 		a[j+1]=t;
    33. 	 } 
    34. 	for(int i=1;i<=n;i++)
    35. 	{
    36. 		printf("%d ",a[i]);
    37. 	}
    38. 	return 0;
    39. }

    二、希尔排序

    1. #include
    2. #include
    3. /*
    4. 希尔排序：取希尔增量序列时： 是就地排序，不是稳定的，时间复杂度：O（n^2）
    5. */ 
    6. int a[105]; 
    7. int n;
    8. int main()
    9. {
    10. 	int t;
    11. 	scanf("%d",&n);
    12. 	int k=0;
    13. 	for(int i=1;i<=n;i++)
    14. 	{
    15. 		scanf("%d",&a[i]);
    16. 	}
    17. 	for(int d=n/2;d>=1;d=d/2) 
    18. 	{
    19. 		k++;//计算趟数 
    20. 		//以增量d分组，对每组进行直接插入排序
    21. 		for(int i=1+d;i<=n;i++)
    22. 	    {
    23. 	    	t=a[i];
    24. 	    	int j;
    25. 	    	for(j=i-d;j>=1;j=j-d)
    26. 	    	{
    27. 	    		if(a[j]>t)
    28. 	    		{
    29. 	    			a[j+d]=a[j];
    30. 				}
    31. 				else{
    32. 					break;
    33. 				}
    34. 			}
    35. 		     a[j+d]=t;	
    36. 		 } 
    37. 		 
    38. 		 printf("第%d趟，增量为%d,排好的结果：",k,d);
    39. 		for(int i=1;i<=n;i++)
    40. 		{
    41. 		printf("%d ",a[i]);
    42. 		}
    43. 		printf("\n");
    44. 	 } 
    45.  
    46. 	return 0;
    47. }

    三、冒泡排序

    1. #include
    2. #include
    3. #define maxx 100
    4. /*所谓交换,是指根据序列中两个关键字比较的结果来对换这两个关键字在序列中的位置。*/
    5. int a[maxx],n,t;
    6. int v;//标记 
    7. int main()
    8. {
    9. 	
    10. 	scanf("%d",&n);
    11. 	for(int i=1;i<=n;i++)
    12. 	{
    13. 		scanf("%d",&a[i]);
    14. 	}
    15. 	
    16. 	//冒泡排序
    17. 	//外层循环控制 排序的趟数 n个元素排序需要循环n-1次 【1】
    18. 	for(int i=1;i<=n-1;i++) 
    19. 	{
    20. 		v=0;
    21.         //内层循环控制比较的次数 n个元素第i趟比较n-i次 【2】
    22.         for(int j=1;j1;j++) 
    23. 		{
    24.             //比较相邻的元素大小 目的：将最大的元素选出到移动到最后 
    25.             if(a[j]>a[j+1])
    26. 			{
    27. 				v=1;
    28.                 t = a[j];
    29.                 a[j] = a[j+1];
    30.                 a[j+1] = t;
    31.             }
    32.         }
    33.         if(v==0)//v仍然等0，说明没交换，说明完全有序 
    34.         {
    35.         	break;
    36. 		}
    37.     }
    38. 	for(int i=1;i<=n;i++)
    39. 	{
    40. 	 printf("%d ",a[i]);
    41. 	}
    42. 	return 0;
    43. }

    四、快速排序

    排序区间[l,r] , 选 a[l] 做基准数

    两个下标i=l,j=r;相对遍历。

    先用j 找一个比x小的数，放在i位置，i++

    再用i 找一个比x大的数，放在j位置，j--

    不断循环，直到 i==j为止，此时i(j)位置就是x的位置

    1. #include
    2. #include
    3. /*交换排序：基于数据交换的排序
    4. 1.冒泡排序：是就地排序， 是稳定的，时间复杂度 O（n^2） 
    6. 2.快速排序：---递归: 是就地排序，不稳定，时间复杂度O(nlogn) ------待排序的数组已经保持需要的顺序了，容易退化成O(n^2) 
    7. 每一趟：先选一个标准（基准数），按照基准数进行划分，把比基准数小的交换到他前面，
    8. 把比基准数大的交换到他后面 
    10. 基准数怎么选：对区间(l,r) 
    11. （1）选排序区间的第一个数--a[l]------为例 
    12. （2）选排序区间的最后一个数--a[r] 
    13. */ 
    14. void QuickSort(int a[],int l,int r)
    15. {//选排序区间的第一个数--a[l]做基准数
    16.    if(l>=r)
    17.    {
    18.    	return;
    19. 	} 
    20. 	int x=a[l];
    21. 	int i=l;
    22. 	int j=r; 
    23. 	while(i
    24. 	{
    25. 		//先 从后往前，找一个小于基准数小的数，放到i位置 
    26. 		while(ix)j--; 
    27. 		if(i
    28. 		{
    29. 			a[i]=a[j];
    30. 			i++;
    31. 		 } 
    32. 		//再从前往后，找一个小于基准数大的数，放到j位置
    33. 		while(i
    34. 		if(i
    35. 		{
    36. 			a[j]=a[i];
    37. 			j--;
    38. 		 } 
    39. 	}
    40. 	a[i]=x;
    41. 	QuickSort(a,l,i-1); 
    42. 	QuickSort(a,i+1,r);
    43. }
    44.  
    45. int main()
    46. {
    47. 	int a[105]; 
    48. 	int n;
    49. 	scanf("%d",&n);
    50.  
    51. 	for(int i=1;i<=n;i++)
    52. 	{
    53. 		scanf("%d",&a[i]);
    54. 	}
    55.    //快速排序
    56.    QuickSort(a,1,n); 
    57.  
    58. 	for(int i=1;i<=n;i++)
    59. 		{
    60. 		printf("%d ",a[i]);
    61. 		}
    62. 		printf("\n");
    63. 	return 0;
    64. }

    五、（简单）选择排序

    每趟从待排序区中，选择一个最小的数，放到待排序区的第一个位置。从而实现排序

    1. #include
    2. #include
    3. #define maxx 100
    4.  
    5. int a[maxx],n,t;
    6. int minn; 
    7.  
    8.  
    9. int main()
    10. {
    11.     int minn;//最小元素的下标 
    12. 	scanf("%d",&n);
    13. 	for(int i=1;i<=n;i++)
    14. 	{
    15. 	 scanf("%d",&a[i]);
    16. 	}
    17. 	//简单选择排序:就地排序， 时间复杂度O(n^2) ,不稳定的排序 
    18. 	//简单选择排序:进行n-1趟排序，每次都在乱序区中选择一个最小的元素，放在乱序的第一个位置，此时有序区+1，乱序区-1 
    19. 	for(int i=1;i<=n-1;i++)//控制循环趟数
    20. 	{
    21. 		minn=i; 
    22. 		for(int j=i+1;j<=n;j++)//控制乱序区，去找最小的元素的位置
    23. 		{
    24. 			if(a[j]
    25. 			{
    26. 				minn=j;
    27. 			}
    28. 		}
    29. 		//把minn位置的元素放在乱序区的第一个位置，即i位置
    30. 		if(minn!=i)
    31. 		{
    32. 		int t=a[i];
    33. 		a[i]=a[minn];
    34. 		a[minn]=t; 
    35. 		}
    36. 	 } 
    37. 	 	 
    38. 	for(int i=1;i<=n;i++)
    39. 	{
    40. 	printf("%d ",a[i]);
    41. 	}
    42. 	printf("\n");
    43. 	return 0;
    44. }

    六、堆排序

    堆----->完全二叉树----->数组存储

    a[i]父亲：a[i/2]

    a[i]左孩子：a[2*i]

    a[i]右孩子：a[2*i+1]

    1.建堆（两种方法）

    （1）自我初始化：在原数组的基础上进行初始化

    从子树入手由小到大去调整每棵子树；

    对于每棵子树，我们向下调整：

    让根节点和左右孩子节点作比较，如果子树值小：最小值和根节点交换，继续向下调整子树

    （2）通过插入来建堆

    数组每多一个数据就调整一次。新插入的数据放在放在最后，如果其比父亲大或者新插入的数据是根节点就不用调整否则就向上调整

    堆排序：

    （1）建堆（流程见上）

    （2）循环n次 每次输出最小的数---->a[1],

    删掉a[1]--->让堆中最后一个节点来替换a[1]，然后重新对a[1]向下调整

    1. #include
    2. #include
    3. #define maxx 100
    4.  
    5. /*升序排列 
    7.    堆排序:就地排序，不稳定 ，时间复杂度O(nlogn) 
    8.    n个元素，保存在a数组中，直接在a数组中
    9. 1.初始化成一个小顶堆：
    10.   下标最大的内部节点的下标是几？最后一个内部节点的下标是几？
    11.         n/2
    12. （1）找到最后一个内部节点（n/2）,依次调整每棵子树
    13.         调整过程：依次向下比较调整：若该节点比左右孩子节点中的最小值大，进行交换，直到不满足该条件位置
    14. 2.在小顶堆的基础上，进行堆排序
    15.    循环n-1次：
    16.   （1）输出（删除）根节点；
    17.    （2）最后一个位置的节点代替根节点
    18. （3）向下调整
    19. ---输入最后一个元素
    20. 3.堆中插入一个元素：
    21. （1）把元素放到数组最后
    22. （2）向上和父亲节点比较进行调整
    23.   
    24.  */
    25. void downAdjust(int a[],int i,int m)//对以 下标i的元素 为根节点的子树进行向下调整 
    26. {//now是当前调整的节点，next是now的孩子，也是下一次要调整的节点 
    27. 	int now=i;
    28. 	int next;
    29. 	int t;
    30. 	while(now*2<=m)
    31. 	{
    32. 		next=now*2;//now的左孩子
    33. 		if(next+1<=m&&a[next+1]
    34. 		{
    35. 			next=next+1;//now的右孩子 
    36. 		}
    37. 		if(a[now]<=a[next])
    38. 		{
    39. 			break;
    40. 		 } 
    41. 		 else{
    42. 		 	t=a[now];
    43. 		 	a[now]=a[next];
    44. 		 	a[next]=t;
    45. 		 	now=next;
    46. 		 }
    47. 	 } 
    48. 	 	
    49. }
    50. void upAdjust(int a[],int n)
    51. {//now是当前调整的节点，next是now的父亲，也是下一次要调整的节点
    52. 	int now=n;
    53. 	int next; 
    54. 	int t;
    55. 	while(now>1)
    56. 	{
    57. 		next=now/2;// now的父亲
    58. 		if(a[next]<=a[now])//父亲节点比当前节点大 
    59. 		{
    60. 			break;
    61. 		}
    62. 		else
    63. 		{
    64. 			t=a[now];
    65. 		 	a[now]=a[next];
    66. 		 	a[next]=t;
    67. 		 	now=next;
    68. 		}
    69. 	} 
    70. 		
    71. } 
    72.  
    73. int main()
    74. {
    75.     int n;//元素个数
    76. 	int a[maxx];// 
    77. 	scanf("%d",&n);
    78. 	for(int i=1;i<=n;i++)
    79. 	{
    80. 	 scanf("%d",&a[i]);
    81. 	}
    82. //把a数组初始化成小顶堆
    83. 	for(int i=n/2;i>=1;i--)
    84. 	{
    85. 		downAdjust(a,i,n);
    86. 	 } 
    87. //堆排序
    88.     int m=n;//数组最后一个元素下标 
    89.     int t;
    90. 	for(int i=1;i<=n;i++)
    91. 	{
    92. 		printf("%d ",a[1]);
    93. 		t=a[1];
    94. 		a[1]=a[m];
    95. 		a[m]=t;
    96. 		m--;
    97. 		downAdjust(a,1,m);
    98.  	} 
    99.  	printf("\n");
    100.  	for(int i=1;i<=n;i++)
    101. 	{
    102. 	printf("%d ",a[i]);
    103. 	}
    104. 	printf("\n");
    105. //在堆中插入一个元素；
    106. 	n++;
    107. 	scanf("%d",&a[n]);
    108. 	upAdjust(a,n);
    109.  
    110. 	return 0;
    111. }
    112.  
    113. //堆的应用--优先队列

    七、归并排序

    1. #include
    2. #include
    3. #define maxx 100
    4. void merge(int a[],int l,int mid,int r)
    5. {
    6. 	//l~mid
    7. 	//mid+1~r
    8. 	int t[maxx];
    9. 	int k=0;//t数组的下标 
    10. 	int i=l;
    11. 	int j=mid+1;
    12. 	while(i<=mid&&j<=r)
    13. 	{
    14. 		if(a[i]<=a[j])
    15. 		{
    16. 			t[k]=a[i]; 
    17. 			k++;
    18. 			i++;
    19. 		}
    20. 		else{
    21. 			t[k]=a[j];
    22. 			k++;
    23. 			j++;
    24. 		}
    25. 	}
    26. 	while(i<=mid)
    27. 	{
    28. 		t[k]=a[i]; 
    29. 		k++;
    30. 		i++;
    31. 	}
    32. 	while(j<=r)
    33. 	{
    34. 		t[k]=a[j]; 
    35. 		k++;
    36. 		j++;
    37. 	}
    38. 	for(int i=0;i
    39. 	{
    40. 		a[l+i]=t[i];
    41. 	}
    42. 	
    43. }
    44.  
    45. void merge_sort(int a[],int l,int r)
    46. {
    47. 	int mid;
    48. 	if(l
    49. 	{
    50. 	   	mid=(l+r)/2;
    51. 	   	//l~mid
    52. 	   	merge_sort(a,l,mid);
    53. 	   	//mid+1~r
    54. 	   	merge_sort(a,mid+1,r);
    55. 	   	merge(a,l,mid,r);
    56. 	}
    57. 	
    58. }
    59. int main()
    60. {
    61.     int n;//元素个数
    62. 	int a[maxx];// 
    63. 	scanf("%d",&n);
    64. 	for(int i=1;i<=n;i++)
    65. 	{
    66. 	 scanf("%d",&a[i]);
    67. 	}
    68. 	
    69. 	merge_sort(a,1,n);
    70.  
    71.  	for(int i=1;i<=n;i++)
    72. 	{
    73. 	printf("%d ",a[i]);
    74. 	}
    75. 	printf("\n");
    76.  
    77.  
    78. 	return 0;
    79. }

    八、基于统计的排序

    1.计数排序

    统计一下每个数出现的次数，然后直接按次数输出即可（以空间换时间的算法）

    缺点：

    a.无法对负整数进行排序（偏移量优化）

    b.极其浪费内存空间

    c.是一个不稳定排序（可优化）

    2.桶排序

    1、将代排序的序列部分分到若⼲个桶中，每个桶内的元素再进⾏个别的排序。
     2、时间复杂度最好可能是线性的O（n），桶排序不是基于⽐较的排序

    3.基数排序

    略

  • 相关阅读:
    hbase和aerospike基础概念及所对应的python包API使用
    钉钉推送线上环境异常
    windows server批量创建用户
    幂级数求和难吗？细节很重要
    华为交换机设置边缘端口（收到BPDU包后进入error-down状态）
    【Linux篇】第六篇——Linux下的进程（冯若依曼体系结构+操作系统+进程相关内容）
    【Tableau Server 企业日常问题 24】Tableau server提示工具嵌入工作表，服务器字体乱码问题解决
    Android PreferenceScreen的使用和详解(设置页面)
    怎么压缩PDF文件大小？不会操作的快看过来
    brief note-2022
  • 原文地址：https://blog.csdn.net/A2899531592/article/details/136217099