c++实现十大经典排序算法

#include <iostream>
#include <vector>

std::vector<int> g_array {
    12, 3, 52, 65, 9, 29,16, 7, 2, 78, 63, 98, 23, 43, 1, 24, 84, 34, 94, 32
};
void Swap(std::vector<int>& array, int i, int j) {
    int temp = array[j];
    array[j] = array[i];
    array[i] = temp;
}
void ShowArray(std::vector<int>& array) {
    for (int i = 0; i < array.size(); ++i) {
        std::cout << array[i] << " ";
    }
    std::cout << "\n";
}

// ----------------比较排序-----------------
// 冒泡排序：交换，时间复杂度O(n)- O(n2)，空间复杂度O(1)
void BubbleSort(std::vector<int>& array);
// 快速排序：分治法+交换+双重游标，时间复杂度O(nlogn) - O(n2)，空间复杂度O(nlogn).递归算法每次都要存储栈信息，因此为nlogn
void QuickSort(std::vector<int>& array, int begin, int end);
// 插入排序：有序子序列 + 插入位置 + 连续数量移动，时间复杂度O(n) - O(n2),空间复杂度O(1)
void InsertionSort1(std::vector<int>& array);   // 找到位置后移动
void InsertionSort2(std::vector<int>& array);   // 比较相邻元素，然后交互
// shell 排序：宏观调控 + 增量子序列 + 增量减少至1。时间复杂度O(n1.3) - O(n2)，空间复杂度O(1)。shell增量的选择是个数学难题，一般采用length/作为步长
void ShellSort1(std::vector<int>& array);   // 找到位置后移动
void ShellSort2(std::vector<int>& array);   // 比较相邻元素，然后交互
// 选择排序.O(n2)，空间复杂度O(1).找到最小元素，放到队列头，队列头有序。以此类推
void SelectionSort(std::vector<int>& array);
// 堆排序. 时间复杂度O(nlogn)，空间复杂度O(nlogn)
void HeapSort(std::vector<int>& array);
// 归并排序.时间复杂度O(nlogn)，空间复杂度O(nlogn)
void MergeSort(std::vector<int>& array, int begin, int end);
// -----------------非比较排序----------------
// 计数排序.时间复杂度O(n+k),空间复杂度O(n+k)，k是整数取值范围.快过任何比较排序算法，但是对空间要求较高，适用于有限小范围的区域
void CountingSort(std::vector<int>& array, int max = 100);
// 桶排序,是计数排序的升级版本。时间复杂度O(n+k) - O(n2),空间复杂度O(n+k)，k是整数取值范围.快过任何比较排序算法，但是对空间要求较高，适用于有限小范围的区域
// 计数排序申请的空间比较大，如果分散不均匀，很多空间未访问，会造成浪费。桶排序取出最大值和最小值的差值，划分成若干个 连续+范围递增 的数组，每个数组进行内部排序
void BucketSort(std::vector<int>& array);
// 基数排序.时间复杂度O(n*k),空间复杂度O(n+k)
void RadixSort(std::vector<int>& array);

int main() {
//    BubbleSort(g_array);
//    QuickSort(g_array, 0, g_array.size() - 1);
//    InsertionSort2(g_array);
//    ShellSort2(g_array);
//    SelectionSort(g_array);
//    HeapSort(g_array);
//    MergeSort(g_array, 0, g_array.size() - 1);
//    CountingSort(g_array);
//    BucketSort(g_array);
    RadixSort(g_array);
    ShowArray(g_array);
    return 0;
}

void BubbleSort(std::vector<int>& array) {
    const size_t sz = array.size();
    if (sz <= 1) {
        return;
    }
    for (int i = 0; i < sz; ++i) {
        for (int j = 0; j < sz - i - 1; ++j) {
            if (array[j] > array[j + 1]) {
                Swap(array, j, j + 1);
            }
        }
    }
}

void QuickSort(std::vector<int>& nums, int l ,int r) {
    if (l < r) {
        const int target = nums[l];
        int b = l + 1;
        int e = r;
        while (b < e)
        {
            if (nums[b] >= target && nums[e] < target) {
                Swap(nums, b, e);
            }
            if (nums[b] < target) {
                b++;
            }
            if (nums[e] >= target) {
                e--;
            }
        }
        if (nums[l] > nums[b]) {
            Swap(nums, b, l);
        }
        QuickSort(nums, l, b - 1);
        QuickSort(nums, b, r);
    }
}

void InsertionSort1(std::vector<int> &array) {
    const size_t sz = array.size();
    if (sz <= 1) {
        return;
    }
    for (int i = 1; i < sz; ++i) {
        const int target = array[i];
        int j = i;
        for (; j > 0; --j) {
            if (array[j - 1] <= target) {
                break;
            }
        }
        for (int k = i; k > j; --k) {
            array[k] = array[k - 1];
        }
        array[j] = target;
    }
}

void InsertionSort2(std::vector<int> &array) {
    const size_t sz = array.size();
    if (sz <= 1) {
        return;
    }
    for (int i = 1; i < sz; ++i) {
        const int target = array[i];
        int j = i;
        for (; j > 0 && array[j] < array[j - 1]; --j) {
            Swap(array, j, j -1);
        }
        array[j] = target;
    }
}

void ShellSort1(std::vector<int> &array) {
    const size_t sz = array.size();
    if (sz <= 1) {
        return;
    }
    for (int gap = sz/2; gap > 0; gap = gap/2) {
        for (int i = 0; i < gap; ++i) {
            // 对每组增量进行插入排序
            for (int j = i + gap; j < sz; j += gap) {
                const int target = array[j];
                int k = j;
                for (; k > 0; k -= gap) {
                    if (array[k - gap] < target) {
                        break;
                    }
                }
                for (int l = j; l > k; l -= gap) {
                    array[l] = array[l - gap];
                }
                array[k] = target;
            }
        }
    }
}

