排序

1.插入排序
1）将整个数组看成待排序数组（本来就是，呵呵）
2）将第一个数看成已排序数列，第二个数看成待排序的数，将其插入到已排序数列，其实就是跟第一个数比大小，小于就插在前面，大于即插在后面
3）将第三个数看成待排序的数，重复第二个步骤，以此类推，直到最后一个数

void insert_sort(int a[], int n)
{
  int tmp;
  /*待排序部分*/
  for (int i=1; i<n; i++)
  {
    /*有序部分*/
    for (int j=0; j<i; j++)
    {
      /*找位置*/
      if (a[i] < a[j])
      {
        /*后移*/
        int k = i;
        tmp = a[i];
        while(k != j)
        {
          a[k] = a[k-1];
          k = k-1;
        }
        /*插入*/
        a[j] = tmp;
      }
    }
  }
}

时间复杂度O(n^2)

2.（二元）选择排序
1.从第0 ~ n-1元素里通过比较，记录最大和最小的下标，最小值与第0位交换，最大值与第n-1位交换。
2.依次执行完第i ~ n-1-i元素，由于依次能对当次的最大最小值排序，所以只需n/2 次就能完成

void swap(int a[], int min, int x, int max, int y)
{
  assert(a != NULL);
      cout << min << x << max << y <<endl;
  /*如果最大值与最小值分别在对方的位置上，直接交换*/
  if ((x == max) && (y == min))
  {
    int tmp = a[x];
    a[x] = a[y];
    a[y] = tmp;
    return;
  }
  int tmp_min = a[min];
  int tmp_max = a[max];
  a[min] = a[x];
  a[x] = tmp_min;
  a[max] = a[y];
  a[y] = tmp_max;
}

void select_sort(int a[], int n)
{
  assert(a != NULL);
  int max = 0;
  int min = 0;
  int tmp = 0;
  for (int i=0; i<n/2; i++)
  {
    max = i;
    min = i;
    for (int j=i; j<n-i; j++)
    {
      if (a[j] > a[max])
        max = j;
      else if (a[j] < a[min])
        min = j;
    }
    swap(a, min, i, max, n-1-i);
  }
}

时间复杂度O(n^2)

3.冒泡排序
1.待排序部分，从第一位开始，相邻两位比较，较大值向下沉

void bubble_sort(int a[], int n)
{
  assert(a != NULL);
  for (int i=0; i<n; i++)
  {
    /*待排序部分*/
    for (int j=1; j<n-i; j++)
    {
      /*较大值向下沉*/
      if (a[j-1] > a[j])
      {
        int tmp = a[j-1];
        a[j-1] = a[j];
        a[j] = tmp;
      }
    }
  }
}

时间复杂度O（n^2）

4.快速排序

int quicksort(vector<int> &v, int left, int right){
        if(left < right){
                int key = v[left];
                int low = left;
                int high = right;
                while(low < high){
                        while(low < high && v[high] > key){
                                high--;
                        }
                        v[low] = v[high];
                        while(low < high && v[low] < key){
                                low++;
                        }
                        v[high] = v[low];
                }
                v[low] = key;
                quicksort(v,left,low-1);
                quicksort(v,low+1,right);
        }
}