数据结构与算法--递归

目录


　　记得小时候经常讲的一个故事：从前有座山，山上有座庙，庙里有一个老和尚和一个小和尚，一天，老和尚给小和尚讲了一个故事，故事内容是“从前有座山，山上有座庙，庙里有一个老和尚和一个小和尚，一天，老和尚给小和尚讲了一个故事，故事内容......”

　　什么是递归，上面的小故事就是一个明显的递归。以编程的角度来看，程序调用自身的编程技巧称为递归（ recursion）。

　　百度百科中的解释是这样的：递归做为一种算法在程序设计语言中广泛应用。 一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。

回到顶部

1、递归的定义

　　递归，就是在运行的过程中调用自己。

　　递归必须要有三个要素：

　　①、边界条件

　　②、递归前进段

　　③、递归返回段

　　当边界条件不满足时，递归前进；当边界条件满足时，递归返回。

回到顶部

2、求一个数的阶乘：n!


1

n! = n*(n-1)*(n-2)*......1

　　规定：

　　①、0！=1

　　②、1！=1

　　③、负数没有阶乘

　　上面的表达式我们先用for循环改写：


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

/**

 * 0！=1  1！=1

 * 负数没有阶乘,如果输入负数返回-1

 * @param n

 * @return

 */

public static int getFactorialFor(int n){

    int temp = 1;

    if(n >=0){

        for(int i = 1 ; i <= n ; i++){

            temp = temp*i;

        }

    }else{

        return -1;

    }

    return temp;

}

　　如果求阶乘的表达式是这样的呢？


1

n! = n*(n-1)！

　　我们用递归来改写：


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

/**

 * 0！=1  1！=1

 * 负数没有阶乘,如果输入负数返回-1

 * @param n

 * @return

 */

public static int getFactorial(int n){

    if(n >= 0){

        if(n==0){

            System.out.println(n+"!=1");

            return 1;

        }else{

            System.out.println(n);

            int temp = n*getFactorial(n-1);

            System.out.println(n+"!="+temp);

            return temp;

        }

    }

    return -1;

}

　　我们调用该方法getFactorial(4);即求4！打印如下：

　　

　　这段递归程序的边界条件就是n==0时，返回1，具体调用过程如下：

　　

回到顶部

3、递归的二分查找

　　注意：二分查找的数组一定是有序的！！！

　　在有序数组array[]中，不断将数组的中间值（mid）和被查找的值比较，如果被查找的值等于array[mid],就返回下标mid; 否则，就将查找范围缩小一半。如果被查找的值小于array[mid], 就继续在左半边查找;如果被查找的值大于array[mid],  就继续在右半边查找。 直到查找到该值或者查找范围为空时， 查找结束。

　　

　　不用递归的二分查找如下：


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

/**

 * 找到目标值返回数组下标，找不到返回-1

 * @param array

 * @param key

 * @return

 */

public static int findTwoPoint(int[] array,int key){

    int start = 0;

    int last = array.length-1;

    while(start <= last){

        int mid = (last-start)/2+start;//防止直接相加造成int范围溢出

        if(key == array[mid]){//查找值等于当前值，返回数组下标

            return mid;

        }

        if(key > array[mid]){//查找值比当前值大

            start = mid+1;

        }

        if(key < array[mid]){//查找值比当前值小

            last = mid-1;

        }

    }

    return -1;

}

　　二分查找用递归来改写，相信也很简单。边界条件是找到当前值，或者查找范围为空。否则每一次查找都将范围缩小一半。


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

public static int search(int[] array,int key,int low,int high){

    int mid = (high-low)/2+low;

    if(key == array[mid]){//查找值等于当前值，返回数组下标

        return mid;

    }else if(low > high){//找不到查找值，返回-1

        return -1;

    }else{

        if(key < array[mid]){//查找值比当前值小

            return search(array,key,low,mid-1);

        }

        if(key > array[mid]){//查找值比当前值大

            return search(array,key,mid+1,high);

        }

    }

    return -1;

}

　　递归的二分查找和非递归的二分查找效率都为O(logN)，递归的二分查找更加简洁，便于理解，但是速度会比非递归的慢。

回到顶部

4、分治算法

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

　　上面讲的递归的二分查找法就是一个分治算法的典型例子，分治算法常常是一个方法，在这个方法中含有两个对自身的递归调用，分别对应于问题的两个部分。

