内部排序--数据结构

排序：将一个数据元素的任意序列重新排列成一个按关键词有序的序列。
稳定的排序：相等的数据元素在排序后相对的位置不变。
内部排序的分类：
插入排序：将无序子序列中的一个或几个记录插入到有序序列中，从而增加记录的有序子序列的长度。如直插排序、二分插入排序、希尔排序
交换排序：通过交换无序序列中的记录从而得到关键词最小或最大的记录，并将它加入到有序子序列中，以此方法增加记录的有序子序列的长度。如冒泡排序、快速排序。
选择排序：从记录的无序子序列中选择关键字最小或最大的记录，并将它加入到有序子序列中，一次增加记录的有序子序列的长度。如简单选择排序、树型排序、堆排序。
归并排序：通过归并两个或两个以上的记录有序子序列，逐步增加记录有序序列的长度。如二路归并排序、多路归并排序。
分配排序：如多关键字排序、基数排序。

直接插入排序的基本思想是：n个待排序的元素由一个有序表和一个无序表组成，开始时有序表只包含一个元素。排序过程中，每次从无需表中取出第一个元素，将其插入到有序表中的适当位置，是有序表的长度不断加长，完成排序过程。

#include 
using namespace std;

//直接插入排序
void InsertSort(int a[]) {
    for (int i = 1; i < 8; i++) {
        if (a[i] < a[i - 1]) {
            int temp = a[i];
            int j;
            for (j = i; j > 0; j--) {
                if (a[j-1] < temp)
                    break;
                a[j] = a[j-1];
            }
            a[j] = temp;
        }
    }
}

int main()
{
    int a[8] = { 34 ,12,49,28,31,52,51,49 };
    InsertSort(a);
    for (int i = 0; i < 8; i++) {
        cout << a[i] << " ";
    }
    cout << endl;
    return 0;
}

时间复杂度： O ( n 2 ) O(n^2) O(n2)
空间复杂度： O ( 1 ) O(1) O(1)
稳定的排序方法。
适用情况：元素数目少，或者元素的初始数列基本有序。

再寻找插入位置时采用二分查找，则称为折半插入排序；

#include 
using namespace std;

//折半插入排序
void two_InsertSort(int a[]) {
    for (int i = 1; i < 8; i++) {
        if (a[i] < a[i - 1]) {
            int temp = a[i];
            int low = 0, high = i - 1;
            while (low <= high) {
                int mid = (low + high) / 2;
                if (a[mid] < temp) {
                    low = mid + 1;
                }
                else
                    high = mid - 1;
            }
            int j;
            for (j = i; j > high+1; j--) {
                a[j] = a[j - 1];
            }
            a[j] = temp;
        }
    }
}
int main()
{
    int a[8] = { 34 ,12,49,28,31,52,51,49 };
    two_InsertSort(a);
    for (int i = 0; i < 8; i++) {
        cout << a[i] << " ";
    }
    cout << endl;
    return 0;
}

希尔排序也称为缩小增量排序，其改进原理主要基于一下两点：

元素基本有序时，直接插入排序的时间复杂度接近于 O ( n ) O(n) O(n)。元素数目n较少时，直接插入排序的效率较高。
算法思想：先将整个待排序元素序列分割成若干个子序列（由相隔某个增量的元素组成），分别进行直接插入排序，待整个序列的元素基本有序（增量足够小）时，在对元素进行一次直接插入排序。

#include 
using namespace std;

//希尔排序
void shellSort(int a[], int dk) {
    for (int i = dk; i < 8; i++) {
        if (a[i] < a[i - dk]) {
            int temp = a[i], j;
            for (j = i; j > 0; j = j - dk) {
                if (a[j - dk] > temp) {
                    a[j] = a[j - dk];
                }
                else
                    break;
            }
            a[j] = temp;
        }
    }
}
int main()
{
    int a[8] = { 34 ,12,49,28,31,52,51,49 };
    //two_InsertSort(a);
    shellSort(a, 5);
    shellSort(a, 3);
    shellSort(a, 1);
    for (int i = 0; i < 8; i++) {
        cout << a[i] << " ";
    }
    cout << endl;
    return 0;
}

冒泡排序的基本思想是：将相邻位置的关键字进行比较，若为逆序则交换。

#include 
using namespace std;


//冒泡排序
void BubbleSort(int a[]) {
    bool change = true;
    for (int i = 0; i < 8 && change; i++) {
        change = false;
        for (int j = 0; j < 8 - i - 1; j++) {
            if (a[j] > a[j + 1]) {
                int temp = a[j];
                a[j] = a[j + 1];
                a[j + 1] = temp;
                change = true;
            }
        }
    }
}
int main()
{
    int a[8] = { 34 ,12,49,28,31,52,51,49 };
    //two_InsertSort(a);
    //shellSort(a, 5);
    //shellSort(a, 3);
    //shellSort(a, 1);
    BubbleSort(a);
    for (int i = 0; i < 8; i++) {
        cout << a[i] << " ";
    }
    cout << endl;
    return 0;
}

