数据结构 -- 经常使用排序算法

排序之间性能的比较

直接插入排序

将一个记录插入到已排序好的有序表中，从而获得一个新，记录数增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);
}