基础&算法|Java递归算法练习

版权声明：本文为博主原创文章，未经允许不得转载。 https://blog.csdn.net/qq_24672657/article/details/82940696

Java递归算法练习

使用java实现几个比较简单的递归面试题

写递归算法的时候，可以类比数学归纳法。

将每步先简化

单向链表与递归算法

实现单向链表

Node.java

/**
 * @ClassName Node
 * @Description TODO
 * @Version 1.0
 **/
public class Node {
    private final Integer vaule;
    private Node nextNode;

    public Node(Integer vaule) {
        this.vaule = vaule;
    }

    public Integer getVaule() {
        return vaule;
    }

    public Node getNextNode() {
        return nextNode;
    }

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

    public static void printLinkedList(Node node) {
        while (node != null) {
            System.out.print(node.getVaule());
            System.out.print(" ");
            node = node.nextNode;
        }

        System.out.println();
    }
}

CreateLinkedList.java

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

/**
 * @ClassName CreateLinkedList
 * @Description TODO
 * @Version 1.0
 **/
public class CreateLinkedList {


    /**
     * 创建一个链表
     * @param data 数据源
     * @return 返回链表的头结点
     */
    public Node createLinkedList(List<Integer> data){
        if (data.isEmpty()) {
            return null;
        }
        // 递归实现
        Node firstNode = new Node(data.get(0));
        Node nextNode = createLinkedList(data.subList(1, data.size()));
        firstNode.setNextNode(nextNode);
        return firstNode;
    }


    public static void main(String[] args) {
        CreateLinkedList createLinkedList = new CreateLinkedList();
        Node.printLinkedList(createLinkedList.createLinkedList(Arrays.asList(1)));
        Node.printLinkedList(createLinkedList.createLinkedList(Arrays.asList()));
        Node.printLinkedList(createLinkedList.createLinkedList(Arrays.asList(1,2,3,4)));

    }
}

反转链表

import java.util.Arrays;

/**
 * @ClassName LinkedListReverser
 * @Description TODO
 * @Version 1.0
 **/
public class LinkedListReverser {

    public Node reverserLinkedList(Node head){
        // 相当于0的情况
        if (head == null) {
            return null;
        }
        // 一个节点的时候，递归到最后一个节点了
        if (head.getNextNode() == null) {
            return head;
        }
        
        // 递归实现
        Node newHead  = reverserLinkedList(head.getNextNode());
        head.getNextNode().setNextNode(head);
        head.setNextNode(null);

        return newHead;

    }

    public static void main(String[] args) {
        LinkedListReverser reverser = new LinkedListReverser();


        CreateLinkedList createLinkedList = new CreateLinkedList();
        Node.printLinkedList(reverser.reverserLinkedList(
                createLinkedList.createLinkedList(Arrays.asList()))
        );
        Node.printLinkedList(reverser.reverserLinkedList(
                createLinkedList.createLinkedList(Arrays.asList(1,2,3,4)))
        );
        Node.printLinkedList(reverser.reverserLinkedList(
                createLinkedList.createLinkedList(Arrays.asList(1)))
        );
    }
}

数字组合

给定一组数字，指定数目的一组数，列出所有可能

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

/**
 * @ClassName ListGroup
 * @Description TODO
 * @Version 1.0
 **/
public class ListGroup {

    public void listDroup(List<Integer> select,List<Integer> data, int n){

        // n个数都已经选好了
        if (n == 0) {
            for (int i=0;i<select.size();i++) {
                System.out.print(select.get(i));
                System.out.print(" ");
            }
            System.out.println();
            return;
        }
        if (data.isEmpty()) {
            return;
        }

        // 选择第一个元素
        select.add(data.get(0));
        listDroup(select,data.subList(1,data.size()),n-1);

        // 不选择第一个元素
        select.remove(select.size()-1);
        listDroup(select,data.subList(1,data.size()),n);


    }

    public static void main(String[] args) {
        ListGroup listGroup = new ListGroup();
        listGroup.listDroup(new ArrayList<>(),Arrays.asList(1,2,3,4,5,6),2);

        // 其他边界条件测试省略
    }

}