排序

直接插入排序

个人总结的要点：第一先保证插入的次数，n个数需要插入n-1次。然后每次都要把新插入进来的数和前面已经排好的数进行比较，所以设置了一个while循环。第二，就是要把数插入之前排好的序列当中。如果出了while循环 ，在 i 到 j之间，某个位置（即 i++出来后的值）要插入a[j],所以要往后依次移动，必须从后面往前面移动。

void InsertSort(int* a, size_t size)
{
    for (size_t j = 1; j < size; j++)//插入次数
    {
        size_t i = 0;//每次都从最前面去比较，看看是不是插入的比                                                                              前面会小
        while (i < j && a[i] < a[j])
        {
            i++;    //如果进来就表明前面已经排好了，一旦出去表示，插入的数比i所在位置数小
        }
        int tmp = a[j];//下面移动时，就把a[j]的值覆盖了，所以要保存
        for (size_t index = j; index > i; index--) //把i后面的数据从后往前移动
        {
            a[index] = a[index - 1];
        }
        a[i] = tmp;
    }
}

希尔排序

个人总结要点：第一，保证分割段的间隔，一般使用gap=gap/3+1。第二，从gap到size中间进行的是插入排序，这是要点。第三，在插入的时候是距离gap个距离的数进行插入排序。

void ShellSort(int* a, int size)
{
    int gap = size;
    while (gap >1)
    {
        gap = gap / 3 + 1;
        for (int i = gap; i < size; i++)
        {
            int index = i;
            int tmp = a[index];//这个值可能会在比较中吧这个位置的值换掉
            int end = index - gap;

            while (end >= 0 && tmp < a[end])//这里其实就是一个段的插入排序。
            {
                a[end + gap] = a[end];
                end -= gap;
            }

            a[end+gap] = tmp;//为什么是+因为，如果从while里面出来，end是负的，此时其实是给a[end]赋值

        }
    }
}

冒泡排序

个人总结要点：首先区分这个和选择排序的区别，冒泡排序是泡泡往上冒，石头往下沉。就是说最小的数要往最前面走，大的数往下走。在这个过程中，大的数如果在小的数前面，那么就要交换值，然后在进行下一步。选择排序也是进行比较，只是单纯的记住下标，等一趟排序完了之后，才根据下标交换他们的值，从而把最大或者最小的放到最前面或者最后面。要点就是，在比较过程中，要不停交换。

void BubleSort(int* a,int size)
{
    for (int i = 0; i < size; i++)//控制循环次数
    {
        for (int j = i; j < size; j++)
        {
            if (a[i] > a[j])
            {

                int tmp = a[i];
                a[i] = a[j];
                a[j] = tmp;
            }
        }//相比于选择排序，这个碰到不是顺序的就交换，选择先记住下标，在每趟最后交换值
    }
}

快速排序

个人总结要点：之前总是对这个概念很模糊，后来用了半个小时认真按照概念走了一遍，发现这个很简单。（不清楚的一定要画图，画一遍就理解了），我写的这个是稍微优化了一点，但不影响说要点。第一，找到一个key值，定义两个值分别为头和尾的下标。从尾开始向前走，碰到小于key的，就和头交换，这时候尾位置不动。让头往后走，遇到比key大的，就和尾交换。就这样做，直到头尾相交，或者头超过尾。就这样很简单，两个while 就完成了。
优化：1.每次都把key倒来倒去，最终还是要倒到low的位置，索性直接最后让key值放到，a[low]位置得了，少了中间麻烦。

//int ThreeMid(int* a, int left, int right)
//{  //虽说是取三个数的中间数，到下面的程序就是取数组里面三个值得中间值
//  int mid = left + (left - right) / 2;
//  if (a[left] > a[right])
//  {
//      if (a[right] > a[mid])
//          return right;
//      if (a[mid] > a[left])
//          return left;
//      else
//          return mid;
//  }
//
//  if (a[right] > a[left])
//  {
//      if (a[left] > a[mid])
//          return left;
//      if (a[mid] > a[right])
//          return right;
//      else
//          return mid;
//  }
//}
void QuickSort(int* a, int left,int right)

{
    //int mid = ThreeMid(a, low, high);
    //swap(a[mid], a[high]);
    if (left >= right)
        return;
    int low = left;
    int high = right;
    int key = a[low];

    while (low < high)
    {
        while ( (low < high) && a[high] >= key)
        {
            --high;
        }
        a[low] = a[high];

        while ((low < high) && a[low] <= key)
        {
            ++low;
        }
        a[high] = a[low];


    }
    a[low] = key;

    QuickSort(a, left, low-1);
    QuickSort(a, low + 1, right);
}

选择排序

个人总结要点：这个挺简单一个排序，但要注意保存下标的值，最后再做交换。

void SelectSort(int*a, int size)
{
    for (int i = 0; i < size; i++)
    {
        int index = 0;
        for (int j = 0; j < size-i; j++)
        {
            if (a[index] < a[j])
            {
                index = j;              
            }   //让index成为最大值的下标
        }
        swap(a[size - i - 1], a[index]);
    }//每趟只有一次交换，比较次数和冒泡一样
}

堆排序

void HeapAdjust(int *a, int size, int root)
{
    int parent = root;
    int child = parent * 2 + 1;
    while (child < size)
    {
        if (child+1< size && a[child] < a[child + 1])
        {
            child++;
        }
        if (a[child] > a[parent])
        {
            swap(a[child], a[parent]);
            parent = child;
            child = parent * 2 + 1;
        }
        else
            break;
    }
}
void HeapSort(int* a,int size)
{
    for (int i = (size - 2) / 2; i >=0; i--)
    {
        HeapAdjust(a, size, i);
    }
    for (int i = 0; i < size; i++)
    {
        swap(a[0], a[size - i - 1]);
        HeapAdjust(a, size - i - 1, 0);
    }
}