刷题笔记-排序

一、交换排序

基本思想：两两比较待排序记录关键字，当两个关键字不满足次序要求时进行交换，直到整个序列满足要求为止。

冒泡排序

两两比较关键字，如逆序则交换顺序，较大关键字逐渐一端移动，直到序列有序。
总共排序轮数为：元素个数-1
内层循环对比次数：元素个数-当前轮数-1

void bubble_sort(int arr[], int n) {
    for(int i=0; i<n-1; i++) { 
        bool flag = true;
        for(int j=0; j<n-i-1; j++) {
            if(arr[j]>arr[j+1]) {
                flag = false;
                int temp = arr[j+1];
                arr[j+1] = arr[j];
                arr[j] = temp;
            }
        }
        if(flag)
            break;
    }
}

算法特点：
​ 1、稳定排序
​ 2、可用于链式存储结构
​ 3、记录移动次数较多，算法平均性能比直接插入排序差，当初始记录无序时，n较大时，不宜采用

选择排序

基本思想：每一趟排序从待排序的记录中选出关键字最小的记录，按顺序放在已排序的记录中，直到全部排完为止。

//简单选择排序
void select_sort1(int arr[],int n){
    int k;
    for(int i = 0; i < n; i++){
        k = i;
        for(int j = i+1; j < n; j++){
            if(arr[k] > arr[j])
                k = j;
        }
        if(k != i){
            int temp = arr[i]; arr[i] = arr[k]; arr[k] = temp;
        }
    }
}

算法特点：
​ 1、算法本身是稳定排序，也可以变成是不稳定排序
​ 2、可以用于链式存储结构
​ 3、移动次数少，当每一个记录占用的空间较多时，此方法比直接插入排序快。

快速排序

基本思想：
1.选定Pivot中心轴
2.将大于pivot的数字放在pivot的右边
3.将小于pivot的数字放在pivot的左边
4.分别对左右子序列重复前三步操作
由冒泡排序改进得到，冒泡排序只对相邻两个记录进行比较，因此每次只能消除一个逆序，而快速排序一次交换可消除多个逆序，从而提高排序性能。
代码如下：

void QuickSort(int *array,int low,int high){	//快排 
	if(low>=high){	//若待排序序列只有一个元素，返回空 
		return ;
	}
	int i=low;	//i作为指针从左向右扫描 
	int j=high;	//j作为指针从右向左扫描
	int key=array[low];//第一个数作为基准数 
	while(i<j){
		while(array[j]>=key&&i<j){	//从右边找小于基准数的元素 （此处由于j值可能会变，所以仍需判断i是否小于j） 
			j--;	//找不到则j减一 
		}
		array[i]=array[j];	//找到则赋值 
		while(array[i]<=key&&i<j){	//从左边找大于基准数的元素 
			i++;	//找不到则i加一 
		}
		array[j]=array[i];	//找到则赋值 
	}
	array[i]=key;	//当i和j相遇，将基准元素赋值到指针i处 
	QuickSort(array,low,i-1);	//i左边的序列继续递归调用快排 
	QuickSort(array,i+1,high);	//i右边的序列继续递归调用快排 
}

算法特点：
​ 1、不稳定排序
​ 2、适用于顺序结构，很难用于链式结构
​ 3、当n较大时，在平均情况下时所有内部排序方法中最快的一种，适用于初始记录无序，n较大的情况

二、插入排序

基本思想：每一趟将一个待排序的记录，按其关键字的大小插入到已经排好序的一组记录的适当位置，直到全部待排序全部插入为止。

直接插入排序

void insertion_sort(int a[], int n)
{
    for(int i=1;i<n;i++)
    {
        int key = a[i];
        int j = i-1;
        while(j>=0&&a[j]>key)
        {
            a[j+1] = a[j];
            j--;
        }
        a[j+1] = key;
    }
}

算法特点：
​ 1、稳定排序
​ 2、适用于顺序存储结构和链式存储结构
​ 3、适用于初始记录基本有序的情况，当初始记录无序，n较大时，此算法时间复杂度较高，不宜采用

折半插入排序

基本思想同直接插入排序，不同点在于，在有序集合中搜索插入位置时折半插入采用二分搜索，可以有效的减少比较次数。

//折半直接插入排序
void BInsert_Sort(int arr[],int n){
    int high , low , mid , j;
    for(int i = 2; i <= n; ++i){
        arr[0] = arr[i];
        low = 1 ; high = i-1;
        while(low <= high){ //一定是low <= high ，搜索结束high指向的位置后一位即为插入位置
            mid = (low + high) / 2 ;
            if(arr[0] < arr[mid])
                high = mid - 1;
            else
                low =  mid + 1;
        }

        for(j = i - 1; j >= high + 1; --j)
            arr[j+1] = arr[j];
        arr[high + 1] = arr[0];
    }
}

算法特点：

​ 1、稳定排序
​ 2、只能适用于顺序结构，不用于链式结构
​ 3、适合初始记录无序，n较大的情况

参考链接：

1. 9种常用排序算法总结（超详细）
2. C++ 10种排序算法汇总