C语言实现的几种排序算法

目录

一、冒泡排序

二、选择排序

三、插入排序

四、快速排序

---

一、冒泡排序

        思想：相邻的两个数比较，若不符合关键字排序顺序，则交换，外层循环n-1轮，内层循环如果从0开始向右比较，则外层循环每轮得到一个最大的数，（内层循环若从下标n-1开始向左比较，则外层循环每轮得到一个最小的数）循环n-1轮则排序完成。

void bubblesort(int *a,int n){
	int i,j;
	for(i=0;i<n-1;i++){//N-1轮循环 
		for(j=0;j<n-1-i;j++){//j<n-1-i 小优化 
			if(a[j]>a[j+1]){
				swap(&a[j],&a[j+1]);
			}
		}
	}
}

//双向冒泡排序
void bidbubblesort(int *a,int n){
	int i,j;
	int left,right;
	left=0;right=n-1;
	while(left<right){
		for(i=left;i<right;i++){
			if(a[i]>a[i+1]){
				swap(&a[i],&a[i+1]);
			}
		} //从左向右比较，会出现一个最大的数在最右边 
		right--;
		for(i=right;i>left;i--){
			if(a[i]<a[i-1]){
				swap(&a[i],&a[i-1]);
			}
		} //从右向左比较，会出现一个最小的数在最左边 
		left++;
	}
}

二、选择排序

        思想：每次进入外层循环，都要先设置最小值（或最大值）下标min_pos为当前i的值，让内层循环的循环变量从i的下一个开始遍历，与a[min_pos]进行比较，如果a[i]<a[min_pos],则要让min_pos=i；内层循环就是为了找到一个最小值的下标赋值给min_pos，出了内循环，则交换a[i]和a[min_pos]。i ++；循环下去最终循环n-1次，得到n-1个最小值，则排序完毕

void selectsort(int *a,int n){
	int i,j,min_pos;
	//每一次从新进入循环都要先设置最小值的下标min_pos是当前i的值 
	for(i=0;i<n-1;i++){
		min_pos=i;
		for(j=i+1;j<n;j++){//从min_pos的下一个开始遍历数组，与a[min_pos]比较，记录最小值的下标 
			if(a[j]<a[min_pos]) {
				min_pos=j;
			}
		}
		if(min_pos!=i){
			swap(&a[i],&a[min_pos]);
		}
	}
}

//逆向选择排序
void selectsort(int *a,int n){
	int i,j,max_pos;
	for(i=n-1;i>0;i--){ //每一次从新进入循环都要先设置最大值的下标max_pos是当前i的值
		max_pos=i; //设置假设最大值下标  
		for(j=i-1;j>=0;j--){ //j从最大值下标的前一个开始，与最大值比较直到j=0 
			if(a[j]>a[max_pos]){
				max_pos=j;
			}
		}
		if(max_pos!=i){
			swap(&a[max_pos],&a[i]);
		}
	}
}
//双向选择排序
void bidselectsort(int *a,int n){
	int i,j;
	int left,right;
	int min_pos,max_pos;
	left=0;
	right=n-1;
	while(left<right){
		max_pos=right;
		min_pos=left;
		for(i=left+1;i<=right;i++){
			if(a[i]<a[min_pos]){
				min_pos=i;
			}
		}
		if(min_pos!=left){
			swap(&a[min_pos],&a[left]);
		}
		left++;
		for(i=right-1;i>=left;i--){
			if(a[i]>a[max_pos]){
				max_pos=i;
			}
		}
		if(max_pos!=right){
			swap(&a[max_pos],&a[right]);	
		}
        right--;	
	}
}