时间复杂度： O ( n 2 ) O(n^2) O(n2)，在最好情况下（正序），元素的交换次数为0，比较次数为n-1；在最坏的情况下（逆序），元素的交换次数为 n ( n − 1 ) / 2 n(n-1)/2 n(n−1)/2，比较次数为 ( n − 1 ) ( n − 2 ) / 2 (n-1)(n-2)/2 (n−1)(n−2)/2
空间复杂度： O ( 1 ) O(1) O(1)，只需一个辅助单元进行交换。
稳定的排序方法
适用的情况：元素数目少，或者元素的初始序列基本有序。

快速排序是迄今为止所有内部排序算法中速度最快的一种，其基本思想是：取待排序的序列中的某个元素作为基准（一般取第一个元素），通过一趟排序，将待排序元素分为左右两个子序列，左子序列元素的关键字均小于或等于基准元素的关键字，右子序列的关键字则大于基准元素的关键字，然后分别对两个子序列继续进行排序，直至整个序列有序。

#include 
using namespace std;


//快速排序
int Partition(int a[],int low,int high){
    int temp = a[low];
    int i = low, j = high;
    while (i < j) {
        while (i < j && a[j] >= temp)
            j--;
        a[i] = a[j];
        while (i < j && a[i] <= temp)
            i++;
        a[j] = a[i];
    }
    a[i] = temp;
    return i;
}
void QuickSort(int a[],int low,int high) {
    if (low < high) {
        int temp = Partition(a, low, high);
        QuickSort(a, low, temp - 1);
        QuickSort(a, temp + 1, high);
    }
}
int main()
{
    int a[8] = { 34 ,12,49,28,31,52,51,49 };
    //two_InsertSort(a);
    //shellSort(a, 5);
    //shellSort(a, 3);
    //shellSort(a, 1);
    //BubbleSort(a);
    QuickSort(a, 0, 7);
    for (int i = 0; i < 8; i++) {
        cout << a[i] << " ";
    }
    cout << endl;
    return 0;
}

时间复杂度：在最好情形下（左右两个区间的长度大致相等），则结点数n与二叉树深度h应满足 l o g 2 n < h < l o g 2 n + 1 log_2n 空间复杂度： O ( l o g n ) O(logn) O(logn)
不稳定的排序方法，快速排序不适合对小规模的序列进行排序。

基本思想：第一趟在n个记录中选取最小记录作为有序序列的第一个记录，第二趟在n-1个记录中选取最小记录作为有序序列的第二个记录，第i趟在n-i+1个记录中选取最小的记录作为有序序列中的第i个记录。

#include 
using namespace std;

//简单选择排序
void SelectSort(int a[]) {
    for (int i = 0; i < 8; i++) {
        for (int j = i + 1; j < 8; j++) {
            if (a[j] < a[i]) {
                int temp = a[j];
                a[j] = a[i];
                a[i] = temp;
            }
        }
    }
}
int main()
{
    int a[8] = { 34 ,12,49,28,31,52,51,49 };
    //two_InsertSort(a);
    //shellSort(a, 5);
    //shellSort(a, 3);
    //shellSort(a, 1);
    //BubbleSort(a);
    //QuickSort(a, 0, 7);
    SelectSort(a);
    for (int i = 0; i < 8; i++) {
        cout << a[i] << " ";
    }
    cout << endl;
    return 0;
}

时间复杂度： O ( n 2 ) O(n^2) O(n2)，在n个关键字中选出最小者，需要n-1次比较，继续在剩余n-1个元素中选出次小者需要n-2次比较，以此类推。
空间复杂度： O ( 1 ) O(1) O(1)
不稳定的排序方法，适合元素数目小，无需完全排序的情况，比如选出第i小的元素。

又称锦标赛排序(Tournament Sort) :首先对n个记录的关键字两两进行比较，然后在n / 2个较小者之间再进行两两比较，如此重复，直至选出最小关键字的记录。选出最小记录后，将树中的该最小记录修改为∞，然后从该叶子结点所在子树开始，修改到达树根的路径上的结点。

对于n个元素的序列 k 1 , k 2 , . . . , k n {k_1,k_2,...,k_n} k1​,k2​,...,kn​，当且仅当满足以下关系时，称之为堆。
大顶堆： k i > = k 2 i a n d k i > = k 2 i + 1 k_i>=k_{2i} and k_i>=k_{2i+1} ki​>=k2i​andki​>=k2i+1​。或者，小顶堆 k i < = k 2 i a n d k i < = k 2 i + 1 k_i<=k_{2i} and k_i<=k_{2i+1} ki​<=k2i​andki​<=k2i+1​
堆排序：对一组待排序记录的关键字，首先把它们按堆的定义建成小（大）顶堆，然后输出堆顶的最小（大）关键字所代表的记录，再对剩余的关键字建堆，以便得到次小（大）的关键字，如此反复进行，直到全部关键字拍成有序序列为止。