排序算法和搜索学习

#include<iostream>
#include<algorithm>
#include <random>

using namespace std;
template<typename  T>
class Sort
{
public:
    void BubbleSort(T list[], int n);
    void SelectSort(T list[], int n);
    void InsertionSort(T list[], int n);
    void QuickSort(T list[], const int left, const int right);
    void Merge(T* initList, T* mergedList, const int l, const int m, const int n);
    void MergeSort(T* initList, T* mergedList, const int n, const int s=2);
    void CreatRandomArray(T* initList, const int range1,const int range2,const int n)
    {
        default_random_engine e;
        uniform_int_distribution<unsigned> u(range1, range2);
        for (int i = 0; i < n; i++)
        {
            initList[i] = u(e);
        }
    }
    void CheckList(T* initList,const int n)
    {
        for (int i = 0; i < n - 1; i++)
        {
            if (initList[i] > initList[i + 1])
            {
                cout << "Sort error" << endl;
                return;
            }
        }
        cout << "Sort right" << endl;
    }
    void printlist(T list[],int num)
    {
        printf("数组有%d个数 数组:",num);
        for (int i = 0; i < num; i++)
            printf("%d ", list[i]);
        printf("\n");
    }
};
template<typename T>
//冒泡排序
void Sort<T>::BubbleSort(T list[], int n)
{
for(int i=0;i<n-1;i++)
    for (int j = 0; j < n - 1-i; j++)
    {
        if (list[j] > list[j + 1])
        {
            std::swap(list[j], list[j + 1]);
        }
    }
}
template<typename T>
//选择排序
void Sort<T>::SelectSort(T list[], int n)
{
    
    for (int i = 0; i < n-1; i++)
    {
        int min = i;
        for (int j = i+1; j < n; j++)
        {
            if (list[j] < list[min])
                min = j;
        }
        std::swap(list[i], list[min]);
    }
}
template<typename T>
//插入排序
void Sort<T>::InsertionSort(T list[], int n)
{
    int out, in;
    //先出去一个 
    for (out = 1; out < n; out++)
    {
        int temp = list[out];
        in = out;
        while (in>0&&list[in-1]>=temp)
        {
            list[in] = list[in - 1];
            in--;
        }
        list[in] = temp;
    }
}
template<typename T>
//快速排序
void Sort<T>::QuickSort(T list[], const int left, const int right)
{
    if (left < right)
    {
        int pivot = list[left];
        int i = left;
        int j = right;
        do {
            do i++; while (list[i] < pivot&& i<= right);
            do j--; while (list[j] > pivot&& j >= left);
            if(i<j)std::swap(list[i], list[j]);
        } while (i < j);
        std::swap(list[left],list[j]);

        QuickSort(list, left, j - 1);
        QuickSort(list, j + 1, right);
    }
}
//归并排序
/*
将数组两部分分别排序
param l：前半部分起始id
param m：后半部分起始id
param n：数组最后id+1
*/
template<typename T>
void Sort<T>::Merge(T* initList, T* mergedList, const int l, const int m,const int n)
{
    int i1, i2, iResult;
    for (i1 = l, i2 = m , iResult = l; i1 < m && i2 < n; iResult++)
    {
        if (initList[i1] <= initList[i2])
        {
            mergedList[iResult] = initList[i1];
            i1++;
        }
        else
        {
            mergedList[iResult] = initList[i2];
            i2++;
        }
    }
    /* //copy用法一：  
16     //将数组myints中的七个元素复制到myvector容器中  
17     copy ( myints, myints+7, myvector.begin() );  */
    copy(initList + i1, initList + m , mergedList + iResult);
    copy(initList + i2, initList + n , mergedList + iResult);
}
template<typename T>
void Sort<T>::MergeSort(T* initList, T* mergedList, const int n, const int s)
{
    if(s<n)
    {
        for (int i = 0; i < n; i += s)
        {
            //if (s + i > n)
            //    break;
            if ((i+s) > n)
            {
                //Merge(initList, mergedList, i, i + s - s / 2, n);
                //copy(mergedList + i, mergedList + n, initList + i);//将变化后的数组段传给initList
                for (int outnum = i + 1; outnum < n; outnum++)
                {
                    int temp = initList[outnum];
                    int innum = outnum;
                    while (innum > i && initList[innum - 1] > temp)
                    {
                        initList[innum] = initList[innum - 1];
                            innum--;
                    }
                    initList[innum] = temp;
                }
            }
            else 
            {
                Merge(initList, mergedList, i, i + s - s / 2, i + s);
                copy(mergedList + i, mergedList + i + s, initList + i);//将变化后的数组段传给initList
            }
        }
        //MergePass(mergedList, mergedList, n, s * 2); 当这样时 传入的initList会和mergedList指向同一地址
        MergeSort(initList, mergedList, n, s * 2);
    }
    else
    {
        Merge(initList, mergedList, 0, s / 2, n);
    }
}
class Search
{
public:
    int SequentialSearch(int* list, int n, int x)
    {
        int i;
        for (i = 0; i < n; i++)
        {
            if (list[i] == x)
                return i;
        }
        if (i == n)
            return -1;
    }
    int BinarySearch(int* list, int n, int x)
    {
        int low, high, mid;
        low = 0;
        high = n-1;
        while (low<=high)
        {
            mid = (low + high) / 2;
            if (list[mid] == x)
                return mid;
            else if (list[mid] > x)
                high = mid - 1;
            else low = mid + 1;
        }
        return -1;
    }
    int BinarySearch(int* list, int low, int high, int x)
    {
        if (low <= high)
        {
            int mid = (low + high) / 2;
            if (list[mid] == x)
                return mid;
            else if (list[mid] > x)
                BinarySearch(list, low, mid - 1, x);
            else BinarySearch(list, mid + 1, high, x);
        }
        else return -1;
    }
};
void show(char* p, int m)
{
    for (int i = 0; i <= m; i++)
        cout << p[i];
    cout << endl;
}
void Perm(char *p,int k,int m)
{
    //递归排列
    //比如abc 
    //a排列 b排列 c排列
    //一层一层下去
    if (k == m)
    {
        //show(p, m);
    }
    else for (int i = k; i <= m; i++)
    {
        std::cout << "递归前，交换前";
        show(p, m);
        std::swap(p[k],p[i]);
        std::cout << "递归前，交换后";
        show(p, m);
        Perm(p,k+1,m);//第一次出现m种情况，第二次出现m-1种情况，递归下去直到只有1种情况
        std::cout << "递归后，交换前";
        show(p, m);
        std::swap(p[k], p[i]);
        std::cout << "递归后，交换后";
        show(p, m);
    }
}

int main()
{
    int a[] = { 5,6,4,2,3,1,8,5,7 };
    int b[20];
    int c[20];
    int num = sizeof(a) / sizeof(*a);
    Sort<int> sort;
    sort.QuickSort(a,0,num);
    for (int i = 0; i < 100; i++)
    {
        sort.CreatRandomArray(b,0,100,20);
        sort.MergeSort(b, c, 20);
        sort.CheckList(c, 20);
    }
    sort.printlist(c, 20);
    Search search;
    int id_num =search.BinarySearch(a, num, 56);
    int id_num2 = search.BinarySearch(a,0, num, 56);

    //printf("id=%d,num=%d\n", id_num,a[id_num]);
    //printf("id=%d,num=%d\n", id_num2, a[id_num2]);
    char p[] = "abc";
    //Perm(p, 0, 2);
    return 0;
}