排序作业：冒泡排序、直接插入排序、希尔排序、简单选择排序、快速排序

1、冒泡排序

【问题描述】用简冒泡排序实现整数数组的升序排序，要求每扫描数组完成一趟完整交换后，输出数组全部内容。
【输入形式】

元素个数n

整数1 整数2 整数3 ...  整数n

【输出形式】

//第一趟交换后的数组内容

整数1 整数2 整数3 ...  整数n

//第二趟交换后的数组内容

整数1 整数2 整数3 ...  整数n

... ...

//最后一趟交换后的数组内容

整数1 整数2 整数3 ...  整数n

【样例输入】

6

64 15 32 7 9 21

【样例输出】

15 32 7 9 21 64

15 7 9 21 32 64

7 9 15 21 32 64

7 9 15 21 32 64

思路：

左边大于右边交换一趟排下来最大的在右边

动图如下：

 

代码如下：

#include<stdio.h>
int BubbleSort(int a[], int n){
	int i,j,k,flag;
	//flag作为标记变量 
	j=n-1,flag=1;
	//flag为1则有数据交换，否则退出循环	
	while(flag){
		//初始化为 0
		flag=0;	
		for(i=0;i<j;i++)
			if(a[i]>a[i+1])
			{
				int temp=a[i];
				a[i]=a[i+1];
				a[i+1]=temp;
				//如果有数据交换，改变flag的值为1
				flag=1;		
			}
			//循环打印每趟排序结果
			for(k=0;k<n;k++)		
			{
				printf("%d ",a[k]);
			}
			printf("\n");
			//长度减1 
			j--;	
		}
	return 0;
}

int main(){
	int i,n;
	int a[100];
	scanf("%d ",&n);
	for(i=0;i<n;i++){
		scanf("%d",&a[i]);
	}
	BubbleSort(a,n);
	return 0;
	}

时间复杂度：最坏情况：O(N^2)
      最好情况：O(N)
空间复杂度：O(1)

2、直接插入排序

【问题描述】编写程序实现直接插入排序的算法，结果按升序排列，每完成一趟插入操作后，当即输出数组当前的状态。
【输入形式】64 15 32 7 9 21

【输出形式】15 64 32 7 9 21      //15插入完成后

                     15 32 64 7 9 21     //32插入完成后，下同

                      7 15 32 64 9 21

                      7 9 15 32 64 21

                      7 9 15 21 32 64
【样例输入】

6

64 15 32 7 9 21

【样例输出】

15 64 32 7 9 21

15 32 64 7 9 21

 7 15 32 64 9 21

 7 9 15 32 54 21

 7 9 15 21 32 64

思路：
  在待排序的元素中，假设前n-1个元素已有序，现将第n个元素插入到前面已经排好的序列中，使得前n个元素有序。按照此法对所有元素进行插入，直到整个序列有序。
  但我们并不能确定待排元素中究竟哪一部分是有序的，所以我们一开始只能认为第一个元素是有序的，依次将其后面的元素插入到这个有序序列中来，直到整个序列有序为止。
 

动图如下：

 代码如下：

#include<stdio.h>
int DirectInsert(int a[], int n){
	int i,j;
	//将第一个数作为有序序列，因此下标从2开始遍历 
	for(i=2;i<=n;i++)	
	{
		if(a[i]<a[i-1])
		{
			//a[0]作为辅助空间 ，保存待插入的数
			a[0] = a[i];	 
			for(j=i-1;a[0]<a[j];j--)
			{
				//往后移动 
				a[j+1] = a[j]; 
			}
			a[j+1] = a[0];
		} 
		for(j=1;j<=n;j++){
			printf("%d ",a[j]);
		}
		printf("\n");
	}
	return 0;
}

int main(){
	int i,n;
	int a[100];
	scanf("%d",&n);
	for(i=0;i<n;i++){
		scanf("%d",&a[i+1]);
	}
	
	DirectInsert(a,n);
	
	return 0;
}

3、希尔排序

【问题描述】编写程序实现希尔排序算法，结果按升序排列，每完成一趟插入操作后，当即输出数组当前的状态。

【输入形式】

m n//m是待排序数据的个数，n为增量序列数据个数

a1 a2 ... am //m个待排序数据

b1 b2 ... bn //n个增量序列数据

【输出形式】

c1 c2 ... cm //第1趟排序结果

d1 d2 ... dm //第2趟排序结果

...

...

...

【样例输入】

28 4

84 92 78 67 21 79 23 57 86 32 46 19 22 90 15 69 42 13 47 38 55 34 18 43 26 94 72 62

9 5 3 1

【样例输出】

32 38 19 22 18 15 23 42 13 47 46 55 34 21 43 26 57 72 62 92 78 67 90 79 69 94 86 84

15 23 19 13 18 26 38 34 21 43 32 55 42 22 47 46 57 72 62 69 78 67 84 79 92 94 86 90

13 18 19 15 22 21 38 23 26 42 32 47 43 34 55 46 57 72 62 69 78 67 84 79 90 94 86 92

13 15 18 19 21 22 23 26 32 34 38 42 43 46 47 55 57 62 67 69 72 78 79 84 86 90 92 94

动图如下：【注意：此题增量需以数组形式输入，此图仅帮助读者理解排序过程】