　　二分查找中，将查找范围分成比查找值大的一部分和比查找值小的一部分，每次递归调用只会有一个部分执行。

回到顶部

5、汉诺塔问题

　　汉诺塔问题是由很多放置在三个塔座上的盘子组成的一个古老的难题。如下图所示，所有盘子的直径是不同的，并且盘子中央都有一个洞使得它们刚好可以放在塔座上。所有的盘子刚开始都放置在A 塔座上。这个难题的目标是将所有的盘子都从塔座A移动到塔座C上，每次只可以移动一个盘子，并且任何一个盘子都不可以放置在比自己小的盘子之上。

　　

　　试想一下，如果只有两个盘子，盘子从小到大我们以数字命名（也可以想象为直径），两个盘子上面就是盘子1，下面是盘子2，那么我们只需要将盘子1先移动到B塔座上，然后将盘子2移动到C塔座，最后将盘子1移动到C塔座上。即完成2个盘子从A到C的移动。

　　如果有三个盘子，那么我们将盘子1放到C塔座，盘子2放到B塔座，在将C塔座的盘子1放到B塔座上，然后将A塔座的盘子3放到C塔座上，然后将B塔座的盘子1放到A塔座，将B塔座的盘子2放到C塔座，最后将A塔座的盘子1放到C塔座上。

　　如果有四个，五个，N个盘子，那么我们应该怎么去做？这时候递归的思想就很好解决这样的问题了，当只有两个盘子的时候，我们只需要将B塔座作为中介，将盘子1先放到中介塔座B上，然后将盘子2放到目标塔座C上，最后将中介塔座B上的盘子放到目标塔座C上即可。

　　所以无论有多少个盘子，我们都将其看做只有两个盘子。假设有 N 个盘子在塔座A上，我们将其看为两个盘子，其中(N-1)~1个盘子看成是一个盘子，最下面第N个盘子看成是一个盘子，那么解决办法为：

　　①、先将A塔座的第(N-1)~1个盘子看成是一个盘子，放到中介塔座B上，然后将第N个盘子放到目标塔座C上。

　　②、然后A塔座为空，看成是中介塔座，B塔座这时候有N-1个盘子，将第(N-2)~1个盘子看成是一个盘子，放到中介塔座A上，然后将B塔座的第(N-1)号盘子放到目标塔座C上。

　　③、这时候A塔座上有(N-2)个盘子，B塔座为空，又将B塔座视为中介塔座，重复①，②步骤，直到所有盘子都放到目标塔座C上结束。

　　简单来说，跟把大象放进冰箱的步骤一样，递归算法为：

　　①、从初始塔座A上移动包含n-1个盘子到中介塔座B上。

　　②、将初始塔座A上剩余的一个盘子（最大的一个盘子）放到目标塔座C上。

　　③、将中介塔座B上n-1个盘子移动到目标塔座C上。


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

/**

 * 汉诺塔问题

 * @param dish 盘子个数(也表示名称)

 * @param from 初始塔座

 * @param temp 中介塔座

 * @param to   目标塔座

 */

public static void move(int dish,String from,String temp,String to){

    if(dish == 1){

        System.out.println("将盘子"+dish+"从塔座"+from+"移动到目标塔座"+to);

    }else{

        move(dish-1,from,to,temp);//A为初始塔座，B为目标塔座，C为中介塔座

        System.out.println("将盘子"+dish+"从塔座"+from+"移动到目标塔座"+to);

        move(dish-1,temp,from,to);//B为初始塔座，C为目标塔座，A为中介塔座

    }

}

　　测试：


1

move(3,"A","B","C");

　　打印结果为：

　　

回到顶部

5、归并排序

　　归并算法的中心是归并两个已经有序的数组。归并两个有序数组A和B，就生成了第三个有序数组C。数组C包含数组A和B的所有数据项。

　　

　　非递归算法为：


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

/**

 * 传入两个有序数组a和b，返回一个排好序的合并数组

 * @param a

 * @param b

 * @return

 */

