数学归纳法与递归学习

递归学习记录

递归是什么

递归的定义：重复的将问题分解为子问题解决问题的方法。

数学归纳法

我们在证明一个公理时，如求1+2+3+……+n=n(1+n)/2
根据公理可以看到如下规律：
1=11+1）/2
1+2=2（1+2）
1+2+3=3*(1+3)/2
如是可以猜想出
1+2+3+……+n-1=(n-1)(1+n-1)/2
根据猜想证明：
1+2+3+……+n-1+n=(n-1)(1+n-1)/2 +n
=n(n-1)/2 +n
=n*(n-1)/2
一个递归算法设计时，我们可以把它当错一个要证明的公理，然后将问题缩小成子规模如上面的案例。设计一个方法求1+2+3+……+n。
设计方法时，明确方法的返回值，参数；假设求和的方法为：int sum(int n);
思考问题的规模是什么，每次缩进多少才能变成上面的子问题。
设计算法时，先从一般出发，特殊情况特殊处理。
public int sum(int n){
//因为根据问题知道参数不能小于零，所以n-1>0,由于问题规模是按照1缩进的，所以再次整合，可以知道，当n<=0时，停止递归开始回溯栈中未执行完的方法。
//特殊情况的处理
if(n<=0){
return 0;
}
//一般情况的处理
return n+sum(n-1);
}
运行侧视图：

使用递归生成链表：
//定义方法,等会儿我们去需要证明 Node createNode(String node){
//
}

//Node 链表的节点，这里以单向链表为例
public class Node {
   public class Node {
    private  final Object value;
    private  Node next;
    public void setNext( Node node){
        this.next=node;
    }
    public Node getNext(){
        return this.next;
    }
    public Object getValue(){
        return this.value;
    }
  public Node(Object value){
      this.value=value;
      this.next=null;
    }
    public Node(){
        this.value=0;
    }
  public  static void print(Node node){
        Node pre=node;
        while(pre!=null){
            System.out.print(pre.getValue()+" ");
            pre=pre.getNext();
        }
    };

}
//生成链表的方法证明
 Node createLinkListByString(String node){
        if(node.isEmpty()){
            return null;
        }
        char nodeChar=node.charAt(0);
        Node newNode=new Node(String.valueOf(nodeChar));
        //按照规模生成下一个节点
        Node head=createLinkListByString(node.substring(1,node.length()));
        newNode.setNext(head);
        return newNode;
    }

测试生成链表图