遞歸的妙用

遞歸算法是在函數或子過程的內部，直接或者間接地調用自己的算法。學過算法與數據結構的都知道，通過遞歸可以將一個複雜的問題化解爲一個子問題和一個基本問題，從而達到簡化問題邏輯的效果。本篇將通過幾個例子來講解一下遞歸的妙用。

鏈表中的遞歸

鏈表是一種具有天然遞歸性質的數據結構，將鏈表頭去掉後，剩下部分仍然是一個鏈表。因此與鏈表有關的操作幾乎都能用遞歸的方式解決。
以一道LeetCode上的題目爲例來看一下遞歸的威力：

這道題目是很簡單的，正常的書寫邏輯就可以達到想要的效果，在java語言下，系統給出的模板是這樣的：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode removeElements(ListNode head, int val) {
        
    }
}

我們需要在Solution內書寫我們的邏輯完成想要達到的效果，在此之前，首先在自己的IDE上書寫代碼，筆者將給出使用遞歸和不使用遞歸的兩種解答：
不使用遞歸的情況
（注：LeetCode平臺給出了節點類，爲了調試方便，在自己的IDE上相應創建相同的節點類。）
不使用遞歸就要考慮鏈表如何構建，這裏先給出不帶虛擬頭結點的鏈表解決方案（也就是頭結點儲存了我們的數據）：

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        while(head != null && head.val == val){
            ListNode delNode = head;
            head = head.next;
            delNode.next = null;
        }
        if(head == null)
            return head;//鏈表裏全是要刪除的元素則返回null
        ListNode prev = head;
        while(prev.next != null){
            if(prev.next.val == val){
                ListNode delNode = prev.next;
                prev.next = delNode.next;
                delNode.next = null;
            }
            else
                prev = prev.next;
        }
        return head;
    }
}

帶虛擬頭結點的解決方案：

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        //設置虛擬頭結點，不過對用戶是屏蔽的
        ListNode dummyHead = new ListNode(-1);
        dummyHead.next = head;

        ListNode prev = dummyHead;
        while(prev.next != null){
            if(prev.next.val == val){
                ListNode delNode = prev.next;
                prev.next = delNode.next;
                delNode.next = null;
            }
            else
                prev = prev.next;
        }
        return dummyHead.next;
    }
}

設置了虛擬頭結點後可以省去第一步對真實儲存了信息的頭結點的判斷，減少一點代碼量。
使用遞歸方案
使用遞歸方案就要思考遞歸的邏輯是什麼

• 鏈表頭結點爲空否，爲空則返回(遞歸終止條件)
• 遞歸處理去掉頭結點後的鏈表(遞歸過程)
• 頭結點是否需要刪除，如果是則返回頭結點後的鏈表，否則返回頭結點(最後處理)

依照這個邏輯給出下面用遞歸方式書寫的代碼:

public class Solution4 {
    public ListNode remove(ListNode head,int val){
        if(head == null)
            return head;
        head.next = remove(head.next,val);
        return head.val == val ? head.next : head;
    }
}

可以看到，使用遞歸後，我們的代碼簡化到只有4行。

儘管遞歸能很大程度上簡化代碼，不過使用遞歸是有代價的，遞歸需要使用系統棧，每次調用要將斷點保存到系統棧中，如果調用過程很多，將非常消耗系統資源，所以性能上一般比不用遞歸的方式差一些。不過一些複雜的數據結構中(樹、森林、圖等)，遞歸能很好地展示程序邏輯，所以有時爲了減少代碼量增加程序可讀性，使用遞歸是必要的。

---

二分搜索樹

樹結構同樣具有天然的遞歸性質，這裏以二分搜索樹的各種操作爲例，來看一下遞歸的用處，二分搜索樹的所有相關操作都用遞歸的方式實現:

import java.util.Stack;
public class BST<E extends Comparable<E>> {
    //二分搜索樹並不支持所有泛型，泛型必須滿足可比較性
    private class Node{
        //二分搜索樹作爲內部私有類，節點對用戶是屏蔽的,用戶不必知道節點如何
        public E e;
        public Node left,right;
        public Node(E e){
            this.e = e;
            left = null;
            right = null;
        }
    }
    private Node root;
    private int size;

    public BST(){
        //不寫的話也是可以，因爲這裏的構造函數和默認一樣
        root = null;
        size = 0;
    }
    public int size(){
        return size;
    }
    public boolean isEmpty(){
        return size == 0;
    }
    public void add(E e){
        root = add(root,e);
    }
    private Node add(Node node, E e){
        //向以Node爲根的二分搜索樹插入元素e，遞歸
        //返回插入新節點後二分搜索樹的根
        if(node == null){
            size ++;
            return new Node(e);
        }
        //以上是遞歸終止條件,下是遞歸調用
        if(e.compareTo(node.e)<0)
            node.left = add(node.left,e);
        else if(e.compareTo(node.e)>0)
            node.right = add(node.right,e);
        return node;
    }
    //二分搜索樹查詢操作
    public boolean contains(E e){
        return contains(root,e);
    }
    private boolean contains(Node node,E e){
        if(node == null)
            return false;
        if(e.compareTo(node.e) == 0)
            return true;
        else if (e.compareTo(node.e)<0)
            return contains(node.left,e);
        else
            return contains(node.right,e);
    }
    //二分搜索樹的遍歷操作
    public void preOrder(){
        preOrder(root);
    }
    private void preOrder(Node node){
        //前序遍歷以node爲根的二分搜索樹，遞歸算法
        //if(node == null) return ;//遞歸終止條件
        if(node != null) {
            System.out.println(node.e);
            preOrder(node.left);
            preOrder(node.right);
        }
    }
    //前序遍歷的非遞歸實現
    public void preOrderNR(){
        Stack<Node> stack = new Stack<>();
        stack.push(root);
        while(!stack.isEmpty()){
            Node cur = stack.pop();
            System.out.println(cur.e);
            if(cur.right != null)
                stack.push(cur.right);
            if(cur.left != null)
                stack.push(cur.left);
        }
    }
    //中序遍歷
    public void inOrder(){
        inOrder(root);
    }
    private void inOrder(Node node){
        if(node == null)
            return ;
        inOrder(node.left);
        System.out.println(node.e);
        inOrder(node.right);
    }
    //後序遍歷
    public void postOrder(){
        postOrder(root);
    }
    private void postOrder(Node node){
        if(node == null)
            return ;
        postOrder(node.left);
        postOrder(node.right);
        System.out.println(node.e);
    }

    @Override
    public String toString(){
        StringBuilder res = new StringBuilder();
        generateBSTString(root, 0, res);
        return res.toString();
    }
    //生成以node爲根節點，深度爲depth的描述二叉樹的字符串
    private void generateBSTString(Node node,int depth,StringBuilder res){
        if(node==null){
            res.append(generateDepthString(depth) + "null\n");
            return;
        }
        res.append(generateDepthString(depth) + node.e + "\n");
        generateBSTString(node.left,depth+1,res);
        generateBSTString(node.right,depth+1,res);
    }
    private String generateDepthString(int depth){
        StringBuilder res = new StringBuilder();
        for(int i=0;i<depth;i++)
            res.append("--");
        return res.toString();
    }
}

從代碼中看到，其中的前序遍歷過程也給出了非遞歸方式的寫法，非遞歸的寫法需要藉助棧這種數據結構，代碼相應也複雜的多。可見遞歸方式能帶來很大的便利。

---

遞歸的用處遠比想象的要多，熟練運用遞歸能讓我們寫出很有feel的代碼。