算法：分治策略2

---

一、快速排序

1.快速排序之乱序

int Parition(int* br, int left, int right)
{
    int tmp = br[left];
    while (left < right)
    {
        while (left<right && br[right]>tmp)
        {
            --right;
        }
        if (left < right)
        {
            br[left] = br[right];
        }
        while (left < right && br[left <= tmp])
        {
            ++left;
        }
        if (left < right)
        {
            br[right] = br[left];
        }
    }
    br[left] = tmp;
    return left;
}
int Parition(int* br, int left, int right)
{
    int pos = rand() % (right - left);
    std::swap(br[left], br[pos]);
    return Parition(br, left, right);
}

2.快速排序之三位取中法

#include<iostream>
#include<list>
#include<vector>
#include<queue>
#include<stack>
#include<stdio.h>
#include<algorithm>
using namespace std;

typedef int ElemType;
typedef struct ListNode
{
    ElemType data;
    struct ListNode* next;
}ListNode, * LinkList;
ListNode* ListQuickParition(ListNode* left, ListNode* right)
{
    ListNode* i = left->next;
    ListNode* j = left;
    int tmp = i->data;
    while (i != right)
    {
        if (i->data <= tmp)
        {
            j = j->next;
            swap(j->data, i->data);
        }
        i = i->next;
    }
    swap(left->next->data, i->data);
    
    ListQuickParition(left, i);
    ListQuickParition(i, right);
}
void Print_Ar(const int* br, int n)
{
    if (br == NULL || n < 1) return;
    for (int i = 0; i < n; ++i)
    {
        cout << br[i] << " ";
    }
    cout << endl;
}
int Parition(int* br, int left, int right)
{
    int tmp = br[left];
    while (left < right)
    {
        while (left < right && br[right]>tmp)
        {
            --right;
        }
        if (left < right)
        {
            br[left] = br[right];
        }
        while (left < right && br[left] <= tmp)
        {
            ++left;
        }
        if (left < right)
        {
            br[right] = br[left];
        }
    }
    br[left] = tmp;
    return left;
}
void PassQuick(int* br, int left, int right)
{
    if (left < right)
    {
        int pos = Parition(br, left, right);
        PassQuick(br, left, pos - 1);
        PassQuick(br, pos + 1, right);
    }
}
void QuickSort(int* br, int n)//非递归排序算法
{
    if (br == NULL || n < 2) return;
    queue<int> qu;
    qu.push(0);
    qu.push(n - 1);
    while (!qu.empty())
    {
        int left = qu.front();
        qu.pop();
        int right = qu.front();
        qu.pop();
        int pos = Parition(br, left, right);
        if (left < pos - 1)
        {
            qu.push(left);
            qu.push(pos - 1);
        }
        if (pos + 1 < right)
        {
            qu.push(pos + 1);
            qu.push(right);
        }
    }
}
void QuickSort(int* br, int n)//递归排序算法
{
    if (br == NULL || n < 2) return;
    PassQuick(br, 0, n - 1);
}
void QuickSort(int* br, int n)//队排序算法(第一种)
{
    if (br == NULL || n < 2) return;
    queue<std::pair<int, int>> qu;
    qu.push(std::pair<int, int>(0, n - 1));//左边和右边
    while (!qu.empty())
    {
        std::pair<int, int> pos = qu.front();
        qu.pop();
        int mid = Parition(br, pos.first, pos.second);
        if (pos.first < mid - 1)
        {
            qu.push(std::pair<int, int>(pos.first, mid - 1));
        }
        if (mid + 1 < pos.second)
        {
            qu.push(std::pair<int, int>(mid + 1, pos.second));
        }
    }
}
int Parition(int* br, int left, int right)//双向划分
{
    int tmp = br[left];
    while (left < right)
    {
        while (left<right && br[right]>tmp)
        {
            --right;
        }
        if (left < right)
        {
            br[left] = br[right];
        }
        while (left < right && br[left <= tmp])
        {
            ++left;
        }
        if (left < right)
        {
            br[right] = br[left];
        }
    }
    br[left] = tmp;
    return left;
}
int LeftParition(int* br, int left, int right)//单向划分
{
    int j = left - 1;
    int i = left;
    int tmp = br[i];
    while (i <= right)
    {
        if (br[i] <= tmp)
        {
            j = j + 1;
            swap(br[j], br[i]);
        }
        ++i;
    }
    swap(br[left], br[j]);
    return j;
}
int RandParition(int* br, int left, int right)//随机法划分
{
    srand(time(NULL));
    int pos = rand() % (right - left);
    std::swap(br[left], br[pos]);
    return Parition(br, left, right);
}
int MidParition(int* br, int left, int right)//三位取中法划分
{
    int mid = (right - left) / 2 + left;
    struct IndexNode
    {
        int key;
        int index;

        operator int() const//强转
        {
            return key;
        }
    };
    struct IndexNode kL = { br[left],left };
    struct IndexNode kM = { br[mid],mid };
    struct IndexNode kR = { br[right],right };
    
    std::priority_queue<IndexNode> hp;
    hp.push(kL);
    hp.push(kM);
    hp.push(kR);
    hp.pop();
    struct IndexNode pos = hp.top();

    std::swap(br[kL.index], br[pos.index]);
    return Parition(br, left, right);
}
void QuickSort(int* br, int n)//队排序算法(第二种)
{
    if (br == NULL || n < 2) return;
    typedef std::pair<int, int> Pair;//typedef关键使程序更加清楚
    queue<Pair> qu;
    qu.push(Pair(0, n - 1));
    while (!qu.empty())
    {
        Pair pos = qu.front();
        qu.pop();
        int mid = Parition(br, pos.first, pos.second);
        if (pos.first < mid - 1)
        {
            qu.push(Pair(pos.first, mid - 1));
        }
        if (mid + 1 < pos.second)
        {
            qu.push(Pair(mid + 1, pos.second));
        }
    }
}
int FindK(int* br, int left, int right, int k)
{
    if (left == right && k == 1)
    {
        return br[left];
    }
    int pos = Parition(br, left, right);
    int j = pos - left + 1;
    if (k <= j)
    {
        return FindK(br, left, pos, k);
    }
    else
    {
        return FindK(br, pos + 1, right, k - j);
    }
}
int FindK_Min(int* br, int n, int k)//寻找第k小的元素
{
    if (br == NULL || k<0 || k>n)
    {
        return -1;
    }
    return FindK(br, 0, n - 1, k);
}
int main()
{
    int ar[] = { 56,12,78,90,34,23,100,56,45,67,89 };
    int n = sizeof(ar) / sizeof(ar[0]);
    Print_Ar(ar, n);
    QuickSort(ar, n);
    int k = 3;
    int elem = FindK_Min(ar, n, k);
    Print_Ar(ar, n);
    return 0;
}

