几种排序算法比较

排序对比图

一、交换排序：

1、冒泡算法：

​核心：相邻比大小，交换

遍历length-1遍

每遍的子遍历遍历length-i遍（第1遍时，i=2）

Bubble_Sort(int &array[]){
​    for(i = 1; i<length-1,i++){
        for(j = 0; j<length-i; j++){             //第1遍时，i为2
            if array[j] >array[j+1]{
                  int help = array[j];
                  array[j] = array[j+1];
                  array[j+1] = help;
           }
        }        
    }
}

.
.

2、快速排序：

核心:将序列排好，分解为子序列，子序列继续排列，排列完的子序列继续分自身的子序列
特点:在同一个数组上排序，无需格外数组，不断排序

(1)首先设定一个分界值，通过该分界值将数组分成左右两部分。
(2)将大于或等于分界值的数据集中到数组右边，小于分界值的数据集中到数组的左边。此时，左边部分中各元素都小于或等于分界值，而右边部分中各元素都大于或等于分界值。
(3)然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理。
(4)重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左、右两个部分各数据排序完成后，整个数组的排序也就完成了。

void split(int &array,[] int start, int end){
    int key = quicksort(start, end);
    split(stat, key-1);
    split(key+1, end );
}

void quicksort(int &array[], int start, int end){
    key = array[start];
    
    while(start != end && start != end+1){
        while (array[end] >= key && start<end) 
            end--；
        if(start < end) 
            array[start++] = array[end];                //引用后再加1;
        while(array[start] > key && start <end) 
            start++;
        if(start < end)
            array[end-- ] = array[start];               //引用后再减1;
    }
        array[start] = key;                             //退出时start == end, 讲基准数放入坑中 
        return key;
}

.
.

更加简洁的代码:

void quick_sort(int s[], int l, int r){
    if (l < r)
    {
        //Swap(s[l], s[(l + r) / 2]); //将中间的这个数和第一个数交换 参见注1
        int i = l, j = r, x = s[l];
        while (i < j)
        {
            while(i < j && s[j] >= x) // 从右向左找第一个小于x的数
                j--;  
            if(i < j) 
                s[i++] = s[j];
            
            while(i < j && s[i] < x) // 从左向右找第一个大于等于x的数
                i++;  
            if(i < j) 
                s[j--] = s[i];
        }
        s[i] = x;
        quick_sort(s, l, i - 1); // 递归调用 
        quick_sort(s, i + 1, r);
    }
}

//  此代码，  
    作者：MoreWindows
    原文：https://blog.csdn.net/morewindows/article/details/6684558 

---

.
.

二、插入排序

​思想：

• 遍历 length-1遍“子遍历”
• 每遍“子遍历”遍历 i 遍

insertion_sort(int &array[]){
    int i,j,help = 0;
    for(i = 0; i<length-1; i++){
        j = i;                            //第1遍时，j=1；
        while(j > 0){
            if(array[j] < array[j-1]){
                help = array[j];
                array[j] = array[j-1];      
                array[j-1] = array[j];
            }     
        }
    }
}

.
.

三、选择排序:

思想：

• 从小到大排序，从左往右遍历，每次遍历，flag = “子遍历的首位数下标”，“子遍历”每次找到比flag小的数，就记录其下标flag = 下标;
• 子遍历结束，子遍历的首位数 与 数组flag标记位置交换

Selection_sort(int &array[]){
    for(int i = 0; i<array.length-2; i++ ){
        int  flag = i-1;
        for(int j = i; j<length-2; j++){                              //第1遍时，j = 1;
            if(array[flag] > array[j]) flag = j;
        }
        int help = array[i-1];
        array[i-1] = array[flag];
        array[flag] = help;    
    }
}

.
.

四、归并排序

思想：

• 归并算法与快速排序相反，是把顺序的子序列给合并起来，再排序
• 需要借助格外数组
• 稳定

//排序获取的两个子数组
void Sort(int &array[],int start,int middle,int end){  
    if()
    int help[] = new int[];
    int i =start,j = middle+1,z = 0;
    
    while(i ！= middle+1 && j != end+1;){           //比较数据并且交换
        if(array[i] <= array[j]){
            help[z] = array[i];
            i++;
        }
        else{
            help[z] = array[j];
            j++;
        }

        z++;
    }
    
    if(i != middle+1){                              //help数组追加数组后面较大的数据
        while(i != middle+1){
            help[z] = array[i];
            i++;
        }
    }
    else if(j != end+1){
         while(i != middle+1){
            help[z] = array[j];
            j++;
        }
    }
    
    z = 0；                                          //help数组导入array数组
    while(start != end+1){
        array[start] = help[z];
        start++;
    }
}
//开始归并排序函数；递归合并子数组
//若数组数为偶数，中间数偏左
void Merge(int &array[],int start,int end){         
    int middle = (end + start)/2;                                 
    Merge(&array,start, middle);                     //数组数为偶数，左数组数比右数数组多1
    Merge(&array,middle+1, end);
    Sort(&array,start, middle,end)
}