c++实现堆的构造插入和删除、快排

快排

class my_quicksort {
public:
    void quicksort(vector<int>& a)
    {
        if (a.size() < 2)
            return;
        queue<pair<int, int>> s;
        s.push(make_pair(0, a.size() - 1));
        while (!s.empty())
        {
            int v = s.front().first;
            int w = s.front().second;
            s.pop();
            int j = q_sort(a, v, w);
            if (j > v + 1)s.push(make_pair(v, j - 1));
            if (j < w - 1)s.push(make_pair(j + 1, w));
        }
        cout << "非递归解:\n";
    }

    void quicksort(vector<int>& a, int l, int r)
    {
        if (l >= r)return;
        int j = q_sort(a, l, r);
        quicksort(a, l, j - 1);
        quicksort(a, j + 1, r);
        if(r == a.size() - 1 && l == 0)
            cout<< "递归解:\n";
    }

    int q_sort(vector<int>& a, int v, int w)
    {
        if (v >= w)return -1;
        int i = v;
        int j = w;
        int tmp = a[i];
        while (i < j)
        {
            while (a[j] >= tmp && i < j)j--;
            swap(a[i], a[j]);
            while (a[i] <= tmp && i < j)i++;
            swap(a[i], a[j]);
        }
        return j;
    }
};

堆排序

//这是小顶堆的实现过程，大顶堆同理
class my_heapsort {
public:
    void heapsort(vector<int>& a)
    {
        for (int i = a.size() / 2 - 1; i >= 0; i--)
        {
            heapsort_adjust(a, i, a.size());
        }
        for (int i = a.size() - 1; i >= 0; i--)
        {
            swap(a[0], a[i]);
            heapsort_adjust(a, 0, i);
        }
        cout << "排序后：\n";
        print_heap(a);
    }

    void heapsort_adjust(vector<int>& a,int index,int length)
    {
        int tmp = index * 2 + 1;
        while (tmp < length)
        {
            if (tmp + 1 < length && a[tmp] < a[tmp + 1])
                tmp++;
            if (a[index] > a[tmp])
                break;
            swap(a[index], a[tmp]);
            index = tmp;
            tmp = tmp * 2 + 1;
        }
    }
    void print_heap(vector<int> a)
    {
        int i = 2;
        for (int j = 0; j < a.size(); j++)
        {
            cout << a[j] << ' ';
            if (j == i - 2)
            {
                i <<= 1;
                cout << endl;
            }
        }
        cout << "\n\n";
    }
    void add(vector<int>& a, int s)  //向堆中加入元素
    {
        int pre = (a.size() - 1) / 2;
        int index = a.size();
        a.push_back(s);
        while (pre >= 0 && a[index] < a[pre])
        {
            swap(a[index], a[pre]);
            index = pre;
            pre = (pre - 1) / 2;
        }
        print_heap(a);
    }
    int del(vector<int>& a)  //删除堆首元素
    {
        if (a.empty())
            return -1;
        int s = a[0];
        a[0] = a.back();
        a.pop_back();
        int child = 1;
        int pre = 0;
        while (child < a.size())
        {
            if (child + 1 < a.size() && a[child] > a[child + 1])
                child++;
            if (a[pre] <= a[child])
                break;
            swap(a[pre], a[child]);
            pre = child;
            child = pre * 2 + 1;
        }
        print_heap(a);
        return s;
    }
};