三、插入排序

        思路：核心是从0--0天然有序，到0--1有序，......再到0--n-1有序,因此外层循环从i=1开始代表先做0--1有序，当i循环到n-1时，则0--n-1有序了，排序完毕，外层到内层的连接处，需要设置当前的a[i]=temp，方便后续的操作（比较大小和插入）。内层循环，遵循“往前看”的原则，j=i-1开始一直到j>=0，其实意思是比较temp与前面元素的相对大小，如果前面某个元素比temp小，则可以break，因为前面都是有序的，一定也会比temp更小。若前面的某个元素比temp大，则应将它后移一位故a[j+1]=a[j];

void insertsort(int *a,int n){
	int temp;
	int i,j;
	for(i=1;i<n;i++){//从0-1有序到0-n-1有序 
		temp=a[i];
		for(j=i-1;j>=0;j--){//往前看 
			if(a[j]<temp) break;		
			else{
				a[j+1]=a[j];//将现在这个下标j的数后移一位，那应该就是移到下标为j+1的位置 
			}
		}//出循环的条件是break或者j=-1; 此时应该将a[j+1]=temp; 
		a[j+1]=temp;
	}
}

四、快速排序

        思想：挖坑填数+递归 定义一个基准数std=a[0]，定义左右下标left right，定义一个决策变量（决定哪个下标移动）moving。若moving==2，则应该移动右下标right，从std的右边  希望去找到一个比std要小的数，放到左下标的位置上，（因为把a[0]取出来当做std，a[0]一开始是一个坑）；如果没找到就right--，继续找；若找到了，需要三步操作，填数 改决策变量 移动下标。循环下去当left==right时，则把a[left]=std;最后核心是递归，需要注意参数，传入数组的首地址和数组std左边和右边的元素个数。

void quicksort(int *a,int n)
{
	if(n<2){//数组的元素少于两个就不用排序了 
		return;
	}
	//递归调用时，std、left，right都是相应的参数，这样写是没问题的
	int std=a[0];	//选取数组第一个数作为中心轴 （基准数） 
	int left=0;		//左下标  
	int right=n-1;	//右下标 
	int moving=2;	//判断当前应当移动哪个下标，1-左下标，2-右下标 
	while(left<right)
	{
		if(moving==2)//移动右下标的情况 
	//此时应当找出一个数 比基准数std 小的数 放到左边多出来的坑位 
		{
			if(std<a[right])
	//如果右下标位置元素的值大于等于基准数，则右下标继续向左移动 
			{
				right--; 
			}
			else
			//如果右下标位置元素的值小于基准数，那么把右下标的元素填到左下标的坑中 
			{ 	//三步操作：填数，改决策变量，移动下标 
				a[left]=a[right];
				left++;		//让左下标向右移动
				moving=1;	//改变 决定移动哪个下标的变量moving，使得下次循环将移动左下标 
				continue;
			}	
		} 
		if(moving==1)//移动左下标的情况 
//此时应当找出一个比基准数std要大的数 放到此时右下标多出来的坑位 
		{
			if(a[left]<std)//如果左下标位置元素的值小于std基准数，则左下标继续向右移动 
			{
				left++;
			} 
			else//如果左下标位置元素的值大于std基准数，将该值填到右下标的坑位 
			{
				a[right]=a[left];
				right--;	//让右下标向左移动 
				moving=2;	//改变 决定移动哪个下标的变量moving，使得下次循环将移动右下标 
			} 
		} 
	}
	//此时一轮循环结束，left应该等于right，将此时的坑位填入std基准数 
	a[left]=std;//此时基准数的位置是在left这里 
	//这样基准数的左边是有 0-left-1，即left个元素 
	//这样基准数的右边是有 n-left-1 个元素 （右边就等于全部减去左边再减去中间一个元素） 
	//递归调用该函数，只是传进去的参数需要调整使得，每次调用函数的范围合理 
	quicksort(a,left);//对上一次基准数的左边进行排序   
	quicksort(a+left+1,n-left-1);//对上一次的基准数的右边进行排序 
	//注意传入的参数是 数组和数组元素个数,这个仔细分析一下就行，传入数组的首地址
}