public static int[] sort(int[] a,int[] b){

    int[] c = new int[a.length+b.length];

    int aNum = 0,bNum = 0,cNum=0;

    while(aNum<a.length && bNum < b.length){

        if(a[aNum] >= b[bNum]){//比较a数组和b数组的元素，谁更小将谁赋值到c数组

            c[cNum++] = b[bNum++];

        }else{

            c[cNum++] = a[aNum++];

        }

    }

    //如果a数组全部赋值到c数组了，但是b数组还有元素，则将b数组剩余元素按顺序全部复制到c数组

    while(aNum == a.length && bNum < b.length){

        c[cNum++] = b[bNum++];

    }

    //如果b数组全部赋值到c数组了，但是a数组还有元素，则将a数组剩余元素按顺序全部复制到c数组

    while(bNum == b.length && aNum < a.length){

        c[cNum++] = a[aNum++];

    }

    return c;

}

　　该方法有三个while循环，第一个while比较数组a和数组b的元素，并将较小的赋值到数组c；第二个while循环当a数组所有元素都已经赋值到c数组之后，而b数组还有元素，那么直接把b数组剩余的元素赋值到c数组；第三个while循环则是b数组所有元素都已经赋值到c数组了，而a数组还有剩余元素，那么直接把a数组剩余的元素全部赋值到c数组。

　　归并排序的思想是把一个数组分成两半，排序每一半，然后用上面的sort()方法将数组的两半归并成为一个有序的数组。如何来为每一部分排序呢？这里我们利用递归的思想：

　　把每一半都分为四分之一，对每个四分之一进行排序，然后把它们归并成一个有序的一半。类似的，如何给每个四分之一数组排序呢？把每个四分之一分成八分之一，对每个八分之一进行排序，以此类推，反复的分割数组，直到得到的子数组是一个数据项，那这就是这个递归算法的边界值，也就是假定一个数据项的元素是有序的。

　　


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

public static int[] mergeSort(int[] c,int start,int last){

    if(last > start){

        //也可以是(start+last)/2，这样写是为了防止数组长度很大造成两者相加超过int范围，导致溢出

        int mid = start + (last - start)/2;

        mergeSort(c,start,mid);//左边数组排序

        mergeSort(c,mid+1,last);//右边数组排序

        merge(c,start,mid,last);//合并左右数组

    }

    return c;

}

public static void merge(int[] c,int start,int mid,int last){

    int[] temp = new int[last-start+1];//定义临时数组

    int i = start;//定义左边数组的下标

    int j = mid + 1;//定义右边数组的下标

    int k = 0;

    while(i <= mid && j <= last){

        if(c[i] < c[j]){

            temp[k++] = c[i++];

        }else{

            temp[k++] = c[j++];

        }

    }

    //把左边剩余数组元素移入新数组中

    while(i <= mid){

        temp[k++] = c[i++];

    }

    //把右边剩余数组元素移入到新数组中

    while(j <= last){

        temp[k++] = c[j++];

    }

    

    //把新数组中的数覆盖到c数组中

    for(int k2 = 0 ; k2 < temp.length ; k2++){

        c[k2+start] = temp[k2];

    }

}

　　测试：


1

2

3

int[] c = {2,7,8,3,1,6,9,0,5,4};

c = mergeSort(c,0,c.length-1);

System.out.println(Arrays.toString(c));

　　结果为：

　　

回到顶部

6、消除递归

　　一个算法作为一个递归的方法通常通概念上很容易理解，但是递归的使用在方法的调用和返回都会有额外的开销，通常情况下，用递归能实现的，用循环都可以实现，而且循环的效率会更高，所以在实际应用中，把递归的算法转换为非递归的算法是非常有用的。这种转换通常会使用到栈。

　　递归和栈

　　递归和栈有这紧密的联系，而且大多数编译器都是用栈来实现递归的，当调用一个方法时，编译器会把这个方法的所有参数和返回地址都压入栈中，然后把控制转移给这个方法。当这个方法返回时，这些值退栈。参数消失了，并且控制权重新回到返回地址处。

　　调用一个方法时所发生的事：

　　一、当一个方法被调用时，它的参数和返回地址被压入一个栈中；

　　二、这个方法可以通过获取栈顶元素的值来访问它的参数；

　　三、当这个方法要返回时，它查看栈以获得返回地址，然后这个地址以及方法的所有参数退栈，并且销毁。

回到顶部

7、递归的有趣应用

　　①、求一个数的乘方

