分治和减治算法——归并排序

贪心：每步最优解
回溯（试探）：得到所有解
分治（二分法）：将大问题划分成小问题来解决
减治（递归）：不断的缩小问题规模得到解
动态规划：整体最优解

• 1.分支算法
  • 分：划分子问题（将一个问题划分成若干个独立的，具有共性的问题）
  • 治：求解每个子问题（递归过程），由词构建整个问题的解
• 步骤：分解子问题
  • 每个子问题与原问题相似
  • 子问题规模太小（什么时候知道规模较小？【有解】）
  • 合并：将每个子问题的解合并成原问题的解

2. 适用场景

   • 在一个较小的规模上得到解
   • 该问题具有最优子结构
   • 每个子问题的解合成原来问题的解

3. 实列
   二分查找

   	//递归
   	 int halfSearch(int Data[],int low,int high,int key)
   	 //查找是否有Key，有：返回下标，没有：返回-1
   	 {
   	 	if(low<=high){
   	        int mid=(low+high)/2;
   	        if(Data[mid]==key)
   	            return mid;
   	    	else if(Data[mid]>key)
   	        	return halfSearch(Data,low,mid-1,key);
   	    	else
   	        	return halfSearch(Data,mid+1,high,key);
   	     }return -1;
   	 }
   

   //非递归
    int halfSearch(int Data[],int low,int high,int key)
    //查找是否有Key，有：返回下标，没有：返回-1
    {
    	while(low<=high){
           int mid=(low+high)/2;
           if(Data[mid]==key)
               return mid;
       	else if(Data[mid]>key)
           	high=mid-1;
           else
               low=mid+1;
       }
    }
   

   2 . X的n次方

   	#include <stdio.h>
   	#include <math.h>
   	int t=0;
   	int  power(int x,int n)
   	{
   	
   		if(n==0)
   			return 1;
   		else if(n==1 )
   			return x;	
   		if(n%2==0)
   			return power(x,n/2)*power(x,n/2);
   		else
   			return power(x,n/2)*power(x,n/2)*x;
   		
   		
   	}
   	int main()
   	{
   		int x ,n;
   		double l;
   		printf("请输入：");
   		scanf("%d%d",&x,&n);
   		if(n>=0)
   		{
   			l=power(x,n);
   		}
   		else 
   		{
   			l=1.0/power(x,-n);
   		}
   		
   		printf("%lf\n",l);
   	
   	 } 
   

   3.归并排序

   #include <stdio.h> 
   #include <string.h>
   #include <stdlib.h> 
   void merge_sort(int a[],int low,int high,int *tmp); 
   int main(void){
       int a[8]={3,2,5,8,4,7,6,9};
       int *tmp,n;
       n=sizeof(a)/sizeof(a[0]);// 数组大小 
       tmp=(int *)malloc(n*sizeof(int)); //临时数组 
       merge_sort(a,0,n-1,tmp);//归并排序 
       free(tmp);
       int i;
       printf("%d \n",n);
       for(i=0;i<n;i++)
       {
       	printf("%d ",a[i]);
   	}
       
    
   }
   
   
   void merge_sort(int a[],int low,int high,int *tmp){
       int i,j,k;
       //在具体抽象 
       if(low<high){
           int mid=(high+low)/2; //中间数 
           //二分 
           merge_sort(a,low,mid,tmp);//排序前半部分 
           merge_sort(a,mid+1,high,tmp);//排序后半部分 
           //回溯回来之后 
           //将两个数组进行升序有序排列 
           i=low,j=mid+1,k=0;
           //前半部的没放完，后半部分也没放完 
           while(i<=mid||j<=high){
           	//放i的情况
   			//	1.j放完了或者  i没完，并且i比j小  放i 
               if(j==high+1||(i<mid+1&&a[i]<a[j])) 
                   tmp[k++]=a[i++];
               else
               	// 剩下的情况就是放j了 
                   tmp[k++]=a[j++];
           } 
           //按字节拷贝 
            //memcpy(目标首地址（void *），源首地址（void *），长度)
           memcpy((void *)(a+low),(void *)tmp,(high-low+1)*sizeof(int));
           
           //完成合并(垃圾代码)
           /*for(k=0,i=low,j=mid+1;i<mid+1&&j<high+1){
               if(a[i]<a[j])
                   tmp[k++]=a[j++];
               else
                   tmp[k++]=a[j++];
           }
           while(i<mid+1){
               tmp[k++]=a[i++];
           }
           while(j>high+1){
               tmp[k++]=a[j++];
           }*/
         
          
       }
   }
   

• 完成任务