Java复习之递归+链表

这篇博客主要是复习Java中递归和链表的相关知识。

(1)链表数据结构
链表是一种常见的基础的数据结构是一种线性表，但是不会按线性的顺序存储数据，而是在每一个节点里存着到下一个节点的指针，也就是说俩链表并不会向数组那样存在索引的概念，我们要取某一个节点的数据，则需要从根节点开始，一个个找过去。

链表可以看作有两部分组成，一部分是数据，另一部分就是指向下一个节点的引用。
(2)递归算法
递归算法是一种直接或者间接调用自身算法的过程。在计算机编程中递归算法对解决一大类问题是十分有效的，它往往使算法的描述简洁而且易于理解。

递归需要注意的问题:
(1)递归必须要有出口
(2)递归的次数过多有可能会造成占内存溢出

使用递归实现阶乘：

public class RecursionDemo {
    public static void main(String args[])
    {
        System.out.println(factorial(5));
        System.out.println(factoria2(5));
    }
    //使用循环首先阶乘
    public static int factorial( int num)
    {
        //do-while循环
        int sum = num;
        int i=num-1;
        do{
            sum *=i;
            i--;
        }while(i>1);
        return sum;
    }
    //使用递归实现阶乘
    public static int factoria2(int num)
    {
        if(num==1)
            return 1;
        return num * factoria2(num-1);
    }
}

着重演练一下递归的调用的过程,假设当num=5的时候

第一次返回：5 * factoria2(4)

此时factoria2(4)再次调用函数factoria2()函数，此时返回

4 * factoria2(3)

此时factoria2(3)再次调用函数factoria2()函数，此时返回

3 * factoria2(2)

此时factoria2(2)再次调用函数factoria2()函数，此时返回

2 * factoria2(1)

此时factoria2(1)再次调用函数factoria2()函数，此时返回
1

然后再一步步退回去

factoria2(1) ==1 –>factoria2(2)==2

–>factoria2(3)==6 –>factoria2(4)==24

–>factoria2(5)==5*factoria2(4)=120

这就是递归的过程，先从原点走到出口，然后从出口在走到远点，得出最后的结果。

链表增删Demo：

public class LinkListDemo {
    public static void main(String args[])
    {
        NodeManager nm = new NodeManager();
        //同一个对象
        nm.addNode("节点1");
        nm.addNode("节点2");
        nm.addNode("节点3");
        nm.addNode("节点4");
        nm.addNode("节点5");
        nm.printNode();
        nm.delNode("节点3");
        nm.printNode();
    }
}

//链表节点的管理
class NodeManager{
    private Node root;//根节点
    //添加节点，主要是对于根节点，其余节点递归使用节点的添加方法
    public void addNode(String name)
    {
        //如果根节点为空，那么添加的就是根节点
        if(root == null)
        {
            root = new Node(name);
        }
        else
        {
            root.add(name);
        }
    }

    //删除节点
    public void delNode(String name)
    {
        if(root!=null)
        {
            if(root.name.equals(name))
            {
                root = root.next;
            }
            else
            {
                root.del(name);
            }
        }
    }

    //输出所有节点
    public void printNode()
    {
        if (root!=null)
        {
            System.out.print(root.name);
            root.print();
            System.out.println();
        }
    }

 //定义一个节点内部类
    class Node{
      String name;
     //表示节点之间的关系,自己的类型作为自己的属性，表示下一个节点对象
     private Node next;
     public Node(String name)
     {
         this.name=name;
     }

     //添加节点
     public void add(String name)
     {
         if(this.next==null)
         {
             this.next=new Node(name);
         }
         else
         {
             //从这里进入了递归
             this.next.add(name);
         }
     }

     //删除节点
     public void del(String name)
     {
        if(this.next!=null)
        {
            if(this.next.name.equals(name)){
                this.next=this.next.next;
            }else
            {
                this.next.del(name);
            }
        }
     }

     //输出所有节点
     public void print(){
        if(this.next!=null)
        {
            System.out.print("-->"+this.next.name);
            this.next.print();//递归
        }
     }
 }
}