　　一般稍微复杂一点的计算器上面都能求一个数的乘法，通常计算器上面的标志是 x^y 这样的按键，表示求 x 的 y 次方。一般情况下我们是如何求一个数的乘法的呢？

　　比如2^8,我们可以会求表达式2*2*2*2*2*2*2*2 的值，但是如果y的值很大，这个会显得表达式很冗长。那么由没有更快一点方法呢？

　　数学公式如下是成立的：

　　(Xa)b = Xa*b

　　如果如果求28次方，我们可以先假定22=a,于是28 = （22）4 ，那么就是a4 ；假定 a2 = b，那么 a4 = b2，而b2可以写成(b2)1。于是现在28就转换成：b*b

　　也就是说我们将乘方的运算转换为乘法的运算。

　　求xy的值，当y是偶数的时候，最后能转换成两个数相乘，当时当y是奇数的时候，最后我们必须要在返回值后面额外的乘以一个x。


1

x^y= (x^2)^(y/2)，定义a=x^2,b=y/2, 则得到形如： x^y= a^b;

　　具体算法：


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

public static int pow(int x,int y){

    if(x == 0 || x == 1){

        return x;

    }

    if(y > 1){

        int b = y/2;

        int a = x*x;

        if(y%2 == 1){//y为奇数

            return pow(a,b)*x;

        }else{//y为偶数

            return pow(a,b);

        }

    }else if(y == 0){

        return 1;

    }else{//y==1

        return x;

    }

}

　　②、背包问题

　　背包问题也是计算机中的经典问题。在最简单的形式中，包括试图将不同重量的数据项放到背包中，以使得背包最后达到指定的总重量。

　　比如：假设想要让背包精确地承重20磅，并且有 5 个可以放入的数据项，它们的重量分别是 11 磅，8 磅，7 磅，6 磅，5 磅。这个问题可能对于人类来说很简单，我们大概就可以计算出 8 磅+ 7 磅 + 5 磅 = 20 磅。但是如果让计算机来解决这个问题，就需要给计算机设定详细的指令了。

　　算法如下：

　　一、如果在这个过程的任何时刻，选择的数据项的总和符合目标重量，那么工作便完成了。

　　二、从选择的第一个数据项开始，剩余的数据项的加和必须符合背包的目标重量减去第一个数据项的重量，这是一个新的目标重量。

　　三、逐个的试每种剩余数据项组合的可能性，但是注意不要去试所有的组合，因为只要数据项的和大于目标重量的时候，就停止添加数据。

　　四、如果没有合适的组合，放弃第一个数据项，并且从第二个数据项开始再重复一遍整个过程。

　　五、继续从第三个数据项开始，如此下去直到你已经试验了所有的组合，这时才知道有没有解决方案。

　　具体实现过程：


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

package com.ys.recursion;

public class Knapsack {

    private int[] weights; //可供选择的重量

    private boolean[] selects; //记录是否被选择

    

    public Knapsack(int[] weights){

        this.weights = weights;

        selects = new boolean[weights.length];

    }

    

    /**

     * 找出符合承重重量的组合

     * @param total 总重量

     * @param index 可供选择的重量下标

     */

    public void knapsack(int total,int index){

        if(total < 0 || total > 0 && index >= weights.length){

            return;//没找到解决办法，直接返回

        }

        if(total == 0){//总重量为0，则找到解决办法了

            for(int i = 0 ; i < index ; i++){

                if(selects[i] == true){

                    System.out.println(weights[i]+" ");

                }

            }

            System.out.println();

            return;

        }

        selects[index] = true;

        knapsack(total-weights[index], index+1);

        selects[index] = false;

        knapsack(total, index+1);

    }

    

    public static void main(String[] args) {

        int array[] = {11,9,7,6,5};

        int total = 20;

        Knapsack k = new Knapsack(array);

        k.knapsack(total, 0);

    }

}

　　③、组合：选择一支队伍

　　在数学中，组合是对事物的一种选择，而不考虑他们的顺序。

　　比如有5个登山队员，名称为 A,B,C,D和E。想要从这五个队员中选择三个队员去登峰，这时候如何列出所有的队员组合。（不考虑顺序）

　　还是以递归的思想来解决：首先这五个人的组合选择三个人分成两个部分，第一部分包含A队员，第二部分不包含A队员。假设把从 5 个人中选出 3 个人的组合简写为（5,3），规定 n 是这群人的大小，并且 k 是组队的大小。那么根据法则可以有：

