Algorithm Review 1 基础排序算法

整天做上层架构设计和写界面，把计算机最重要的算法与数据结构都忘得差不多了。所以从这篇开始系统地复习常见的算法与数据结构，这里会暂时抛弃Java，用C++来做，因为即使是Android系统，算法实现也大多是通过C或者C++编译成so来实现的。对于算法的描述我会尽量抛弃复杂的理论描述，尽量用大白话来让大家好理解。
第一篇是关于普通数组排序的，默认排序都是从小到大~

一、冒泡排序
算法复杂度n^2
把数组竖起来，尾部想象成一个水面，每次让最大的元素浮到水面上，就像冒泡一样。
基本思想就是每次两两数据比较，如果左边元素大于右边元素，则交换两者，这样每次都能让一个最大的元素浮上“水面”。

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

注意：C++内置有swap函数，因为涉及到内存的读写所以效率较低，有兴趣的同学可以用同样的算法进行测试，在数据量超过100000时，算法效率会大幅下降，所以本文中不使用该函数。

二、选择排序
算法复杂度n^2
假设每次数组的第一个元素的索引是指向的最小的元素，然后用这个元素和后面所有的元素进行比较，如果后面元素有比这个元素小，就把这个假设的索引值改成这个较小元素的索引，让后继续往后搜索直到数组末尾，每次选出来的就是那个最小的元素的索引，然后让第一个索引和这个索引交换数据即可。

void selectionSort(int arr[], int length){    for(int i = 0; i < length; i++)    {        int minIndex = i;        for(int j = i + 1; j < length; j++)        {            if(arr[j] < arr[minIndex])            {                minIndex = j;            }        }        if(minIndex != i)        {            int temp = arr[minIndex];            arr[minIndex] = arr[i];            arr[i] = temp;        }    }}

三、插入排序
算法复杂度n^2
每次将后面一个元素插入到前面已经排序好的数组的正确位置，所以插入排序是从i = 1开始的，因为只有一个元素的时候它本身就是有序的。

void insertionSort(int arr[], int length){    for (int i = 1; i < length; i++)    {        for (int j = i - 1; j >= 0; j--)        {            if(arr[j] > arr[j + 1])            {                swap(arr[j], arr[j + 1]);            }        }    }}void insertionSortImprove(int arr[], int length){    for (int i = 1; i < length; i++)    {        int temp = arr[i];        int pos = i;        for (int j = i - 1; j >= 0; j--)        {            if(arr[j] > temp)            {                arr[pos] = arr[j];                pos = j;            }        }        arr[pos] = temp;    }}

注意这里特地写了两种方法，第一种是直接调用C++提供的swap函数，需要进行内存的操作，而第二种则使用了我们前面所述的方法。虽然swap看上去代码可读性更好，但是因为效率的问题，方法1的运行时间会比方法2多出几倍。后面我会写专门的测试用例来验证这一点。

四、归并排序
算法复杂度nlogn
归并排序是比较经典的用空间换时间，是分治算法的一种典型运用，同时还用到了递归。归并算法很难用语言描述清楚，这里上两张图。

每次把数组进行划分，直到只有一个元素时数组就是有序的了，这时候递归返回，对Level2进行归并，这时候Level2就是有序的了，再返回，对Level1进行归并，以此类推。
归并的具体做法可以看下面这张图：

每次需要开辟一片新的内存来保存原来的数组数据，然后需要三个索引来进行操作，k每次的取值为x，y中较小的那个，同时需要考虑越界的问题，具体还是看代码来理解吧。

void insertionSort(int arr[], int l , int r){    for(int i = l + 1; i <= r; i++)    {        int temp = arr[i];        int pos = i;        for(int j = i - 1; j >= l; j--)        {            if(arr[j] > temp)            {                arr[pos] = arr[j];                pos = j;            }        }        arr[pos] = temp;    }}void doMerge(int arr[], int l, int mid, int r){    int aux[r - l + 1];    for(int i = l; i <= r; i++)    {        aux[i - l] = arr[i];    }    int x = l;    int y = mid + 1;    for(int k = l; k <= r; k++)    {        if(x > mid)        {            arr[k] = aux[y - l];            y++;        }        else if(y > r)        {            arr[k] = aux[x - l];            x++;        }        else if(aux[x - l] < aux[y - l])        {            arr[k] = aux[x - l];            x++;        }        else        {            arr[k] = aux[y - l];            y++;        }    }}//闭区间[l, r]void realMergeSort(int arr[], int l, int r){    if(r - l <= 15)    {        insertionSort(arr, l, r);        return;    }    int mid = (l + r) / 2;    realMergeSort(arr, l, mid);    realMergeSort(arr, mid + 1, r);    if(arr[mid] > arr[mid + 1])    {        doMerge(arr, l, mid, r);    }}void mergeSort(int arr[], int length){    realMergeSort(arr, 0, length - 1);}

注意这里在代码里还加入了两点优化：
1、当归并排序的数据区间小于某个值时，我们可以使用插入排序来替代归并。
2、只有arr[mid] > arr[mid + 1]时，才需要进行归并。

五、快速排序
算法复杂度nlogn
快速排序的思想也是分治思想+递归的一种典型实现，标准的快速排序就是把数组分成大于v和小于v的两部分，v一般取数组的第一个元素，分组成功后分别对大于v和小于v的部分继续进行快速排序。可看图参考：

可见这里需要三个索引，其中j记录的就是v最终应该所在的位置。

int partition(int arr[], int l, int r){    int v = arr[l];    int j = l;    for(int i = l + 1; i <= r; i++)    {        if(arr[i] < v)        {            swap(arr[j + 1], arr[i]);            j++;        }    }    swap(arr[l], arr[j]);    return j;}void realQuickSort(int arr[], int l, int r){    if(l >= r)    {        return;    }    int pos = partition(arr, l, r);    realQuickSort(arr, l, pos - 1);    realQuickSort(arr, pos + 1, r);}void quickSort(int arr[], int length){    realQuickSort(arr, 0, length - 1);}

标准的快排在面对基本有序的数组时性能会急剧下降，我们可以想见在上面的算法时其实我们对等于v的部分没有进行任何处理，所以对于基本有序的数组，这样的做法其实有大量的排序是做了无用功，这才有了更好的三路快速排序，上个图大概演示一下：

lt指向小于v的部分，gt指向大于v的部分，可见如果等于v的元素很多的时候，将大大减少算法的排序次数。

void realQuickSort3Ways(int arr[], int l, int r){    if( r - l <= 15 )    {        insertionSort(arr, l, r);        return;    }    swap( arr[l], arr[rand() % (r-l+1) + l]);    int v = arr[l];    int i = l + 1;    int lt = l;    int gt = r + 1;    while(i < gt)    {        if(arr[i] > v)        {            swap(arr[i], arr[gt - 1]);            gt--;        }        else if(arr[i] < v)        {            swap(arr[i], arr[lt + 1]);            lt++;            i++;        }        else        {            i++;        }    }    swap(arr[l], arr[lt]);    realQuickSort3Ways(arr, l, lt - 1);    realQuickSort3Ways(arr, gt, r);}void quickSort3Ways(int arr[], int length){    srand(time(NULL));    realQuickSort3Ways(arr, 0, length - 1);}

注意这里依然加入了两个优化，一个是前面提过的当数据量较小且基本有序时，插入排序是效率最高的，第二个是对数组进行一定的随机排序也可以提高快排的效率，这里涉及复杂的数学证明，就不赘述了。

基础排序的基本技巧就是控制好几个临界点，然后理解算法本身的执行流程，代码写起来才会行云流水。

先到这，这篇拖了好久了~