數據結構 -- 經常使用排序算法

排序之間性能的比較

直接插入排序

將一個記錄插入到已排序好的有序表中，從而獲得一個新，記錄數增1的有序表。即：先將序列的第1個記錄當作是一個有序的子序列，而後從第2個記錄逐個進行插入，直至整個序列有序爲止。

插入排序算法的通常步驟：

1.從第一個元素開始，該元素能夠認爲已被排序；

2.取出下一個元素，在已經排序的元素序列中從後向前掃描；

3.若是該元素（已排序）大於新元素，將該元素移到下一個位置；

4.重複步驟3，直到找到已排序的元素小於或者等於新元素的位置；

5.將新元素插入到該位置後，重複2~5

void insetSort(int arr[], int n)
{
    for (int i = 1; i < n; i++)
    {
        for (int j = i-1; j >= 0; j--)
        {
            if (arr[j] > arr[i])
            {
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
    }
}

希爾排序

希爾排序的算法思想：將待排序數組按照步長gap進行分組，而後將每組的元素利用直接插入排序的方法進行排序；每次將gap折半減少，循環上述操做；當gap=1時，利用直接插入，完成排序。

void shellSort(int arr[], int len)
{
    int insertNum;
    int grap = len / 2;

    while (grap)
    {
        for (int i = grap; i < len; i++)
        {
            insertNum = arr[i];
            int j = i;
            while (j >= grap && insertNum < arr[j - grap])
            {
                arr[j] = arr[j - grap];
                j -= grap;
            }
            arr[j] = insertNum;
        }
        grap /= 2;
    }
}

簡單選擇排序

在要排序的一組數中，選出最小（或者最大）的一個數與第1個位置的數交換；而後在剩下的數當中再找最小（或者最大）的與第2個位置的數交換，依次類推，直到第n-1個元素（倒數第二個數）和第n個元素（最後一個數）比較爲止。

void simpleSort(int *p, int length)
{
    for (int i = 0; i < length - 1; i++)
    {
        int min = i;
        for (int j = i + 1; j <= length - 1; j++)
        {
            if (p[j] < p[min])
            {
                min = j;
            }
        }
        int temp = p[i];
        p[i] = p[min];
        p[min] = temp;
    }
}

冒泡排序

在要排序的一組數中，對當前還未排好序的範圍內的所有數，自上而下對相鄰的兩個數依次進行比較和調整，讓較大的數往下沉，較小的往上冒。即：每當兩相鄰的數比較後發現它們的排序與排序要求相反時，就將它們互換。

void bubbleSort(int arr[], int len)
{
    for (int i = 0; i < len - 1; i++)
    {
        for (int j = 0; j < len - i -1; j++)
        {
            if (arr[j] > arr[j + 1])
            {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

快速排序

1）選擇一個基準元素,一般選擇第一個元素或者最後一個元素,

2）經過一趟排序講待排序的記錄分割成獨立的兩部分，其中一部分記錄的元素值均比基準元素值小。另外一部分記錄的 元素值比基準值大。

3）此時基準元素在其排好序後的正確位置

4）而後分別對這兩部分記錄用一樣的方法繼續進行排序，直到整個序列有序。

二分查找

1. 二分查找思想：一、數組從小到大排序；二、查找的key每次和中間數比較，若是key小於mid
2. 查找mid左側的數組部分；若是key大於mid，則查找mid右側的數組部分；若是相等，則直接返回mid。

int BinarySearchRecursive(int *array, int low, int high, int key)
{
    if ( low > high )
        return -1;
        
    int mid = ( low + high )/2;
    
    if ( array[mid] == key )
        return mid;
    else if ( array[mid] < key )
        return BinarySearchRecursive(array, mid+1, high, key);
    else
        return BinarySearchRecursive(array, low, mid-1, key);
}