各种排序算法C++

各种排序算法

插入排序

直接插入排序

void InsertSort(int arr[], int len) {    int i, j;    int temp;    for (i = 1; i < len; i++) {        temp = arr[i];        for (j = i - 1; j >= 0 && arr[j] > temp; j--)            arr[j + 1] = arr[j];        arr[j + 1] = temp;    }}

插入排序的时间复杂度最好的情况是已经是正序的序列，只需比较(n−1)次，时间复杂度为O(n)，最坏的情况是倒序的序列，要比较n(n−1)2次，时间复杂度为O(n2)，平均的话要比较时间复杂度为O(n2).

shell(希尔)排序

int* shellSort(int* A, int n) {    int step = n/3;    while (step>0) {        if(step == 2)            step = 1;        for (int i=step; i<n; ++i) {            int j = i;            while (j-step>=0 && A[j-step] > A[j]) {                swap(A[j-step], A[j]);                j -=step;            }        }        step /= 3;    }    return A;}

选择排序

直接选择排序

void selectSort(int* arr, int len){    for (int i = 0; i<len; i++) {        int min = i;        for (int j = i; j<len; j++) {            if (arr[j] < arr[min]) {                min = j;            }        }        swap(arr[i], arr[min]);    }}

堆排序

//堆调整void HeapAdjust(int arr[], int first, int end){    int father = first;    int son = father * 2 + 1;    while (son < end) {        if (son + 1 < end && arr[son] < arr[son+1])             ++son;        if (arr[father] > arr[son])             break;//如果父节点大于子节点则表示调整完毕        else {            swap(arr[father], arr[son]);    //不然就交换父节点和子节点的元素            father = son;   //父和子节点变成下一个要比较的位置            son = 2 * father + 1;        }    }}//堆排序void HeapSort(int arr[], int len) {    int i;     for (i = len/2 - 1; i >= 0; --i) {        HeapAdjust(arr, i, len); //初始化堆，从最后一个父节点开始    }    for (i = len - 1; i > 0; --i) {        swap(arr[0], arr[i]);   //从堆中的取出最大的元素再调整堆        HeapAdjust(arr, 0, i);  //调整成堆    }}

堆排序的时间复杂度最好到最坏都是O(nlogn)，较多元素的时候效率比较高

交换排序

冒泡排序

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

void bubbleSort2(int arr[],int len) {    for (int i = 0; i<len; i++) {        int flag = 0;        for (int j = 1; j<len-i; j++) {            if (arr[j-1] > arr[j]) {                flag = 1;                swap(arr[j-1], arr[j]);            }        }        if (!flag)  break;    }}

快速排序

int Partition(int arr[], int first, int last) {    int tmp = arr[last];    while (first < last) {        while (first < last && arr[first] <= tmp)            first++;        swap(arr[first], arr[last]);        while (first < last && arr[last] >= tmp)            last--;        swap(arr[first], arr[last]);    }    return first;}void quickSortPart(int arr[], int first, int last) {    if (first >= last) return;    int mid = Partition(arr, first, last);    quickSortPart(arr, first, mid - 1);    quickSortPart(arr, mid + 1, last);}void quickSort(int arr[],int len) {    quickSortPart(arr, 0, len-1);}

归并排序

void merge(int arr[], int tmp[], int first, int mid, int last) {    int i = first;    int j = mid+1;    int k = first;    while (i<=mid && j<=last) {        if (arr[i] < arr[j]) {            tmp[k++] = arr[i++];        }        else{            tmp[k++] = arr[j++];        }    }    while (i<=mid) {        tmp[k++] = arr[i++];    }    while (j<=last) {        tmp[k++] = arr[j++];    }    for (i = first; i<=last; i++) {        arr[i] = tmp[i];    }}void mergeSortPart(int arr[], int tmp[], int first, int last) {    if (first >= last) return;    int mid = first + (last -first) / 2;    mergeSortPart(arr, tmp, first, mid);    mergeSortPart(arr, tmp, mid+1, last);    merge(arr, tmp, first, mid, last);}void mergeSort(int arr[],int len) {    int *tmp = new int[len];    mergeSortPart(arr, tmp, 0, len - 1);    delete [] tmp;}

桶排序

计数排序

基数排序