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

算法导论第三版第四章 最大子数组和的三种解法(暴力、教材分治法、线性解法)

1.暴力求解法 该方法的思想非常简单,先找出从第1个元素开始的最大子数组,而后再从第2个元素开始找出从第2个元素开始的最大子数组,依次类推,比较得出最大的子数组。实现代码如下: /* 常规方法,时...

算法导论之分治法

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

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

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

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

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

分治法(算法导论Lec3)

包括一个数的n次方O(lgn),矩阵相乘,矩阵的n次方,斐波纳契的各种方法(运行时间指数,O(n), O(lgn) )   /** * @brief Divide and Conquer, Al...
  • aytfly
  • aytfly
  • 2013年05月14日 16:04
  • 342

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

有很多算法,在结构上他们是递归的:weile
  • Eaton18
  • Eaton18
  • 2014年09月18日 00:39
  • 365

算法导论第2章(4) 分治法的应用 找逆序对 (习题2-4)

第二章习题2-4 逆序对的概念:数组s[0...N]中如果ij就表示有一个逆序对 问题:对任意一个数组求其逆序对。 可以使用分治法:对于一个数组S将其分为2个部分S1和S2,求S1和S2的逆序...

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

分治策略---最大自子数组 一、分治策略的三个步骤 1、分解:将问题划分为一些子问题,子问题的形式与原问题一样,只是规模更小 2、解决:递归地求解出子问题。如果子问题的规模足够小...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:算法导论学习2.3 分治法 (这个递归终于懂了。。)
举报原因:
原因补充:

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