算法导论学习2.3 分治法 (这个递归终于懂了。。)

原创 2012年03月27日 16:00:52
import java.util.Arrays;
  
public class MergeSort {
	
	public static void main(String[] args) {
		
    	int[] data = {2,4,0,7,1,8,3,6};
    	
    	sort(data, 0, data.length - 1);
    	
    	for(int i = 0; i < data.length; i++) {
    		System.out.print(data[i] + " ");
    	}    	
    }  
  
    public static void sort(int[] data, int p, int r) {  
  
        if (p < r) {  
            int q = (p + r) / 2;  
            sort(data, p, q);  
            sort(data, q + 1, r);  
            merge(data, p, q, r);  
        }    
    }  
  
    private static void merge(int[] data, int p, int q, int r) {  
        int[] left = Arrays.copyOfRange(data, p, q + 1);  
  
        int[] right = Arrays.copyOfRange(data, q + 1, r + 1);  
  
        int i = 0;  
        int j = 0;  
        int k = 0;  
        while (k < r - p + 1) {  
            if (i == left.length) {  
                data[p + k] = right[j++];  
            }  
            else if (j == right.length) {  
                data[p + k] = left[i++];  
            }  
            else if (left[i] < right[j]) {  
                data[p + k] = left[i++];  
            }  
            else {  
                data[p + k] = right[j++];  
            }  
            k++;  
        }    
    }
}  

一直搞不清楚这个递归是怎么执行的,就加了个临时数组test[ ]单步走了一边,终于弄懂了~~~

//  测试的代码
import java.util.Arrays;
  
public class MergeSort {
	
	public static void main(String[] args) {
		
    	int[] data = {1,3,4,2}; 
    	
    	int[] test = new int[data.length];
    	
    	sort(data, 0, data.length - 1, test);
    	
    	System.out.print("out:\t");
    	for(int i = 0; i < data.length; i++) {
    		System.out.print(data[i] + " ");
    	}    	
    }  
  
    public static void sort(int[] data, int p, int r, int[] test) {  
  
        if (p < r) {  
            int q = (p + r) / 2;  
            sort(data, p, q, test);
            
//            System.out.print("sort1.\t");
//            for(int i = 0; i < test.length; i++) {
//        		System.out.print(test[i] + " ");
//        	}    	
//            System.out.println();
            
            sort(data, q + 1, r, test);
            
//            System.out.print("sort2.\t");
//            for(int i = 0; i < test.length; i++) {
//        		System.out.print(test[i] + " ");
//        	}    	
//            System.out.println();
            
            merge(data, p, q, r, test);  
            
//            System.out.print("merge.\t");
//            for(int i = 0; i < test.length; i++) {
//        		System.out.print(test[i] + " ");
//        	}    	
//            System.out.println();
            
        }    
    }  
  
    private static void merge(int[] data, int p, int q, int r, int[] test) {  
        int[] left = Arrays.copyOfRange(data, p, q + 1);  
  
        int[] right = Arrays.copyOfRange(data, q + 1, r + 1);  
  
        int i = 0;  
        int j = 0;  
        int k = 0;  
        while (k < r - p + 1) {  
            if (i == left.length) {  
                data[p + k] = right[j++];
                test[p + k] = data[p + k];
            }  
            else if (j == right.length) {  
                data[p + k] = left[i++]; 
                test[p + k] = data[p + k];
            }  
            else if (left[i] < right[j]) {  
                data[p + k] = left[i++];  
                test[p + k] = data[p + k];
            }  
            else {  
                data[p + k] = right[j++]; 
                test[p + k] = data[p + k];
            }  
            k++;  
        }    
    }
}  

递归的执行顺序如下:


输出如下:

sort1.	0 0 0 0 
sort2.	0 0 0 0 
merge.	1 3 0 0 
sort1.	1 3 0 0 
sort1.	1 3 0 0 
sort2.	1 3 0 0 
merge.	1 3 2 4 
sort2.	1 3 2 4 
merge.	1 2 3 4 
out:	1 2 3 4 



版权声明:本文为博主原创文章,未经博主允许不得转载。

《算法导论》读书笔记(二)——分治法

设计算法 插入排序使用了增量法,即先排j-1个,然后排j个,下面学习一种新的方法:分治法。 分治法 分治法的思想:大事化小,分而治之。把规模较大的问题分解为几个规模较小的类似子问题,递归的求解子问题,...
  • vinson0526
  • vinson0526
  • 2013年09月02日 22:15
  • 898

MIT算法导论学习笔记-Lecture3:分治法

第三讲 分治法(Devide and Conquer)
  • ai552368625
  • ai552368625
  • 2014年07月25日 09:01
  • 1933

【算法导论】【笔记】【分治法】最近点对问题

寻找最近点对 目录 寻找最近点对 问题分析 分治法 时间复杂度 题目:在一个 n≥2n\geq 2 个点的集合 Q 中寻找距离最近的点对 问题分析 首先很容易想...
  • ideaqjx
  • ideaqjx
  • 2017年12月26日 16:30
  • 70

递归与分治法

分治法设计思想:将一个规模较大的问题,分解成若干规模较小但问题的性质与原问题相同的子问题,然后将这些子问                                 题逐个击破,再将子问题的解合并...
  • qq_18415779
  • qq_18415779
  • 2015年06月26日 10:57
  • 797

我终于弄懂了各种前端build工具

学习前端的同学注意了!!!  学习过程中遇到什么问题或者想获取学习资源的话,欢迎加入前端学习交流群,群号码:315913738 即使对于一些经验丰富的开...
  • l1063951462
  • l1063951462
  • 2017年03月15日 16:06
  • 216

分治法和递归

分治算法的基本思想是将一个规模为N的问题分解为K个规模较小的子问题,这些子问题相互独立且与原问题性质相同。求出子问题的解,就可得到原问题的解。分治法在每一层递归上都有三个步骤:分解:将原问题分解为若干...
  • coolmeme
  • coolmeme
  • 2010年11月25日 16:27
  • 1651

如何编写递归程序(分治法)

一个过程或函数在其定义或说明中又直接或间接调用自身的一种方法,它通常把一个大型复杂的问题层层转化 为一个与原问题相似的规模较小的问题来求解,递归策略只需少量的程序就可描述出解题过程所需要的多次重 复计...
  • xgf415
  • xgf415
  • 2016年07月25日 21:24
  • 757

算法导论学习之分治法

算法导论
  • weiyongle1996
  • weiyongle1996
  • 2017年04月17日 22:17
  • 111

算法导论之2-3思考题

题目:霍纳规则的正确性: 写出伪代码以实现朴素多项式求值(native polynomial-evaluation)算法,它从头开 始计算多项式的每一个项。这个算法的运行时间是多少?与霍纳...
  • xlinsist
  • xlinsist
  • 2015年10月24日 19:15
  • 584

分治法的递归算法时间复杂度分析

最近看分治法,那我们就一起研究下分治法的时间复杂度吧。 分治法是将问题分解为语言问题等价的规模相等的子问题进行求解的过程。因此根据定义可知,如果原问题为A该问题被分解为K个子问题,则子问题应该为A/...
  • kongfangyi
  • kongfangyi
  • 2015年01月22日 17:27
  • 1707
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:算法导论学习2.3 分治法 (这个递归终于懂了。。)
举报原因:
原因补充:

(最多只允许输入30个字)