C++快速排序总结

#include <iostream>
#include <stack>
using namespace std;
//快速排序的非递归版本。
void Swap(int &a, int &b)
{
    int temp = a;
    a = b;
    b = temp;
}
int Sort(int a[],int low,int high)
{
    int i = low;
    int j = high;
    while (i < j)
    {
        while (i<j && a[j]>=a[high])j--;
        while (i < j && a[i] <= a[high])i++;
        if (i < j)
        {
            Swap(a[i],a[j]);
        }   
    }
    if (a[j]>a[high])
            Swap(a[j],a[high]);
        return j;
}
void Grial(int a[],int low,int high)
{
    stack<int> st;
    st.push(high);
    st.push(low);
    while (st.empty() == false)
    {
        int i = st.top();
        st.pop();
        int j = st.top();
        st.pop();

        if (i < j)
        {
            int mIdIndex = Sort(a,i,j);
            st.push(j);
            st.push(mIdIndex+1);
            st.push(mIdIndex);
            st.push(i);
        }
    }
}
int main()
{
    int a[] = { 6,5,3,3,-11 ,-1,-11,-11,129,3,21,3,421,-12};
    Grial(a, 0, sizeof(a) / sizeof(int)-1);
    for (int i = 0; i < sizeof(a) / sizeof(int); i++)
    {
        cout << a[i] << " ";
    }
    cout << endl;
    return 0;
}

#include <iostream>
using namespace std;

void Swap(int &a, int &b)
{
    int temp = a;
    a = b;
    b = temp;
}
void Grial(int a[],int low,int high)
{
    int i = low;
    int j = high;
    if (i >= j)return;
    int temp = a[high];
    while (i < j)
    {
        while (i < j && a[high] <= a[j])j--;

        while (i < j && a[high] >= a[i])i++;

        if (i < j)
        {
            Swap(a[i],a[j]);
        }
    }

    if (a[j]>a[high])
    Swap(a[j],a[high]);
    Grial(a, low, j);
    Grial(a, j + 1, high);
}

int main()
{
    int a[] = {5,3,6,2,5,6,7,2,1,3,4,5,6,8,4,5,7,8,9,354,1,1,23, 4,6,7,7,3};
    Grial(a, 0, sizeof(a) / sizeof(int)-1);
    for (int i = 0; i < sizeof(a) / sizeof(int); i++)
    {
        cout << a[i] << " ";
    }
    cout << endl;
    return 0;
}

#include <iostream>
using namespace std;
void Swap(int &a, int &b)
{
int temp = a;
a = b;
b = temp;
}
void Qulick(int a[], int low, int high)
{
    int i = low-1;
    int j = low;
    if (low >= high)return;
    while (j<high)
    {
        while (a[j] > a[high])j++;
        i++;
        if (i != j)
        {
            Swap(a[i], a[j]);
        }
        j++;
    }
    //这里比较到最后是不用交换的。
    //我个人比较喜欢这个版本，比较容易思考。
    Qulick(a, low, i);
    Qulick(a,i+1,high);
}

int main()
{
    int i = 0;
    int a[] = { 4,5,6,1,2,3,4,6,67,78,89,0,8,6,4,3,2,3,4
               ,5,6,6,7,7,6,6,4,3,3,3,4324,3,5,9 };
    Qulick(a, 0,sizeof(a) / sizeof(int)-1);
    for (i=0; i < sizeof(a)/sizeof(int); i++)
    {
        cout << a[i] << " ";
    }
    cout << endl;
    return 0;
}

#include <iostream>
using namespace std;
//堆的重要性不言而喻，求几十个亿数据里面最大的100个数，
//可以使用堆，效率最好。
class MaxHeap
{
public:
    MaxHeap(int a[],int n)
    {
        data = new int[n];
        for (int i = 0; i < n; i++)
        {
            data[i] = a[i];
        }
        size = n;
        n = size / 2;
        SetHeap(n);
    }
    void SetHeap(int n)
    {
        while (n--)
        {
            GetSet(data,n);
        }
    }
    void GetSet(int a[],int n)
    {
        int i = n;
        int j = 2 * i + 1;
        while (j < size)
        {
            if (j + 1 < size && a[j] > a[j + 1])
                j = j + 1;
            if (a[i]>a[j])
            {
                a[i] ^= a[j];
                a[j] ^= a[i] ;
                a[i] ^= a[j];
            }
            i = j;
            j = i * 2 + 1;
        }
    }
    void Sort()
    {
        int *b = new int[size-1];
        int k = 0;
        while (size)
        {
            b[k++] = data[0];
            data[0] = data[size - 1];
            size--;
            GetSet(data,0);
        }
        for (int i = 0; i < k; i++)
        {
            cout << b[i] << "  ";
        }
        cout << endl;
    }
private:
    int *data;
    int size;
};
int main()
{
    int i = 0;
    int a[20];
    for (; i < 20; i++)
    {
        a[i] = rand() % 20;
        cout << a[i] << "  ";
    }
    cout << endl;
    MaxHeap mh(a,sizeof(a)/sizeof(int));
    mh.Sort();
    return 0;
}