二、算法之合并排序

1.合并排序

#include<iostream>
#include<list>
#include<vector>
#include<queue>
#include<stack>
#include<stdio.h>
#include<algorithm>
using namespace std;

typedef int ElemType;
typedef struct ListNode
{
    ElemType data;
    struct ListNode* next;
}ListNode, * LinkList;
/*ListNode* ListQuickParition(ListNode* left, ListNode* right)
{
    ListNode* i = left->next;
    ListNode* j = left;
    int tmp = i->data;
    while (i != right)
    {
        if (i->data <= tmp)
        {
            j = j->next;
            swap(j->data, i->data);
        }
        i = i->next;
    }
    swap(left->next->data, i->data);
    
    ListQuickParition(left, i);
    ListQuickParition(i, right);
}*/
void Print_Ar(const int* br, int n)
{
    if (br == NULL || n < 1) return;
    for (int i = 0; i < n; ++i)
    {
        cout << br[i] << " ";
    }
    cout << endl;
}
void Copy(int* src, int* dest, int left, int right)
{
    while (left <= right)
    {
        dest[left] = src[left];
        left++;
    }
}
void Merge(int* src, int* dest, int left, int m, int right)//合并排序
{
    int i = left, j = m + 1;
    int k = left;
    while (i <= m && j <= right)
    {
        dest[k++] = src[i] <= src[j] ? src[i++] : src[j];
    }
    while (i <= m )
    {
        dest[k++] = src[i++];
    }
    while (j <= right)
    {
        dest[k++] = src[j++];
    }
}
void MergePass(int* src, int* dest, int left, int right)
{
    if (left < right)
    {
        int mid = (right + left) / 2;
        MergePass(src, dest, left, mid);
        MergePass(src, dest, mid + 1, right);

        Merge(src, dest, left, mid, right);
        Copy(dest, src, left, right);
    }
}
void MergeSort(int* br, int n)
{
    if (br == NULL || n < 2)
    {
        return;
    }
    int* tmp = new int[n];
    MergePass(br, tmp, 0, n - 1);
    delete[]tmp;
}

---