排序

//排序算法的代码实现
//时间：2018.08.23
//作者：周晴

#include<iostream>
#include<vector>
#include <algorithm>
using namespace std;  
#define MAXSIZE 10
#define MAX_LENGTH_INSERT_SORT 7

//用于排序的顺序表的结构
struct sqList {
    int r[MAXSIZE + 1];
    int length;
};

//交换L中数组r的下标为i和j的值
void swap(sqList *L,int i,int j) {
    int temp = L->r[i];
    L->r[i] = L->r[j];
    L->r[j] = temp;
}

class Sortieren {
public:
    //冒泡排序:两两进行比较，不符合次序的交换
    void bubbleSort(sqList *L) {
        for (int i = 1; i < L->length; i++) {
            //从后向前循环
            for (int j = L->length-1; j >= i; j--) {
                if (L->r[j] > L->r[j + 1])
                    swap(L, j, j+1);
            }
        }

    }

    //冒泡排序的优化，加入标志位，在一轮比较中，若无移动，则为有序，停止
    void bubbleSortbetter(sqList *L) {
        bool ifSort = true;
        for (int i = 0; i < L->length&&ifSort; i++) {
            ifSort = false;//标志位
            //从后向前循环
            for (int j = L->length - 1; j >= i; j--) {
                if (L->r[j] > L->r[j + 1]) {
                    swap(L, i, j);
                    ifSort = true;
                }
            }
        }
    }

    //简单选择排序
    void simpleChooseSort(sqList *L) {
        for (int i = 1; i < L->length; i++) {
            int min = i;
            for (int j = i + 1; j <= L->length; j++) {
                if (L->r[j] < L->r[min]) {
                    min = j;
                }
            }
            if (min != i)
                swap(L, i, min);

        }
    }

    //直接插入排序
    void insertSort(sqList *L) {
        int i, j;
        for (i = 2; i <= L->length; i++) {
            if (L->r[i] < L->r[i - 1]) {
                L->r[0] = L->r[i];
                for (j = i - 1; L->r[j] < L->r[0]; j--) {
                    L->r[j + 1] = L->r[j];
                }
                L->r[j + 1] = L->r[0];
            }
        }
    }

    //希尔排序
    void shellSort(sqList *L) {
        int gap = L->length /3+1;
        int i, j, k;
        for (; gap > 1; gap = gap / 3 + 1) {
            for (i = 1; i < gap+1; i++) {
                for (j = i + gap; j < L->length; j += gap) {
                    if (L->r[j] < L->r[j - gap]) {
                        L->r[0] = L->r[j];
                        for (k = j - gap; k >= 0 && L->r[k] > L->r[0]; k -= gap) {
                            L->r[k + gap] = L->r[k];
                        }
                        L->r[k + gap] = L->r[0];
                    }
                }
            }
        }
    }

    //堆排序
    //键大顶堆，只有s不符合大顶堆的要求，调整s
    void heapAdjust(sqList *L,int s,int m) {
        int temp, j;
        temp = L->r[s];
        for (j = 2 * s; j <= m; j *= 2) {
            if (L->r[j] < L->r[j + 1])
                ++j;
            if (temp > L->r[j])
                break;
            L->r[s] = L->r[j];
            s = j;
        }
        L->r[s] = temp;

    }

    void heapSort(sqList *L) {
        for (int i = L->length/2; i > 0; i--) {
            heapAdjust(L, i, L->length);
        }
        for (int i = L->length; i > 0; i--) {
            swap(L, 1, i);
            heapAdjust(L, 1, i-1);
        }

    }

    //归并排序
    //将两个有序的子序列归并为有序序列
    void Merge(int SR[],int TR[],int i,int m,int t) {
        int j, k, l;
        for (int j = m + 1, k = i; j <= t && i <= m; k++) {
            if (SR[i] < SR[j])
                TR[k] = SR[i++];
            else
                TR[k] = SR[j++];
        }
        if (i <= m) {
            for(l=0;l<=m-i;l++)
                TR[k+l] = SR[i+l];
        }
        if (j <= t) {
            for (l = 0; l <= t - j; l++)
                TR[k + l] = SR[j + l];
        }

    }

    void MSort(int SR[],int TR1[],int s,int t) {
        int m;
        int TR2[MAXSIZE + 1];
        if (s == t)
            TR1[s] = SR[s];
        else {
            m = (s + t) / 2;
            MSort(SR, TR2, s, m);
            MSort(SR, TR2, m+1, t);
            Merge(TR2, TR1, s, m, t);
        }
    }

    void mergeSort(sqList *L) {
        MSort(L->r, L->r, 0,L->length);
    }

    //快速排序
    //将序列分为两部分，一部分小于枢轴关键字，一部分大于枢轴关键字，返回枢轴的位置
    int partion(sqList *L, int low, int high) {
        int pivotkey;
        pivotkey = L->r[low];
        L->r[0] = pivotkey;
        //用替换代替交换，将枢轴关键字保留在L->r[0]中，减少不必要的交换
        while (low < high) {
            while (low < high&&L->r[high] >= pivotkey)
                high--;
            L->r[low] = L->r[high]; 
            while (low < high&&L->r[low] <= pivotkey)
                low++;
            L->r[high] = L->r[low];
        }
        L->r[low] = L->r[0];
        return low;
    }

    void QSort(sqList *L,int low,int high) {
        int pivot;
        if ((high - low) > MAX_LENGTH_INSERT_SORT) {
            //优化递归操作，只进行尾递归采用迭代而不是递归
            while (low < high) {
                pivot = partion(L, low, high);
                QSort(L, low, pivot - 1);
                low = pivot + 1;
            }
        }
        //待排序序列数目较小时，采用直接插入排序较好
        else
            insertSort(L);
    }

    void quickSort(sqList *L) {
        QSort(L,1,L->length);
    }



};