各种排序算法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;
}

桶排序

计数排序

基数排序