排序算法

1.冒泡排序

#include<iostream>
using namespace std;
int main() {
  int n, a[100];
  cin >> n;
  for (int i = 0; i < n; i++) {
    cin >> a[i];
  }
  for (int i = 1; i < n; i++) {
    for (int j = 0; j < n-i; j++) {
      if (a[j+1] < a[j]) {
        swap(a[j+1], a[j]);
      }
    }
  }
  for (int i = 0; i < n; i++) {
    cout << a[i] << " ";
  }
} 

2.选择排序
 

for(int i = 1; i < n; i++) {
  for (int j = i+1; j < n- 1; j++) {
    if (a[i] < a[j]) {
      swap (a[i], a[j]);
    }
  }
} 

 

3.插入排序

for(int i = 1; i < n; i++) {
  for (int j = i; j > 0; j--) {
    if (a[j] < a[j-1]) {
      swap (a[j], a[j-1]);
    }
    else {
      break;
    }
  }
} 

4.希尔排序
  { 8 9 1 7 2 3 5 4 6 0 } 
a.初始增量为 gap = 10/2 = 5，整个数组分成了 5 组
【 8 , 3 】，【 9 , 5 】，【 1 , 4 】，【 7 , 6 】，【 2 , 0 】
b.  {3 5 1 6 0 8 9 4 7 2}    gap = 5/2 = 2；
【 3 , 1 , 0 , 9 , 7  】，【 5 , 6 , 8 , 4 , 2  】

对这分开的 2 组分别使用插入排序
{0  1  3  7  9} ，   { 2  4  5  6  8}
c.再缩小增量 gap = 2/2 = 1，整个数组分成了 1 组,合并成为

【 0, 2 , 1 , 4 , 3 , 5 , 7 , 6 , 9 , 8 】
d. 在用插入排序进行得 0 1 2 3 4 5 6 7 8 9

5.快速排序

#include<iostream>
using namespace std;
int a[100], n;
void quicksort(int l, int r) {
  int i, j, t, base;
  if (l > r) 
    return;
  base = a[l];
  i = l;
  j = r;
  while (i != j) {
    while (a[j] >= base && i < j) 
    j--;
    while (a[i] <= base && i < j)
    i++;
    if (i < j) {
      t = a[i];
      a[i] = a[j];
      a[j] = t;
    }
  }
  a[l] = a[i];
  a[i] = base;
  quicksort(l, i-1);
  quicksort(i+1, r);
}
int main() {
  cin >> n;
  for (int i = 0; i < n; i++) {
    cin >> a[i];
  }
  quicksort(0, n-1);
  for (int i = 0; i < n; i++) {
    cout << a[i] << " ";
  }
} 

20    40    50    10   60   
left                           right
a.base = 20 (参照物）
b，从数组right位置向前找，找到比base小的数（交换）
10  40  50  10  60
c.从数组的left位置向后找，一直找到比（base）大的数，
10  40  50  40  60
d.重复“第二,第三“步骤，直到left和right指针重合，
    、最后将（base）插入到40的位置，
      此时数组值为： 10，20，50，40，60，至此完成一次排序。
e.　quickSort(a,left,i-1);/*递归左边*/
　  quickSort(a,i+1,right);/*递归右边*/
6.归并排序

#include<iostream>
using namespace std;
int a[100], n;
void merge(int l,int r,int mid) {
  int aux[r-l+1], i,  j;
  for(int k = l; k <= r; k++)
    aux[k-l]=a[k];
  i = l;
  j = mid+1;
  for(int k = l;k <= r; k++) {
    if(i > mid) {
      a[k] = aux[j-l];
       j++;
     }
     else if(j > r) {
       a[k] = aux[i-l];
       i++;
      }
     else if(aux[i-l]>aux[j-l]) {
        a[k] = aux[j-l];
         j++;
      }
      else {
          a[k] = aux[i-l];
          i++;
         }
    }        
}
void merge_sort(int l,int r) {
    if(l >= r) return;
      int mid = (l+r) / 2;
      merge_sort(l, mid);
      merge_sort(mid+1, r);
      merge(l, r, mid);        
}
void mergesort(int l,int r) {
    merge_sort(l, r-1);
} 
int main() {
    cin >> n;
  for (int i = 0; i < n; i++) {
    cin >> a[i];
  }
  mergesort(0, n);
  for (int i = 0; i < n; i++) {
    cout << a[i] << " ";
  }
 }

自上而下的递归（所有递归的方法都可以用迭代重写，所以就有了第 2 种方法）；
自下而上的迭代；首先，将数字分割成两片区域
再将数字分割成两片区域依次划分直到每片区域只有一个元素分割完成
接下来，将分割的每片区域进行合并组合，合并时，按照数字的升序移动，使得合并后的数字在组内按升序排列
  当合并包含多个数字的组时，比较开头的数字，移动其中较小的数字
递归的重复组的合并操作，直到所有数字都在一个组中。
完成 归并排序 和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是 O(nlogn) 的时间复杂度。代价是需要额外的内存空间。
7.桶排序
  桶排序(Bucket sort)是一种基于计数的排序算法，工作的原理是将数据分到有限数量的桶子里，然后每个桶再分别排序
堆排序
 

#include<iostream>
using namespace std;
int a[100], n;
void maxheap_down(int start, int end) {
  int c = start;
  int l = 2*c + 1;//左孩子 
  int tmp = a[c];//节点
  for (; l <= end; c = l, l = 2*l+1) {
    if (l < end && a[l] < a[l+1]) 
      l++;
    if (tmp >= a[l]) 
      break;
    else {
      a[c] = a[l];
      a[l] = tmp;
    }
  } 
}
void heap_sort_asc() {
  for (int i = n/2-1; i >= 0; i--) 
    maxheap_down(i, n-1);
  for (int i = n-1; i > 0; i--) {
    swap(a[0], a[i]);
    maxheap_down(0, i-1);
  }
}
int main() {
    cin >> n;
  for (int i = 0; i < n; i++) {
    cin >> a[i];
  }
  heap_sort_asc();
  for (int i = 0; i < n; i++) {
    cout << a[i] << " ";
  }
 }