思路：
希尔排序，先将待排序列进行预排序，使待排序列接近有序，然后再对该序列进行一次插入排序，此时插入排序的时间复杂度为O(N)，
 

代码如下：

#include<stdio.h>

void ShellSort(int arr[], int len, int d) {
	int i, j, temp;
	for (i = d; i < len; i++) 
	{
		temp = arr[i];
		for (j = i - d; j >= 0 && temp < arr[j]; j -= d) 
		{
			arr[j + d] = arr[j];
		}
		arr[j + d] = temp;
	}
	for(i=0;i<len;i++){
		printf("%d ",arr[i]);
	}
	printf("\n");	
}

int main(){
	//len表示数组长度，m表示增量序列长度 ,d表示增量
	int i,j,k,len,m,d;	 
	scanf("%d%d",&len,&m);
	int arr[len],dk[m];
	
	//输入待排数据 
	for(i=0;i<len;i++){
		scanf("%d",&arr[i]);
	}
	
	//输入增量序列 
	for(j=0;j<m;j++){
		scanf("%d",&dk[j]);
	}
	
	for(k=0;k<m;k++){
		d=dk[k];
		ShellSort(arr,len,d);
	}
	return 0;
}

4、简单选择排序

【问题描述】用简单选择排序实现整数数组的升序排序，要求每趟选择完成后，输出数组完整内容。
【输入形式】

元素个数n

整数1 整数2 整数3 ...  整数n

【输出形式】

//第一趟插入后的数组内容

整数1 整数2 整数3 ...  整数n

//第二趟插入后的数组内容

整数1 整数2 整数3 ...  整数n

... ...

//最后一趟插入后的数组内容

整数1 整数2 整数3 ...  整数n

【样例输入】

6

64 15 32 7 9 21

【样例输出】

7 15 32 64 9 21

7 9 32 64 15 21

7 9 15 64 32 21

7 9 15 21 32 64

7 9 15 21 32 64

思路：

每次从待排序列中选出一个最小值，然后放在序列的起始位置，直到全部待排数据排完即可。

动图如下：

 

代码如下：

#include<stdio.h>
void swap(int arr[],int a,int b){
	int temp=arr[a];
	arr[a]=arr[b];
	arr[b]=temp;
}

void SelectSort(int* arr, int n)
{
	int i,j,min,temp;
	for(i=0;i<n-1;i++)
	{
		//将第一个数的下标作为最小数的下标 
		min=i;
		//遍历找出比第一个数小的下标 
		for(j=i+1;j<n;j++)
		{
			if(arr[min]>arr[j])
			{
				min=j;
			}
		}	
		if(i!=min)
		{
			swap(arr,i,min);		
		}	
		for(int j=0;j<n;j++)
		{
			printf("%d ",arr[j]);
		}
		printf("\n");
	} 
}

int main(){
	int i,j,len;	
	scanf("%d",&len);
	int arr[len];
	//输入待排数据 
	for(i=0;i<len;i++){
		scanf("%d",&arr[i]);
	}
	SelectSort(arr,len);
	return 0;
}

5、快速排序

【问题描述】编写程序实现快速排序的算法，要求在每次Partition之后，显示数组内的全部内容，数组内最终按升序排列。用子表的第一个记录做枢轴记录。

【输入形式】

10

45 53 18 36 72 30 48 93 15 36
【输出形式】

36 15 18 36 30 45 48 93 72 53

30 15 18 36 36 45 48 93 72 53

18 15 30 36 36 45 48 93 72 53

15 18 30 36 36 45 48 93 72 53

15 18 30 36 36 45 48 93 72 53

15 18 30 36 36 45 48 53 72 93

15 18 30 36 36 45 48 53 72 93

动图如下：

代码如下： 

#include<stdio.h>

void swap(int arr[],int i,int j){
	int temp=arr[i];
	arr[i]=arr[j];
	arr[j]=temp;
}

void print(int arr[],int n){
	for(int j=1;j<=n;j++){
				printf("%d ",arr[j]);
			}
	printf("\n");
}
int Partition(int arr[],int low,int high)
{ 
	int pivotkey;
	/* 用数字的第一个记录作枢轴记录 */	
	pivotkey=arr[low]; 
	/* 将枢轴关键字备份到arr[0] */
	arr[0]=pivotkey;
	/* 从数组的两端交替地向中间扫描 */  
	while(low<high) 
	{ 
		 while(low<high&&arr[high]>=pivotkey)
			high--;
		 arr[low]=arr[high];
		 while(low<high&&arr[low]<=pivotkey)
			low++;
		 arr[high]=arr[low];
	}
	arr[low]=arr[0];
	 /* 返回枢轴所在位置 */
	return low;
}

void QSort(int arr[],int low,int high,int len)
{ 
	int pivot;
	if(low<high)
	{	
		pivot=Partition(arr,low,high); 	
		print(arr,len);
		QSort(arr,low,pivot-1,len);	
		QSort(arr,pivot+1,high,len);	
	}	
}

int main(){
	int i,n;
	scanf("%d",&n);
	int arr[n];
	int len=n;
	for(i =0;i<n;i++){
		scanf("%d",&arr[i+1]);
	}
	QSort(arr,1,n,len);
	return 0;
	}

具体详细思路及步骤可点击https://blog.csdn.net/weixin_50886514/article/details/119045154查看