递归 —— 二分查找法 —— 归并排序

Posted 2020-12-26 cmusketeer

PS：什么是递归、二分查找、归并排序。

递归排序大家都不陌生，递归简单的说就是自己在没有达到目的的同时在此调用本身，把一个大问题层层转化为和原问题相似的小问题解决，递归需要有边界条件、递归前进段和递归返回段。当边界条件不满足时，递归前进；当边界条件满足时，递归返回。

二分查找也称折半查找（Binary Search），它是一种效率较高的查找方法。但是，折半查找要求线性表必须采用顺序存储结构，而且表中元素按关键字有序排列。

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

如果想了解更多可以去百度百科查阅即可。下面是简单例子

1、二分查找法

思路

二分法就是把一个数组折半查找，再折半直到找到数据位置，或者无数据位置。比如说1-100，你选的值是23，那么范围写法就是(索引写法类似)

第一次折半是1-50，51-100，经过查找23<50,是在1-50里。

第二次是1-25，26-50，经过查找23<25，是在1-25里。

..........

使用条件

• 必须是有序数据
• 升序和降序start角标和end角标写法相反

/**
	 * 方法描述：二分查找方法
	 * **/
	public static int twoQueryMethod(int[] data,int query){
		int start=0;				//开始角标
		int end=data.length-1;		//结束角标
		int moddle;
		while(true){
			moddle=(end+start)/2;
			if(data[moddle] == query){
				return moddle;
			}
			//起始角标  >  最后角标   没有找到
			else if(start > end){
				return data.length;
			}
			else{
				//中间值大于查找值
				if(data[moddle] > query){
					end = moddle-1;
				}else{
					start = moddle + 1;
				}
			}
		}
	}

 上面是用平常的while循环写的，下面用递归的写法。

2：递归---二分查找法

使用递归可以取消while的循环使用

/**
	 * 递归取代while循环
	 * 
	 * **/
	 //降序查找
	public static int diGuiMethod(int[] data,int search,int start,int end){
		//获取中间值角标
		int moddle=(start+end)/2;
		if(data[moddle] == search){
			return moddle;
		}else if(start > end){
			return data.length;
		}else{
		//下面是降序
			if(data[moddle]< search){
				return diGuiMethod(data,search,start,moddle-1);
			}else{
				return diGuiMethod(data, search, moddle+1, end);

			}
		}
		
	}
	
	//升序查找
	public static int binarySearch(int[] arr, int data, int beginIndex, int endIndex) {
		int midIndex = (beginIndex + endIndex) / 2;
		if (data < arr[beginIndex] || data > arr[endIndex] || beginIndex > endIndex) {
			return -1;
		}
		if (data < arr[midIndex]) {
			return binarySearch(arr, data, beginIndex, midIndex - 1);
		} else if (data > arr[midIndex]) {
			return binarySearch(arr, data, midIndex + 1, endIndex);
		} else {
			return midIndex;
		}
	}

效率

普通二分查找法和递归二分查找都是 O（logN） 但是资料显示 递归二分查找简介但稍微慢一点。

扩展--分治算法

分治算法的基本思想是将一个规模为N的问题分解为K个规模较小的子问题，这些子问题相互独立且与原问题性质相同。求出子问题的解，就可得到原问题的解。即一种分目标完成程序算法，简单问题可用二分法完成。

分治算法--基本思想

当我们求解某些问题时，由于这些问题要处理的数据相当多，或求解过程相当复杂，使得直接求解法在时间上相当长，或者根本无法直接求出。对于这类问题，我们往往先把它分解成几个子问题，找到求出这几个子问题的解法后，再找到合适的方法，把它们组合成求整个问题的解法。如果这些子问题还较大，难以解决，可以再把它们分成几个更小的子问题，以此类推，直至可以直接求出解为止。这就是分治策略的基本思想。

3：归并排序

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

 归并排序的条件、使用优点

• 通过两个不同的有序数组，互相比较按照比较大小排序
• 把一个无序的数组分成N个数据，每个数据本身比较一次，之后再和下一个数组比较并合并，以此类推。

3.1：两个A,B不同的（有序）数组归并成一个C数组，结果C还是有序的。

public static void mergeTwo(int[] arr1,int[] arr2,int[] mergeArr){
		int aIndex=0,bIndex=0,mIndex=0;
		//两个数组都有数据时
		while(aIndex < arr1.length && bIndex < arr2.length){
			if(arr1[aIndex]<arr2[bIndex]){
				mergeArr[mIndex++] = arr1[aIndex++];
			}else{
				mergeArr[mIndex++] = arr2[bIndex++];
			}
		}
		//如果两个数组长度相等，则下方方法就不会执行，如果A长度大于B，则会走第一个while。
		//两个数组其中一个无数据时
		while(aIndex < arr1.length){
			mergeArr[mIndex++] = arr1[aIndex++];
		}
		while(bIndex < arr2.length){
			mergeArr[mIndex++]=arr2[bIndex++];
		}
		//遍历结果
		for(int i=0;i<mergeArr.length;i++){
			System.out.println(mergeArr[i]);
		}
	}

 使用

//main方法中使用
	int[] arr1={12,14,15,16};
		int[] arr2={8,22,56,90,100};
		int [] merge=new int[9];
		mergeTwo(arr1, arr2, merge);

 3.2:归并算法--排序一个无需数组

/**
	 * 一个数组内部进行排序
	 * 
	 * **/
	public static void mergeOne(int arr[],int startInt,int stopInt,int[] cArr){
		//如果范围是1则直接返回。
		if(stopInt==startInt){
			return;
		}
		else{
			int middle=(startInt+stopInt)/2;
			//开始把数组分开---二分法
			mergeOne(arr, startInt, middle,cArr);
			mergeOne(arr, middle+1, stopInt,cArr);
			mergeTwoSort(arr,startInt,middle,stopInt,cArr);	
		}
	}
	public static void mergeTwoSort(int arr[],int start,int mid,int end,int[] cArr){
		int left=start;//左序列开始角标
		int right=mid+1;//右序列开始角标
		int cIndex=0;//临时数组
		//当两边都有值时执行
		while(left <= mid&& end>=right){
			//比较两个数组的元素大小，如：A：left=0开始到3，长度为4，B：right=4开始，长度为4，
			if(arr[left]<arr[right])
			{
				cArr[cIndex++]=arr[left++];
			}else{
				cArr[cIndex++]=arr[right++];
			}
		}
		//当右边数组无元素时执行
		while(left<=mid){
			cArr[cIndex++]=arr[left++];
		}
		//当左边数组无元素时执行
		while(right<=end){
			cArr[cIndex++]=arr[right++];
		}
		//将临时数组全部添加进原数组
		cIndex=0;//指针修改为0
		while(start<=end){
			arr[start++]=cArr[cIndex++];
		}
	}

 使用

//mian方法使用
//一个数组内部排序
		int[] arr3={12,4,34,5,6,45,9};
		int[] cArr=new int[7];
		mergeOne(arr3, 0, 6, cArr);
		System.out.println("一个数组内部排序");
		for(int i=0;i<cArr.length;i++){
			System.out.println(cArr[i]);

 归并效率

O（log2N）以2为底N的对数。