1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

#include <iostream>
#include <vector>
using namespace std;

// 冒泡排序
void sort_maopao() {
    // 将下面10个数从小到大排列
    int a[] = {3,5,6,7,9,8,0,2,4,1};
    for (int i=0;i<10; ++i) {
       for (int j=0;j<10-i-1; ++j) {
           if (a[j] > a[j+1]) {
               int t = a[j];
               a[j] = a[j+1];
               a[j+1] = t;
           }
       }
    }

    for(int i=0;i<10;i++) {
        cout << "a[" << i << "]=" << a[i] << endl;
    }
}

void bubbleSort(vector<int>& arr) {
    int n = arr.size();
    for(int i=0; i < n-1; i++) {
        for(int j=0 ; j < n-i-1; j++) {
            if (arr[j] > arr[j+1]) {
                swap(arr[j],arr[j+1]);
            }
        }
    }
}

int main() {
    sort_maopao();
    cout << endl;
    vector<int> b = {1,3,5,10,6,9,2,7};
    bubbleSort(b);
    for(int i=0;i<b.size(); ++i) {
        cout << "b[" << i << "]:" << b[i] << endl;
    }
    return 0;
}
// g++ -o demo_sort --std=c++11 demo_sort.cpp

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

void selectSort(vector<int>& arr) {
    int n = arr.size();
    for (int i=0;i<n;++i) {
        int index = 0;
        // 找处前面n-i项中的最大项的arr[index]
        for (int j=1;j<n-i;++j) {
            if (arr[j] > arr[index]) {
                index = j;
            }
        }
        // 将arr[index]放到正确的位置arr[n-i0]
        swap(arr[index],arr[n-i-1]);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

void insertSort(vector<int>& arr) {
    int n = arr.size();
    for (int i=1;i<n;++i) {
        for(int j=i;j>0;j--) {
            if (arr[j] < arr[j-1]) {
                swap(arr[j],arr[j-1]);
            } else {
                break;
            }
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

void merge(vector<int>& v, int left, int mid, int right){
    vector<int> temp = v;
    int i = left, j = mid + 1;
    int index = left;
    while(i <= mid || j <= right){
        if(i > mid){
            v[index++] = temp[j];
            j++;
        }
        else if(j > right){
            v[index++] = temp[i];
            i++;
        }
        else if(temp[i] < temp[j]){
            v[index++] = temp[i];
            i++;
        }
        else{
            v[index++] = temp[j];
            j++;
        }
    }
}

1
2
3
4
5
6
7
8
9

void merge_Sort(vector<int>& v, int left, int right){
    if(left >= right) return;
    int mid = (left + right) / 2;
    merge_Sort(v, left, mid);
    merge_Sort(v, mid + 1, right);
    if(v[mid] > v[mid + 1]){
        merge(v, left, mid, right);
    }
}

1
2
3
4

void mergeSort(vector<int>& v){
    int n = v.size();
    merge_Sort(v, 0, n - 1);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

void quick_Sort(vector<int>& arr, int left, int right){
    if(left >= right) {
        return;
    }
    //取最左边的数为基数
    int i = left, j = right, base = arr[left];
    while(i < j){
        while(arr[j] >= base && i < j){
            j--;
        }
        while(arr[i] <= base && i < j){
            i++;
        }
        if(i < j){
            swap(arr[i], arr[j]);
        }
    } 
    arr[left] = arr[i];
    arr[i] = base;
    quick_Sort(arr, left, i - 1);
    quick_Sort(arr, i + 1, right);
}

void quickSort(vector<int>& arr){
    int n = arr.size();
    quick_Sort(arr, 0, n - 1);
}