递归

1. 严格定义递归函数的作用
2. 递归的 终止条件
3. 先一般，后特殊
4. 规模最小化

demo1：递归求和

package com.mark.linked;

/** * author:Mark * date:2018/8/7 15:18 * 利用递归的思想；求和 * 1;规模最下化 */
public class Sum {`这里写代码片`

    public static int sum(int[] arr) {//开放外界的接口
        return sum(arr, 0);
    }

    //计算arr【left，n）这个区间的和
    private static int sum(int[] arr, int left) {//内部实现递归
        if (left == arr.length) {//1.求解的基本问题
            return 0;
        }
        return arr[left] + sum(arr, left + 1);//2.规模最小化
    }

    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        int result = sum(arr);
        System.out.println("Sum is "+result);
    }
}

运行结果：

Sum is 45

demo2：取出集合中指定元素个数的所有可能

package com.mark.linked;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/** * author:Mark * date:2018/8/7 19:54 * 在指定的结合中，取出n个元素的所有可能 */
public class Combinations {

    /** * * @param data 输入的数据集合 * @param n 在data中取出的元素的个数 */
    public void getCombinations(List<Integer> data,int n){
        List<Integer> result = new ArrayList<>();//存取选择的数据
        getCombinations(result, data, n);
    }

    /** * * @param selected 选择的数据保存到selected中 * @param data 输入的数据集合 * @param n 在data中取出的元素的个数 */
    private void getCombinations(List<Integer> selected, List<Integer> data, int n) {//内部实现递归的方法
        //递归的终止条件
        if (n == 0) {
            for (Integer i : selected){
                System.out.print(i);
                System.out.print(" ");
            }
            System.out.println();
            return;
        }
        if (data.isEmpty()) {
            return;
        }

        //规模最小化
        //如果选择第一个元素
        selected.add(data.get(0));//保存已选择的第一个数据
        getCombinations(selected,data.subList(1,data.size()),n-1);//在data【1，seize）中取出n-1个元素

        //如果没有选择第一个元素
        selected.remove(selected.size() - 1);
        getCombinations(selected,data.subList(1,data.size()),n);//在data【1，seize）中取出n个元素


    }

    public static void main(String[] args) {
        Combinations combinations = new Combinations();
        combinations.getCombinations(Arrays.asList(1, 2, 3, 4, 5), 2);
    }

}

运行结果：

1 2
1 3
1 4
1 5
2 3
2 4
2 5
3 4
3 5
4 5

demo3：递归创建链表
1.首先声明一个节点类

package com.link;

/** * author:Mark * date:2018/8/7 13:22 * 节点 */
public class Node {
    private final int value;//节点保存的数据
    private Node nextNode;//下一个节点

    Node(int value) {
        this.value = value;
        this.nextNode = null;
    }

    public int getValue() {
        return value;
    }

    public Node getNextNode() {
        return nextNode;
    }

    public void setNextNode(Node nextNode) {
        this.nextNode = nextNode;
    }

    public  static  String print(Node n) {
        Node node = n;
        StringBuffer stringBuffer = new StringBuffer();
        while (node != null) {
            stringBuffer.append(node.getValue());
            stringBuffer.append("->");
            node = node.nextNode;
        }
        stringBuffer.append("null");
        return stringBuffer.toString();
    }
}

2.递归实现形成链表

package com.link;

import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;

import java.util.Arrays;
import java.util.List;

/** * author:Mark * date:2018/8/7 12:48 * 递归创建链表 */

public class LinkedListCreator {

    /** * @param data 形成链表的数据 * @return 头节点 */
    public Node createLinkedList(List<Integer> data) {//递归方法
        //递归终止的条件
        if (data.isEmpty()) {
            return null;
        }

        Node firstNode = new Node(data.get(0));//第一个节点
        Node headOfSublist = createLinkedList(data.subList(1, data.size()));//在剩下的数据中创建链表
        firstNode.setNextNode(headOfSublist);
        return firstNode;
    }

    public static void main(String[] args) {
        Node node = new LinkedListCreator().createLinkedList(Arrays.asList(1, 2, 3, 4));
        System.out.println(Node.print(node));
    }
}

输出结果：

1->2->3->4->null

demo4：链表的反转

package com.link;

import java.util.Arrays;
import java.util.List;

/** * 链表的反转 * author:Mark * date:2018/8/7 13:15 */

public class LinkedListReverse {

    public Node reverseList(Node head) {//递归
        //递归的终止条件
        if (head == null ) {
            return null;
        }
        if (head.getNextNode() == null) {
            return head;
        }

        Node newHead = reverseList(head.getNextNode());
        head.getNextNode().setNextNode(head);
        head.setNextNode(null);
        return newHead;
    }

    public static void main(String[] args) {
        Node node = new LinkedListCreator().createLinkedList(Arrays.asList(1, 2, 3, 4));
        System.out.println("原链表："+Node.print(node));
        node = new LinkedListReverse().reverseList(node);
        System.out.println("反转后"+Node.print(node));
    }

}

输出结果：

原链表：1->2->3->4->null
反转后4->3->2->1->null