算法导论学习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 



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

相关文章推荐

MIT算法导论学习笔记-Lecture4 分治法(续)

第四讲:分治法(续) 4.1 快速排序(Quicksort)

算法导论学习1--分治法计算逆序数

闲来无事,复习复习经典的算法导论。看到了2-4,习题,计算逆序数的问题,忍不住实现了一下。   逆序数,是排列组合中常见的一个指标,可以用来衡量一个数列的杂乱成对(相对于顺序排列),在一些算法如水...
  • cpfeed
  • cpfeed
  • 2011-09-06 00:43
  • 4129

算法导论之分治法

分治法:主要算法思想就是divide and conquer

算法导论第二版笔记之分治法

//朴素的算法     解决a的n次方相乘问题 #include #include   usingnamespace std; int main() {     double a; ...

[算法导论]分治法---最大子数组

分治策略---最大自子数组 一、分治策略的三个步骤 1、分解:将问题划分为一些子问题,子问题的形式与原问题一样,只是规模更小 2、解决:递归地求解出子问题。如果子问题的规模足够小...

算法导论-分治法-最近点对-HDOJ1007

HDOJ1007的原题目是求出在不同时套中两个玩具的前提下,圆圈的最大半径。问题翻译过来就是求解最近点对的问题,这个问题是经典的分治法问题。 参考博客:http://www.cnblogs.com/p...
  • jkhere
  • jkhere
  • 2014-03-20 10:38
  • 2700

【算法导论】分治法及归并排序

有很多算法,在结构上他们是递归的:weile

算法导论——分治法——最大子数组问题

好久没有写博客了。以后我会不定期地写一些算法的博客,分享一些算法的感想。以下的说法很多都是我自己的感想,肯定有很多不足的地方,希望大家指正。 今天把算法导论里面分治法这一章里面的第一个问题——最大子数...

算法导论 第四章:分治法(二)

矩阵乘法问题     设矩阵A,B是nxn的方阵,我们将用分治法求解 C=A*B 。      我们用蛮力方法求解的运行时间复杂度为:。利用分治法,将A,B,C划分成4个n/2 x n/2 的矩阵,...

最大子数组问题(分治法)--【算法导论】

《算法导论》中引入这个问题是通过股票的购买与出售,经过问题转换,将前一天的当天的股票差价重新表示出来,即转为了一个最大子数组的问题,具体内容我不多说,转的内容是: 13, -3, -25, 20, ...
  • xjm199
  • xjm199
  • 2014-01-07 11:44
  • 3084
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

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