　　(n,k) = (n-1,k-1) + (n-1,k)

　　对于从 5 个人中选择 3 个人，有：

　　(5,3) = (4,2)+(4,3)

　　(4,2)表示已经有A队员了，然后从剩下的4个队员中选择2个队员，(4,3)表示从5个人中剔除A队员，从剩下的4个队员中选择3个队员，这两种情况相加就是从5个队员中选择3个队员。

　　现在已经把一个大问题转换为两个小问题了。从4个人的人群中做两次选择（一次选择2个，一次选择3个），而不是从5个人的人群中选择3个。

　　从4个人的人群中选择2个人，又可以表示为：(4,2) = (3,1) + (3,2)，以此类推，很容易想到递归的思想。

　　具体实现代码：


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

package com.ys.recursion;

public class Combination {

    private char[] persons;//组中所有可供选择的人员

    private boolean[] selects;//标记成员是否被选中，选中为true

    

    public Combination(char[] persons){

        this.persons = persons;

        selects = new boolean[persons.length];

    }

    public void showTeams(int teamNumber){

        combination(teamNumber,0);

    }

    /**

     *

     * @param teamNumber 需要选择的队员数

     * @param index 从第几个队员开始选择

     */

    public void combination(int teamNumber,int index){

        if(teamNumber == 0){//当teamNumber=0时，找到一组

            for(int i = 0 ; i < selects.length ; i++){

                if(selects[i] == true){

                    System.out.print(persons[i]+" ");

                }

            }

            System.out.println();

            return;

        }

        //index超过组中人员总数，表示未找到

        if(index >= persons.length ){

            return;

        }

        selects[index] = true;

        combination(teamNumber-1, index+1);

        selects[index] = false;

        combination(teamNumber, index+1);

    }

    public static void main(String[] args) {

        char[] persons = {‘A‘,‘B‘,‘C‘,‘D‘,‘E‘};

        Combination cb = new Combination(persons);

        cb.showTeams(3);

    }

}

回到顶部

8、总结

　　一个递归方法每次都是用不同的参数值反复调用自己，当某种参数值使得递归的方法返回，而不再调用自身，这种情况称为边界值，也叫基值。当递归方法返回时，递归过程通过逐渐完成各层方法实例的未执行部分，而从最内层返回到最外层的原始调用处。

　　阶乘、汉诺塔、归并排序等都可以用递归来实现，但是要注意任何可以用递归完成的算法用栈都能实现。当我们发现递归的方法效率比较低时，可以考虑用循环或者栈来代替它。

原文地址：https://www.cnblogs.com/wzq-xf/p/11875371.html

时间： 2024-10-08 19:41:02

数据结构与算法--递归的相关文章

数据结构与算法-递归的形象化理解

fib (n) = 1 (n=1) fib (n) = n*fib(n-1)   (n>1) // 条件不成立,则继续调用函数并检查条件不满足则继续调用函数...直到函数返回值为1时,再一层层将返回值递归返回上来 // 我们可以用符合条件的尽量简单的实例来剖析那些复杂的算法 例如:5 * 4 * 3 * 2 * 1 = ? 算了,上面的测试数字太大太复杂了,再选个简单点的例如:3 * 2 * 1 = ? 有人说 2 * 1 = ? 更简单不过了,我们是要体现递归的特性,所以选择3 * 2 * 1

数据结构与算法 —— 递归的效率问题以及递归与循环的比较

1.所谓的递归慢到底是什么原因呢? 大家都知道递归的实现是通过调用函数本身,函数调用的时候,每次调用时要做地址保存,参数传递等,这是通过一个递归工作栈实现的.具体是每次调用函数本身要保存的内容包括:局部变量.形参.调用函数地址.返回值.那么,如果递归调用N次,就要分配N*局部变量.N*形参.N*调用函数地址.N*返回值.从而导致了效率的低下. 2.用循环效率会比递归效率高吗? 递归与循环是两种不同的解决问题的典型思路.当然也并不是说循环效率就一定比递归高,递归和循环是两码事,递归带有栈操作,循环

数据结构与算法—递归(阶乘、斐波那契、汉诺塔)