void ShellSort2(std::vector<int> &array) {
    const size_t sz = array.size();
    if (sz <= 1) {
        return;
    }
    for (int gap = sz/2; gap > 0; gap = gap/2) {
        for (int i = gap; i < sz; ++i) {
            const int target = array[i];
            int j = i;
            for (; j >= gap && array[j] < array[j - gap]; j = j - gap) {
                Swap(array, j, j - gap);
            }
            array[j] = target;
        }
    }
}

void SelectionSort(std::vector<int> &array) {
    const size_t sz = array.size();
    if (sz <= 1) {
        return;
    }
    for (int i = 0; i < sz; ++i) {
        int min = array[i];
        int index = i;
        for (int j = i; j < sz; ++j) {
            if (array[j] < min) {
                min = array[j];
                index = j;
            }
        }
        Swap(array, index, i);
    }
}

void AdjustHeap(std::vector<int> &array, int parent, int sz) {
    if (sz <= 1) {
        return;
    }
    const int left = parent*2 + 1;
    if (left >= sz) {
        return;
    } else {
        const int right = parent*2 + 2;
        if (right >= sz) {
            if (array[parent] < array[left]) {
                Swap(array, parent, left);
                AdjustHeap(array, left, sz);
            }
        } else {
            int max = array[right] < array[left] ? left : right;
            if (array[parent] < array[max]) {
                Swap(array, parent, max);
                AdjustHeap(array, max, sz);
            }
        }
    }
}

void HeapSort(std::vector<int> &array) {
    const size_t sz = array.size();
    if (sz <= 1) {
        return;
    }
    // 构建大顶堆
    for (int i = sz - 1; i > 0; i = i - 2) {
        const int parent = i/2;
        AdjustHeap(array, parent, sz);
    }
    // 交换最大元素到末尾
    for (int j = 1; j <= sz; ++j) {
        Swap(array, 0, sz - j);
        AdjustHeap(array, 0, sz - j);
    }
}

std::vector<int> temp;
void MergeSort(std::vector<int> &array, int begin, int end) {
    const size_t sz = end - begin + 1;
    if (sz <= 1) {
        return;
    }
    int mid = (begin + end)/2;
    MergeSort(array, begin, mid);
    MergeSort(array, mid + 1, end);

    int left = begin;
    int right = mid + 1;

    temp.resize(sz);
    for (int i = begin; i <= end; ++i) {
        int min;
        if (left > mid) {
            min = right++;
        } else if (right > end) {
            min = left++;
        } else if (array[left] < array[right]) {
            min = left++;
        } else {
            min = right++;
        }
        temp.push_back(array[min]);
    }
    for (int i = begin; i <= end; ++i) {
        array[i] = temp[i - begin];
    }
}

void CountingSort(std::vector<int> &array, int max) {
    const size_t sz = array.size();
    if (sz <= 1) {
        return;
    }
    std::vector<int> count(max, 0);
    for (int i = 0; i < sz; ++i) {
        count[array[i]]++;
    }
    array.clear();
    array.reserve(sz);
    for (int j = 0; j < max; ++j) {
        while (count[j]-- > 0) {
            array.push_back(j);
        }
    }
}

void BucketSort(std::vector<int> &array) {
    const size_t sz = array.size();
    if (sz <= 1) {
        return;
    }
    int max = std::numeric_limits<int>::min();
    int min = std::numeric_limits<int>::max();
    for (int i = 0; i < sz; ++i) {
        if (array[i] > max) {
            max = array[i];
        }
        if (array[i] < min) {
            min = array[i];
        }
    }
    const int bucketCount = 1;
    std::vector<std::vector<int>> buckets;
    buckets.resize(bucketCount);
    const int bucketRangeIncrease = (max - min)/bucketCount + 1;    // 这里+1很重要
    for (int j = 0; j < sz; ++j) {
        // 采用相对法，保证(array[j] - min)一定>=0。如果带排序内有负数，则下标计算出来是负值
        buckets[(array[j] - min)/bucketRangeIncrease].push_back(array[j]);
    }
    array.clear();
    for (int k = 0; k < bucketCount; ++k) {
        if (buckets[k].empty()) {
            continue;
        }
        InsertionSort1(buckets[k]);
        for (int i = 0; i < buckets[k].size(); ++i) {
            array.push_back(buckets[k][i]);
        }
    }
}

void RadixSort(std::vector<int> &array) {
    const size_t sz = array.size();
    if (sz <= 1) {
        return;
    }
    int max = std::numeric_limits<int>::min();
    for (int i = 0; i < sz; ++i) {
        if (max < array[i]) {
            max = array[i];
        }
    }
    int count = 1;
    int radix = 1;
    while (max / radix > 10) {
        radix *= 10;
        count++;
    }
    std::vector<std::vector<int>> buckets;
    for (int j = 1; j <= count; ++j) {
        buckets.clear();
        buckets.resize(10); // 0 - 9
        radix = 1;
        for (int k = 1; k < j; ++k) {
            radix *= 10;
        }
        for (int i = 0; i < sz; ++i) {
            int index = (array[i] / radix) % 10;
            buckets[index].push_back(array[i]);
        }
        array.clear();
        array.reserve(sz);
        for (int l = 0; l < 10; ++l) {
            for (int i = 0; i < buckets[l].size(); ++i) {
                array.push_back(buckets[l][i]);
            }
        }
    }
}