排序算法汇总

选择排序：

#include<stdio.h>
void SelectSort(int r[], int n);
int main() {
    int i;
    int text[] = { 1,4,5,3,2,5,767,5,6,12 };
    SelectSort(text, 10);
    printf("升序：");
    for (i = 0; i < 10; i++) {
        printf("%d ", text[i]);
    }
    printf("\n");
    getchar();
    return 1;
}
void SelectSort(int text[], int n)
{
    int i, j, index, temp;
    for (i = 0; i < n - 1; i++) {
        index = i;
        for (j = i + 1; j < n; j++) {
            if (r[j] < r[index]) index = j;
        }
        if (index != i) {
            temp = r[i]; r[i] = r[index]; r[index] = temp;
        }
    }
}

冒泡排序1：

#include<stdio.h>
void BubbleSort(int text[], int n);
int main() {
    int i;
    int text[] = { 1,4,5,3,2,5,767,5,6,12 };
    BubbleSort(text, 10);
    printf("升序：");
    for (i = 0; i < 10; i++) {
        printf("%d ", text[i]);
    }
    printf("\n");
    getchar();
}
void BubbleSort(int text[],int n) {
    int i, j,temp;
    for (j = 0; j < n - 1; j++) {
        for (i = 0; i < n - 1 - j; i++) {
            if (text[i] > text[i + 1]) {
                temp = text[i];
                text[i] = text[i + 1];
                text[i + 1] = temp;
            }
        }
    }
}

冒泡排序2：

#include<stdio.h>
void BubbleSort(int text[], int n);
int main() {
    int i;
    c = 0;
    e = 0;
    int text[] = { 1,4,5,3,2,5,767,5,6,12 };
    BubbleSort(text, 10);
    printf("升序：");
    for (i = 0; i < 10; i++) {
        printf("%d ", text[i]);
    }
    printf("\n");
    getchar();
    return 1;
}
void BubbleSort(int text[], int n)
{
    int bound, exchange,i,temp;
    exchange = n - 1;
    while (exchange != 0) {
        bound = exchange;
        exchange = 0;
        for (i = 0; i < bound; i++) {
            if (text[i]>text[i+1]) {
                temp = text[i];
                text[i] = text[i + 1];
                text[i + 1] = temp;
                exchange = i;
            }
        }
    }
}

冒泡排序2的时间复杂度：

比较次数：

$$\left\{\begin{array}{cc} n-1, & 最好\\ \frac{n(n+1)}{2}, & 最坏 \end{array}\right.$$
交换次数：
$$\left\{\begin{array}{cc} 0, & 最好\\ \frac{n(n+1)}{2}, & 最坏 \end{array}\right.$$
时间复杂度：
$$\left\{\begin{array}{cc} n-1+0=n-1=>O(n), & 最好\\ \frac{n(n+1)}{2}+\frac{n(n+1)}{2}=n(n-1=>O(n^2), & 最坏 \end{array}\right.$$

直接排序：

#include<stdio.h>
int main() {
    int i, j, len, temp, c, e;
    c = 0;
    e = 0;
    int text[] = { 1,4,5,3,2,5,767,5,6,12 };
    for (j = 0; j < 10; j++) {
        for (i = 0; i < 10; i++) {
            if (text[j] < text[i]) {
                temp = text[j];
                text[j] = text[i];
                text[i] = temp;
            }
        }
    }
    printf("降序：");
    for (i = 0; i < 10; i++) {
        printf("%d ", text[i]);
    }
    printf("\n");
    for (j = 0; j < 10; j++) {
        for (i = 0; i < 10; i++) {
            if (text[j] > text[i]) {
                temp = text[j];
                text[j] = text[i];
                text[i] = temp;
            }
        }
    }
    printf("升序：");
    for (i = 0; i < 10; i++) {
        printf("%d ", text[i]);
    }
    printf("\n");
    getchar();
    return 1;
}

归并排序

属于分治策略中的一种排序算法
声明：图片来源为：https://www.cnblogs.com/chengxiao/p/6194356.html

#include <iostream>
#include <string>
using namespace std;
void merge(int n[], int s, int m, int e, int temp[]) {
    int t = 0;
    int i = s;
    int j = m + 1;
    while (i <= m && j <= e) {
        if (n[i] > n[j]) {
            temp[t++] = n[j++];
        }
        else {
            temp[t++] = n[i++];
        }
    }
    while (i <= m) {
        temp[t++] = n[i++];
    }
    while (j <= e) {
        temp[t++] = n[j++];
    }
    cout <<"merge:" <<c<< endl;
    t = 0;
    while (s <=e) {
        n[s++] = temp[t++];
    }
}
void sort(int n[], int s, int e, int temp[]) {
    if (s < e) {
        int m = (s + e) / 2;
        sort(n, s, m, temp);
        sort(n, m + 1, e, temp);
        merge(n, s, m, e, temp);
    }
    cout <<"sort:"<< c << endl;
}
void main() {
    int n[] = { 1,3,8,7,4,9,2,5,11,10 };
    int temp[10];
    sort(n, 0, 9, temp);
    for (int i : n) {
        cout << i<<" ";
    }
    getchar();
}

时间复杂度：

时间复杂度=拆分（int m = (s + e) / 2）+解决问题（两个递归语句：2T(1/2n)）+合并（n）。
  其中拆分时间规模为一个常数，故可忽略不计，则有：2T(n/2)+n。
Tn=

$$\left\{\begin{array}{cc} 1, & n=1\\ 2T(n/2)+n, & n>1\\ \end{array}\right.$$
可得：
T(n)=O(nlog2n)

快速排序

交替扫描，递归重复

第一次划分结束后将pos-1看成左子段的high，将pos+1看成右子段的low，递归划分

int Partition(int T[],int s,int e){
    int i,j;
    i=s;
    j=e;
    while (i < j) {
        while (i<j&&T[i] <= T[j]) {
            j--;
        }
        if (i<j) {
            int temp = T[i];
            T[i] = T[j];
            T[j] = temp;
            i++;
        }
        while (j>i&&T[j] >= T[i]) {
            i++;
        }
        if (j>i) {
            int temp = T[i];
            T[i] = T[j];
            T[j] = temp;
            j--;
        }
    }
    return i;
}

void QuickSort(int T[],int s,int e){
    if(s<e){
        int p;
        p=Partition(T,s,e);
        QuickSort(T,s,p-1);
        QuickSort(T,p+1,e);
    }
}

void main(){
    int T[]={1,9,6,4,8,7,2,0,3};
    QuickSort(T,0,8);
    for(int t=0;t<9;t++){
        cout<<T[t]<<endl;
    }
    system("pause");
}

时间复杂度

最好情况：每次划分对一个记录定位后，该记录的左侧子序列与右侧的长度相同，时间复杂度同归并排序，为：
T(n)=2*T(n/2)+n,即O(nlog2n)

最坏情况：待排序为正序或者逆序，每次划分只得到一个比上一次划分少一个记录的子序列，此时，必须经过n-1次递归才能把所有记录定位，而且第i趟划分需要经过n-i次才能找到第i个记录的位置，所以时间复杂度为：
$\sum_{i=1}^{n-1}$(n-i)=1/2*n*(n-1)=O(n^2)