归并排序以及快速排序模板

 

归并排序：

归并模板及测试

    void Merge(vector<int>& arr, int l, int mid, int r) {
       int size =  r - l + 1;
       int* helpArr = new int[size];

       int p1 = l;
       int p2 = mid + 1;
       int i = 0;
       while (p1 <= mid && p2 <= r) {
           helpArr[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
        }
       while(p1 <= mid) { helpArr[i++] = arr[p1++]; }
       while(p2 <= r)   { helpArr[i++] = arr[p2++]; }
        
       for (int i = 0; i < size; i++) {
           arr[l + i] = helpArr[i];
       }       
    }

归并排序 一定要注意+号的优先级大于>>

class Solution {
public:
    void MergeSort(vector<int>& arr, int l, int r) {
        if (l == r) return;
        //int size = arr.size();
        int mid = l + ((r - l) >> 1);//以前已经因为这个调试了好久，没想到这次还是
        MergeSort(arr, l, mid);
        MergeSort(arr, mid + 1, r);
        Merge(arr, l, mid, r);
    }
    
    void Merge(vector<int>& arr, int l, int mid, int r) {
       int size =  r - l + 1;
       int* helpArr = new int[size];

       int p1 = l;//指向左边数组
       int p2 = mid + 1;//指向右边数组
       int i = 0;
       while (p1 <= mid && p2 <= r) {
           helpArr[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
        }
       while(p1 <= mid) { helpArr[i++] = arr[p1++]; }
       while(p2 <= r)   { helpArr[i++] = arr[p2++]; }
        
       for (int i = 0; i < size; i++) {
           arr[l + i] = helpArr[i];
       }       
    }
};

 

快速选择Partition

这里提供两个模板，一个是指定的数partition，另外一个是末尾元素partition

/*
@p : 代表的是以哪个数字作为parition
举例子: [6 1 5 3 4 3 7 2] p = 3
最后的less代表的是指定的数的左边界
最后的more代表的是指定的数的右边界
返回值是等于区域的index
*/
    pair<int,int> Partition(vector<int>& arr, int l,int r,int p) {
        //这个模板可以分为三个部分 小于 等于 大于
        //我们牢记几个点:
        //1.Partition算法的less,more的值是什么
        //2.循环结束的条件
        //3.我们是移动l指针，然后less与more是附加效果
        int less = l - 1;
        int more = r + 1;
        while (l < more) {
            if (arr[l] < p) {
                swap(arr[++less], arr[l++]);
            }
            else if (arr[l] > p) {
                swap(arr[--more], arr[l]);
            }
            else {
                l++;
            }
        }      
        return { less + 1,more - 1 };
    }

 

/*
这个partition以尾元素来
*/
    pair<int, int> Partition(vector<int>& arr, int l, int r) {
        //这个模板可以分为三个部分 小于 等于 大于
        int less = l-1;
        int more = r;
        while (l < more) {
            if (arr[l] < arr[r]) {
                swap(arr[++less], arr[l++]);
            }
            else if (arr[l] > arr[r]) {
                swap(arr[--more], arr[l]);
            }
            else {
                l++;
            }        
        }
        swap(arr[more], arr[r]);
        return { less + 1,more };

    }

基于上面的模板，我们写出快排模板

/*
这个partition以尾元素来作为划分值
*/
    pair<int, int> Partition(vector<int>& arr, int l, int r) {
        //这个模板可以分为三个部分 小于 等于 大于
        int less = l-1;
        int more = r;
        while (l < more) {
            if (arr[l] < arr[r]) {
                swap(arr[++less], arr[l++]);
            }
            else if (arr[l] > arr[r]) {
                swap(arr[--more], arr[l]);
            }
            else {
                l++;
            }        
        }
        swap(arr[more], arr[r]);
        return { less + 1,more };

    }

    int RandomInRange(int min = 1 , int max = 0) {
        static default_random_engine e;//生成随机的无符号数
        static uniform_int_distribution<unsigned> u(min, max);//生成0-9之间的均匀分布的随机数
        if (min <= max)//必须这样写，否则会出错，min,max不更新
            u = uniform_int_distribution<unsigned>(min, max);
        
        return u(e);
    }

    void quickSort(vector<int>& arr) {
        if (arr.size() < 2) {
            return;
        }
        quickSort(arr, 0, arr.size() - 1);
   }
    void quickSort(vector<int>& arr, int start, int end) {
        if (start < end) {
            int index = RandomInRange(start, end);
            swap(arr[index], arr[end]);
            pair<int, int> p = Partition(arr, start, end);//这里的p的相等的区域
            quickSort(arr, start, p.first-1);
            quickSort(arr, p.second + 1, end);
        }
    }

快排的复杂度分析：  https://blog.csdn.net/hn_gsf/article/details/52249621

 

 

寻找左边第一个大于pivot的数，寻找右边第一个小于pivot的数，然后交换

void Partition(vector<int>& arr,int start,int end) {
    
    int pivot = arr[start + ((end - start) >> 1)];
    int left = start, right = end;
    while (left <= right) {
        while (left <= right && arr[left] < pivot) {
            left++;//找到左边第一个大于
        }
        while (left <= right && arr[right] > pivot) {
            right--;//找到右边第一个小于
        }
        if (left <= right) {
            int tmp = arr[left];
            arr[left] = arr[right];
            arr[right] = tmp;
            left++;
            right--;
        }
    }
}

题目：  颜色分类：https://leetcode-cn.com/problems/sort-colors/

class Solution {
public:
    void partition(vector<int>& arr,int l,int r,int p ){
        int less = l - 1;
        int more = r + 1;
        while(l < more){
            if(arr[l] < p){
                swap(arr[++less],arr[l++]);
            }else if(arr[l] > p){
                swap(arr[--more],arr[l]);
            }else{
                l++;
            }
        }

    }
    void sortColors(vector<int>& nums) {
        partition(nums,0,nums.size()-1,1);
    }
};