算法三——分治法

        说到分治法，我们第一时间就会想到归并排序，它是分治法的经典应用。下面我们先来通过归并排序来讲述什么是分治法。 

        首先，“归并”是指将两个的有序数列合并成一个有序数列，下面利用归并思想对数列进行排序。

下面是代码

#include<stdio.h>
#include<stdlib.h>

int merge(int* arr, int left, int mid, int right){//合并 
	int i = left;
	int j = mid;
	int* temp = (int*)malloc((right-left) * 4);
	int index=0;
	while(i < mid && j < right)
	{
		if(arr[i] < arr[j]){
			temp[index] = arr[i];
			i ++;
			index ++;
		}
		else{
			temp[index] = arr[j];
			j ++;
			index ++;
		}
	}
	while(i < mid){
		temp[index] = arr[i];
		i++;
		index++;
	}
	while(j < right){
		temp[index] = arr[j];
		j ++;
		index ++;
	}
	for(i = 0; i < index; i ++)
	{
		arr[left+i] = arr[i];
	}
	free(temp);
} 
int merge_sort(int *arr, int left, int right)//分解
{   
    if(right-left <= 1){
    	return;
	}
    int mid = (left+right) / 2;
    merge_sort(arr, left, mid);
    merge_sort(arr, mid+1, right);
    merge(arr, left, mid, right);
    
}

int main()
{
    int arr[4];
    arr[0]=10;
    arr[1]=9;
    arr[2]=8;
    arr[3]=7;
    merge_sort(arr,0,4);
    printf("%s", arr);
    return 0;
}

        在排序过程中，首先，分解：将数组分割成两个数组，再分别将两个数组又细分成2个数组，直到，最后每个数组都是一个元素，这时将该单元素数组看为有序数组。然后，合并：将分割的有序数组进行排序，排成有序数组后继续为上一个分割它的数组合并，直到数组被合并成原来的数组，此时已经排好序了。这和分治法的思想基本一致，下面我们来看一看分治法。

分治法介绍：

        首先，分治法字面上理解就是分而治之：把一个复杂的问题分成两个或更多的相同或相似的子问题，直到最后子问题可以简单的直接求解，原问题的解即子问题的解的合并。

要注意，复杂问题所分解出的各个子问题必须是相互独立的，即子问题之间不包含公共的子问题。

分治法的应用有很多，下面来看几个应用实例。

 寻找两个正序数组的中位数

给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的 中位数 。

注意：算法的时间复杂度应该为 O(log (m+n)) 。

示例 1：

输入：nums1 = [1,3], nums2 = [2]
输出：2.00000
解释：合并数组 = [1,2,3] ，中位数 2

示例 2：

输入：nums1 = [1,2], nums2 = [3,4]
输出：2.50000
解释：合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5

提示：

• nums1.length == m
• nums2.length == n
• 0 <= m <= 1000
• 0 <= n <= 1000
• 1 <= m + n <= 2000
• -106 <= nums1[i], nums2[i] <= 106

​
double findMedianSortedArrays(int* nums1, int nums1Size, int* nums2, int nums2Size)
{
    int p1 = 0, p2 = 0;
    int m = 0,l = 0,k = 0;
    int arr[nums1Size + nums2Size];
    int q;
    double n;
    while (p1 < nums1Size || p2 < nums2Size) //归并思想合并数组
    {
         if (p1 == nums1Size)  {
           q = nums2[p2++];
        } 
        else if (p2 == nums2Size)  {
            q = nums1[p1++];
        } 
        else if (nums1[p1] < nums2[p2]) {
            q = nums1[p1++];
        } 
        else  {
            q = nums2[p2++];
        }
        arr[p1 + p2 - 1] = q;
    }
//求新数组arr的中位数
    m = nums1Size + nums2Size;
    if(m == 1) 
        return arr[m-1];
    else  {
        if(m % 2 == 0)
            n = (arr[m/2] + arr[m/2-1])/2.0;
        else 
            n = arr[m/2];
    }
    return n;
}

​

摆动排序 II

给你一个整数数组 nums，将它重新排列成 nums[0] < nums[1] > nums[2] < nums[3]... 的顺序。

假设所有输入数组都可以得到满足题目要求的结果。

示例 1：

输入：nums = [1,5,1,1,6,4]
输出：[1,6,1,5,1,4]
解释：[1,4,1,5,1,6] 同样是符合题目要求的结果，可以被判题程序接受。

示例 2：

输入：nums = [1,3,2,2,3,1]
输出：[2,3,1,3,1,2]

提示：

• 1 <= nums.length <= 5 * 104
• 0 <= nums[i] <= 5000
• 题目数据保证，对于给定的输入 nums ，总能产生满足题目要求的结果

 

static int cmp(const void e1, const void *e2) {
    return *(int *)e1 - *(int *)e2;
}

void wiggleSort(int* nums, int numsSize) {
    int * arr = (int *)malloc(sizeof(int) * numsSize);
    memcpy(arr, nums, sizeof(int) * numsSize);
    qsort(arr, numsSize, sizeof(int), cmp);
    int x = (numsSize + 1) / 2;
    for (int i = 0, j = x - 1, k = numsSize - 1; i < numsSize; i += 2, j--, k--) {
        nums[i] = arr[j];
        if (i + 1 < numsSize) {
            nums[i + 1] = arr[k];
        }
    }
    free(arr);
}