实用排序法简介

   排序是数据结构中十分常见的一种操作，掌握各种排序法有利于提高我们的编程速度以及编程效率。排序方法具体可以分为八类：1.直接插入排序法   2.shell排序法   3.冒泡排序   4.快速排序法   5.堆排序   6.选择排序   7.归并排序   8.基数排序。这八种排序方法的时间复杂度和空间复杂度，以及稳定性不尽相同，本文我将具体介绍前三种排序法，后续将继续更新剩余的排序法。

1.直接插入排序.

这种排序法的基本思想是：和前面的数比较，招到对应位置插入。例如对数据  49  38  65  97  76  13进行直接插入排序，其过程为：

1. 49

2. 38  49

3. 38   49  65

4. 38 49  65  97

5.38  49  65  76  97

6.13  38  49  65  76  97

即将该元素找到它对应的位置，当他比前面数字大时，比后面数字小时，该元素插入两数字之间。代码实现为：

#include<iostream>
using namespace std;
int main() {
    int a[6] = { 49,38,65,97,76,13 };
    int n=6,temp;
    for (int i = 1; i < n; i++) {
        temp = a[i]; 
        int j = i;
        while (j >= 1 && temp < a[j - 1]) {
            a[j] = a[j - 1];
            j--;
        }
        a[j] = temp;
    }
    for (int i = 0; i < n; i++) {
        cout << a[i] << ' ';
    }
    cout << endl;
    return 0;
}

2.shell排序法.

shell排序实则是在直接插入排序的基础上，对所给数组进行划分，构成多个子表，再将子表进行排序。对于子表，我们要引入一个概念：步长。现给定数组为 49,38,65,97,76,13,27,49，以步长d=4进行归类子表，那么第一个49将与第五个元素76构成一个子表，以此类推，38与13,65与27,97与49分别为一个子表，接下来，我们对每个子表内的两个元素进行排序，注意，排序之后并非第一个子表两个元素在第一第二位，而是按照原顺序的排序在单个子表内位置进行改变。

第一次排序后，所得结果为：49 13 27 49 76 38 65 97。

接下来进行第二次排序，这时将步长d调整为2，再次排序：27 13 49 38 65 49 76 97。

第三次则将步长d调整为1，排序得到顺序数组：13 27 38 49 49 65 76 97。

由此可见，shell排序是一种对直接插入排序的改良，减少一定的算力，具体代码如下：

#include<iostream>
using namespace std;
void shell(int a[], int n) {
    int i, j, k, d, temp;
    for (d = n / 2; d >= 1; d = d / 2) {
        for (i = 0; i < d; i++) {
            for (j = i + d; j < n; j = j + d) {
                temp = a[j];
                k = j - d;
                while (k >= 0 && a[k] > temp) {
                    a[k + d] = a[k];
                    k = k - d;
                }
                a[k + d] = temp;
            }
        }
    }
    for (i = 0; i < n; i++) {
        cout << a[i] << ' ' ;
    }
}
int main() {
    int a[8];
    for (int i = 0; i < 8; i++) {
        cin >> a[i];
    }
    shell(a, 8);
}

3.冒泡排序.

冒泡排序相信大家都并不陌生，假定由列表末端开始进行比较，通过最后两个数字比较大小换位，再比较倒数第二与倒数第三的大小，不断往前推进，（当第一次比较完之后，就重新回到末端再次开始比较）直到列表变成有序列表。如数组49 13 76 49 27，比较过程为：

1.49 13 76 27 49

2.49 13 27 76 49

3.49 13 27 76 49

4.13 49 27 76 49

5.13 49 27 49 76

......最后得到13 27 49 49 76 具体代码如下：

#include<iostream>
using namespace std;
void bubblesort(int a[], int len) {
    for (int i = 0; i < len - 1; i++) {
        for (int j = 0; j < len - i- 1; j++) {
            if (a[j + 1] < a[j]) {
                int temp = a[j];
                a[j] = a[j + 1];
                a[j + 1] = temp;
            }
        }
    }
}
int main() {
    int a[5] = {49,13,76,49,27};
    int len = sizeof(a) / sizeof(int);
    bubblesort(a, len);
    for (int i = 0; i < len; i++) {
        cout << a[i] << ' ';
    }
    return 0;
}

后续小涛将会继续更新剩下的五种排序方法，感谢您的阅读！