常用的排序算法

常用的排序算法

冒泡排序

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

选择排序

void SelectSort(vector<int> &arr)
{
    int n = arr.size();
    int minIdx = 0;
    for (int i = 0; i < n - 1; i++) {
        minIdx = i;
        for (int j = i + 1; j < n; j++) {
            if (arr[j] < arr[minIdx]) {
                minIdx = j;
            }
        }
        if (minIdx != i) {
            int tmp = arr[i];
            arr[i] = arr[minIdx];
            arr[minIdx] = tmp;
        }
    }
}

插入排序

void InsertSort(vector<int> &arr)
{
    int n = arr.size();
    for (int i = 1; i < n; i++) {
        int key = arr[i];
        int j = i-1;
        while (j >= 0 && key < arr[j]) {
            arr[j+1] = arr[j];
            j--;
        }
        arr[j+1] = key;
    }
}

快速排序

int Partation(vector<int> &arr, int left, int right)
{
    int piv = arr[left];
    while (left < right) {
        while (left < right && arr[right] >= piv) {
            right--;
        }
        arr[left] = arr[right];
        while (left < right && arr[left] <= piv) {
            left++;
        }
        arr[right] = arr[left];
    }
    arr[left] = piv;
    return left;
}

void QuickSort(vector<int> &arr, int left, int right) {
    if (left < right) {
        int piv = Partation(arr, left, right);
        QuickSort(arr, left, piv - 1);
        QuickSort(arr, piv+1, right);
    }
}

归并排序

void merge(vector<int> &arr, int left, int mid, int right)
{
    if (left >= right) {
        return;
    }
    vector<int> tmp(right - left + 1, 0);
    int i = left, j = mid + 1;
    int k = 0;
    while (i <= mid && j <= right) {
        if (arr[i] <= arr[j]) {
            tmp[k++] = arr[i++];
        } else {
            tmp[k++] = arr[j++];
        }
    }
    while (i <= mid) {
        tmp[k++] = arr[i++];
    }
    while (j <= right) {
        tmp[k++] = arr[j++];
    }
    for (k = 0; k < tmp.size(); k++) {
        arr[left + k] = tmp[k];
    }
}

void MergeSort(vector<int> &arr, int left, int right)
{
    if (left >= right) {
        return;
    }
    int mid = (left + right) / 2;
    MergeSort(arr, left, mid);
    MergeSort(arr, mid + 1, right);
    merge(arr, left, mid, right);
}

堆排序

void siftDown(vector<int> &arr, int n, int i)
{
    while (true) {
        int l = 2 * i + 1;
        int r = 2 * i + 2;
        int maxP = i;
        if (l < n && arr[l] > arr[maxP]) {
            maxP = l;
        }
        if (r < n && arr[r] > arr[maxP]) {
            maxP = r;
        }
        if (maxP == i) {
            break;
        }
        swap(arr[i], arr[maxP]);
        i = maxP;
    }
}

void HeapSort(vector<int> &arr)
{
    int n = arr.size();
    for (int i = n / 2 - 1; i >= 0; i--) {
        siftDown(arr, n, i);
    }
    for (int i = n - 1; i > 0; i--) {
        swap(arr[i], arr[0]);
        siftDown(arr, i, 0);
    }
}