排序总结及实现

#include <iostream>
#include <string>
#include <random>
#include <vector>
#include <queue>
#include <functional>
using namespace std;

class sort_test
{
public:
    int arr[10];
    int arr_length = sizeof(arr) / sizeof(arr[0]);
    vector<int> data;

public:
    sort_test()
    {
        random_device rd;
        mt19937 gen(rd());
        uniform_int_distribution<> dis(1, 100);
        for (int n = 0; n < 10; n++)
        {
            int D = dis(gen);
            arr[n] = D;
            data.push_back(D);
        }
    }

    void bubble_sort()
    {
        int n = sizeof(arr) / sizeof(arr[0]);
        for (int i = 0; i < n - 1; i++)
        {
            for (int j = 0; j < n - i - 1; j++)
            {
                if (arr[j + 1] < arr[j])
                {
                    swap(arr, j, j + 1);
                }
            }
        }
    }

    void select_sort()
    {
        int n = sizeof(arr) / sizeof(arr[0]);

        for (int i = 0; i < n - 1; i++)
        {
            int INIT_INDEX = i;
            for (int j = i + 1; j < n; j++)
            {
                if (arr[j] < arr[INIT_INDEX])
                {
                    INIT_INDEX = j;
                }
            }
            swap(arr, i, INIT_INDEX);
        }
    }

    void insert_sort()
    {
        int n = sizeof(arr) / sizeof(arr[0]);

        for (int end = 1; end < n; end++)
        {
            for (int pre = end - 1; pre >= 0 && arr[pre] > arr[pre + 1]; pre--)
            {
                swap(arr, pre, pre + 1);
            }
        }
    }

