排序算法之交换排序（冒泡排序和快速排序）

交换排序：根据序列两个元素关键字的比较结果来对换两个记录在序列中的位置。

冒泡排序

原理如下

比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。

持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

时间复杂度最好o（n）最坏o（n2）

空间复杂度o（1）

代码实现（c）

#include <stdio.h>
#include <stdbool.h>

void BubbleSort (int a[],int n){
      
        //冒泡排序 
	int i,j,temp;         
	for( i=0;i<n-1;i++){
      
      
		bool flag=false;      //表示本趟冒泡是否发生交换的标志 
		for( j=n-1;j>1;j--)   //一趟冒泡的过程 
		if(a[j-1]>a[j]){
      
            //后面的数小于前面的 进行交换 
			temp=a[j];
			a[j]=a[j-1];
			a[j-1]=temp;
			flag=true;    
		}
		if(flag==false)    //本趟遍历没有发生交换说明结束 
		return;
	}
}
void Printarr(int a[],int n)    //输出数组 
{
      
      
	int i;
	for(i=0;i<n;i++){
      
      
		printf("%d",a[i]);
	}
	return;
} 

int main(){
      
                      //主函数 
	int b,c;
	int a[]={
      
      1,8,7,5,6};
	int n=5;
	printf("未排序的数\n"); 
	Printarr(a,n);
	printf("\n");
	BubbleSort(a,n);
	printf("冒泡排好序的数\n");
	Printarr(a,n);
	return 0;
}

快速排序

通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。
代码实现c

#include <stdio.h>
#include <stdlib.h>

int getStandard(int array[], int i, int j) {
    
    
	//基准数据 
	int key = array[i];
	while (i < j) {
    
     	//因为默认基准是从左边开始，所以从右边开始比较 //当队尾的元素大于等于基准数据 时,就一直向前挪动 j 指针 
			while (i < j && array[j] >= key) {
    
    
				j--;
			}
			if (i < j) {
    
    
				array[i] = array[j];//当找到比 array[i] 小的时，就把后面的值 array[j] 赋给它
			}	
			while (i < j && array[i] <= key) {
    
    //当队首元素小于等于基准数据 时,就一直向后挪动 i 指针 
				i++;
			}
			//当找到比 array[j] 大的时，就把前面的值 array[i] 赋给它
			if (i < j) {
    
    
				array[j] = array[i];
			}
		}
	array[i] = key;//跳出循环时 i 和 j 相等,此时的 i 或 j 就是 key 的正确索引位置
	return i;//把基准数据赋给正确位置 
}
void QuickSort(int array[], int low, int high) {
    
    
	//开始默认基准为 low
	if (low < high) {
    
    
		//分段位置下标 
		int standard = getStandard(array, low, high);
		//递归调用排序
		//左边排序 
		QuickSort(array, low, standard - 1);
		//右边排序 
		QuickSort(array, standard + 1, high);
	}
}

void display(int array[], int size) {
    
    
	int i;
	for (i = 0; i < size; i++) {
    
    
		printf("%d ", array[i]);
	}
	printf("\n");
}

int main() {
    
    
	int array[] = {
    
     49,38,65,97,76,13,27,49,10 };
	int size = sizeof(array) / sizeof(int);
	QuickSort(array, 0, size - 1);
	printf("排好的顺序为") ; 
	display(array, size);
    return 0;
}

在这里插入图片描述

时间复杂度O（n*递归的层数）空间复杂度O(递归的层数)

层数最小（log2n）最大n

优化的思路选取基轴元素时选头中尾三个比较选中间或者随机选一个数作为基轴