目录 递归介绍 递归求阶乘 递归求斐波那契 递归解决汉诺塔 总结 递归介绍 递归:就是函数自己调用自己. 子问题须与原始问题为同样的事,或者更为简单:递归通常可以简单的处理子问题,但是不一定是最好的.对于递归要分清以下概念: 自己调用自己 递归通常不在意具体操作,只关心初始条件和上下层的变化关系. 递归函数需要有临界停止点,即递归不能无限制的执行下去.通常这个点为必须经过的一个数. 递归通常能被其他方案替代(栈.数组正向求). 认识递归,递归函数通常简易但是对于初学者可能很难取理解它.拿一个递归

Java数据结构和算法之递归

四.递归 递归是函数调用自身的一种特殊的编程技术,其应用主要在以下几个方面:   阶乘 在java当中的基本形式是: Public  void  mothed(int n){//当满足某条件时: Mothed(n‐1): } 递归二分查找 Java二分查找实现,欢迎大家提出交流意见.  /** *名称:BinarySearch *功能:实现了折半查找(二分查找)的递归和非递归算法. *说明: *     1.要求所查找的数组已有序,并且其中元素已实现Comparable<T>接口,如Integ

数据结构与算法5: 递归(Recursion)

数据结构与算法5: 递归(Recursion) 写在前面 <软件随想录:程序员部落酋长Joel谈软件>一书中<学校只教java的危险性>一章提到,大学计算机系专业课有两个传统的知识点,但许多人从来都没搞懂过,那就是指针和递归.我也很遗憾没能早点熟练掌握这两个知识点.本节一些关键知识点和部分例子,都整理自教材或者网络,参考资料列在末尾.如果错误请纠正我. 思考列表: 1)什么程序具有递归解决的潜质? 2)递归还是非递归算法,怎么选择? 3)递归程序构造的一般模式 1.递归定义 首要引

java数据结构与算法之递归思维(让我们更通俗地理解递归)

[版权申明]转载请注明出处(请尊重原创,博主保留追究权) http://blog.csdn.net/javazejian/article/details/53452971 出自[zejian的博客] 关联文章: java数据结构与算法之顺序表与链表设计与实现分析 java数据结构与算法之双链表设计与实现 java数据结构与算法之改良顺序表与双链表类似ArrayList和LinkedList(带Iterator迭代器与fast-fail机制) java数据结构与算法之栈(Stack)设计与实现 j

数据结构与算法 3:二叉树,遍历,创建,释放,拷贝,求高度,面试,线索树

[本文谢绝转载,原文来自http://990487026.blog.51cto.com] 树 数据结构与算法 3:二叉树,遍历,创建,释放,拷贝,求高度,面试,线索树 二叉树的创建,关系建立 二叉树的创建,关系建立2 三叉链表法 双亲链表: 二叉树的遍历 遍历的分析PPT 计算二叉树中叶子节点的数目:使用全局变量计数器 计算二叉树中叶子节点的数目:不使用全局变量计数器 无论是先序遍历,中序遍历,后序遍历,求叶子的数字都不变;因为本质都是一样的,任何一个节点都会遍历3趟 求二叉树的高度 二叉树的拷

Java数据结构和算法（一）：综述

数据结构和算法能起到什么作用? 数据结构是指数据在计算机内存空间或磁盘中的组织形式.数据结构包括数组.链表.栈.二叉树.哈希表等等.算法对这些结构中的数据进行各种处理,例如,查找一条特殊的数据项或对数据进行排序. 数据结构的概述 数据结构 优点 缺点 数组 插入快,如果知道下标,可以非常快地存取 查找慢,删除慢,大小固定 有序数组 比无序数组查找快 删除和插入慢,大小固定 栈 提供后进先出方式的存取 存取其他项很慢 队列 提供先进先出方式的存取 存取其他项很慢 链表 插入快,删除快 查找慢 二叉

数据结构与算法系列研究四——数组和广义表

稀疏矩阵的十字链表实现和转置 一.数组和广义表的定义 数组的定义1:一个 N 维数组是受 N 组线性关系约束的线性表.           二维数组的逻辑结构可形式地描述为:           2_ARRAY(D,R)              其中 D={aij} | i=0,1,...,b1-1; j=0,1,...,b2-1;aij∈D0}              R={Row,Col}              Row={<aij,ai,j+1>|0<=i<=b1-1;