    void swap(int arr[], int i, int j)
    {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    void print()
    {
        int n = sizeof(arr) / sizeof(arr[0]);
        for (int i = 0; i < n; i++)
        {
            cout << arr[i] << " ";
        }
        cout << endl;
    }

    //---------------快速排序------------------//

    int position(int left, int right)
    {
        int begin = arr[left]; // 先保存下最左边的数

        while (left < right)
        {
            // 先右后左不能变
            while (left < right && arr[right] >= begin)
            {
                right--;
            }
            arr[left] = arr[right];

            while (left < right && arr[left] <= begin)
            {
                left++;
            }
            arr[right] = arr[left];
        }
        arr[left] = begin;
        return left;
    }

    void quick_sort(int left, int right)
    {
        if (left < right)
        {
            int mid = position(left, right);
            quick_sort(left, mid - 1);
            quick_sort(mid + 1, right);
        }
    }

    //---------------MergeSort-------------------//
    void merge(int low, int mid, int high)
    {
        vector<int> arr1;
        int i = low;
        int j = mid + 1;
        while (i <= mid && j <= high)
        {
            if (arr[i] < arr[j])
            {
                arr1.push_back(arr[i]);
                i++;
            }
            else
            {
                arr1.push_back(arr[j]);
                j++;
            }
        }

        while (i <= mid)
        {
            arr1.push_back(arr[i]);
            i++;
        }

        while (j <= high)
        {
            arr1.push_back(arr[j]);
            j++;
        }

        for (int k = 0; k < arr1.size(); k++, low++)
        {
            arr[low] = arr1[k];
        }
    }

    void merge_sort(int left, int right)
    {
        if (left < right)
        {
            int mid = (left + right) / 2;
            merge_sort(left, mid);
            merge_sort(mid + 1, right);
            merge(left, mid, right);
        }
    }

    //---------------------堆排序-------------------------//
    // 堆结构:完全二叉树结构
    // 左孩子: 2*i+1  右孩子:2*i+2  父:(i-1)/2
    // 若实现是从1开始的: 左孩子: 2*i*(i<<1)  右孩子:2*i+1(i<<1 | 1)  父:(i)/2(i>>1) 可转成位运算
    // 大根堆:每一颗子树的根节点最大(相反则是小根堆)
    class MyMaxHeap
    { // 大根堆的结构
    public:
        int *heap;
        int limit;
        int heapsize;

        MyMaxHeap(int limit)
        {
            this->heap = new int[limit];
            this->limit = limit;
            this->heapsize = 0;
        }

        bool isEmpty()
        {
            return heapsize == 0;
        }

        bool isFull()
        {
            return heapsize == limit;
        }

        void push(int value)
        {
            if (heapsize == limit)
            {
                throw runtime_error("heap is full");
            }

            heap[heapsize] = value;
            heapInsert(heap, heapsize++);
        }

        int pop()
        {
            int ans = heap[0];
            swap(heap, 0, --heapsize);
            heapify(heap, 0, heapsize);
            return ans;
        }

        void heapInsert(int arr[], int index)
        {
            // arr[index]
            // arr[index] 不比 arr[index父]大了,停
            // index = 0

            while (arr[index] > arr[(index - 1) / 2])
            {
                swap(arr, index, (index - 1) / 2);
                index = (index - 1) / 2;
            }
        }

        // 从index位置，往下看，不断的向下·沉
        // 停：我的孩子都不再比我大；已经没孩子了
        void heapify(int arr[], int index, int heapsize)
        {
            int left = index * 2 + 1;
            while (left < heapsize)
            { // 说明有孩子
                // 左右；两个孩子中，谁大，谁把自己的下标给largest
                // 右-> 1)有有孩子 && 2）右孩子的值比左孩子大才行
                // 否则左
                int largest = left + 1 < heapsize && arr[left + 1] > arr[left] ? left + 1 : left;
                largest = arr[largest] > arr[index] ? largest : index;
                if (largest == index)
                {
                    break;
                }
                swap(arr, largest, index);
                index = largest;
                left = index * 2 + 1;
            }
        }

        void swap(int arr[], int i, int j)
        {
            int tmp = arr[i];
            arr[i] = arr[j];
            arr[j] = tmp;
        }
    };

    void HeapSort(int arrSize)
    {
        if (arr == nullptr || arrSize < 2)
        {
            return;
        }

        MyMaxHeap heap(100);

        // O(N*logN)
        for (int i = 0; i < arrSize; i++)
        {
            heap.heapInsert(arr, i);
        }
        // O(N)
        //  for(int i = arrSize-1; i >= 0; i--){
        //      heap.heapify(arr, i, arrSize);
        //  }
        int heapSize = arrSize;
        heap.swap(arr, 0, --heapSize);
        // O(N*logN)
        while (heapSize > 0)
        {
            heap.heapify(arr, 0, heapSize);
            heap.swap(arr, 0, --heapSize);
        }
    }

    void PriorityQueue()
    {
        priority_queue<int> q1;
        for (auto n : data)
        {
            q1.push(n);
        }
        queue_print(q1);

        // greater<int>可使得最大优先队列变成最小优先队列行为
        priority_queue<int, vector<int>, greater<int>> q2(data.begin(), data.end());
        queue_print(q2);

        // 使用自定义的函数对象来实现最小优先队列
        struct
        {
            bool operator()(const int l, const int r) const { return l > r; };
        } comsless;
        priority_queue q3(data.begin(), data.end(), comsless);
        queue_print(q3);

        // 使用lambda表达式
        auto cmp = [](int left, int right){ return left > right; };
        // priority_queue q4(data.begin(), data.end(), cmp);
        priority_queue<int, vector<int>, decltype(cmp)> q4(cmp);
        for(auto n : data){
            q4.push(n);
        }
        queue_print(q4);
    }

    template <class Q>
    void queue_print(Q q)
    {
        while (!q.empty())
        {
            cout << q.top() << ',';
            q.pop();
        }
        cout << endl;
    }
};

int main()
{
    cout << "-----------------BubbleSort------------------" << endl;
    sort_test BubbleSort = sort_test();
    BubbleSort.print();
    BubbleSort.bubble_sort();
    BubbleSort.print();
    cout << "-----------------SelectSort------------------" << endl;
    sort_test SelectSort = sort_test();
    SelectSort.print();
    SelectSort.select_sort();
    SelectSort.print();
    cout << "-----------------InsertSort------------------" << endl;
    sort_test InsertSort = sort_test();
    InsertSort.print();
    InsertSort.insert_sort();
    InsertSort.print();
    cout << "-----------------QuickSort------------------" << endl;
    sort_test QuickSort = sort_test();
    QuickSort.print();
    QuickSort.quick_sort(0, QuickSort.arr_length - 1);
    QuickSort.print();
    cout << "-----------------MergeSort------------------" << endl;
    sort_test MergeSort = sort_test();
    MergeSort.print();
    MergeSort.merge_sort(0, QuickSort.arr_length - 1);
    MergeSort.print();
    cout << "------------------HeapSort------------------" << endl;
    sort_test HeapSort = sort_test();
    HeapSort.print();
    HeapSort.HeapSort(QuickSort.arr_length);
    HeapSort.print();

    cout << "------------------priority_queue------------------" << endl;
    sort_test PQ = sort_test();
    PQ.print();
    PQ.PriorityQueue();

    return 0;
}