递归算法与数据结构：汉诺塔、子序列、排列及栈的逆序-CSDN博客

本文链接：https://blog.csdn.net/codingToMaster/article/details/117912920

暴力递归

暴力递归就是尝试

把问题转化为规模缩小了的同类问题的子问题
有明确的不需要继续进行递归的条件(base case)
有当得到了子问题的结果之后的决策过程
不记录每个子问题的解

汉诺塔问题：

汉诺塔(Tower of Hanoi)源于印度传说中，大梵天创造世界时造了三根金钢石柱子，其中一根柱子自底向上叠着64片黄金圆盘。大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上。并且规定，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘。

这是示意图，a是起始柱，c是目标柱，b起到中转作用

在进行转移操作时，都必须确保大盘在小盘下面，且每次只能移动一个圆盘，最终c柱上有所有的盘子且也是从上到下按从小到大的顺序。

举例：

三个盘子，1-2移到中，将3直接移动到右。再将1-2移动到右

public class Code01_Hanoi {
    public static void main(String[] args) {
        Hanoi(4);
    }
    public static void Hanoi(int n) {
        leftToRight(n);
    }

    // 请把1-N层圆盘 从左-》右
    public static void leftToRight(int n) {
        if (n == 1) { // base case
            System.out.println("Move 1 from left to right");
            return;
        }
        leftToMid(n - 1);
        System.out.println("Move " + n + " from left to right");
        midToRight(n - 1);
    }

    // 请把1-N层圆盘 从左-》中
    private static void leftToMid(int n) {
        if (n == 1) {
            System.out.println("Move 1 from left to mid");
            return;
        }
        leftToRight(n - 1);
        System.out.println("Move " + n + " from left to mid");
        rightToMid(n - 1);
    }
    private static void rightToMid(int n) {
        if (n == 1) {
            System.out.println("Move 1 from right to mid");
            return;
        }

        rightToLeft(n - 1);
        System.out.println("Move " + n + " from left to mid");
        leftToMid(n - 1);
    }

    private static void rightToLeft(int n) {
        if (n == 1) {
            System.out.println("Move 1 from right to left");
            return;
        }

        rightToMid(n - 1);
        System.out.println("Move " + n + " from right to mid");
        midToLeft(n - 1);
    }

    private static void midToLeft(int n) {
        if (n == 1) {
            System.out.println("Move 1 from mid to left");
            return;
        }

        midToRight(n - 1);
        System.out.println("Move " + n + " from mid to left");
        rightToLeft(n - 1);
    }

    private static void midToRight(int n) {
        if (n == 1) {
            System.out.println("Move 1 from mid to right");
            return;
        }

        midToLeft(n - 1);
        System.out.println("Move " + n + " from mid to right");
        leftToRight(n - 1);
    }
}

优化：

public class Code02_Hanoi {
    public static void main(String[] args) {
        func(3, "left", "right", "other");
    }

    public static void func(int N, String from, String to, String other) {
        if (N == 1) {
            System.out.println("Move 1 form " + from + " to " + to);
        } else {
            func(N - 1, from, other, to);
            System.out.println("Move" + N + " form " + from + " to " + to);
            func(N - 1, other, to, from);
        }
    }
}

打印一个字符串的全部子序列：

可以不连续的

   // "abc"
    // 打印一个字符串的全部子序列
    public static List<String> subs(String s) {
        char[] chars = s.toCharArray();

        String path = "";
        List<String> res = new ArrayList<>();
        process(chars, 0, res, path);
        return res;
    }

    // str 固定参数
    // 来到了str[index]字符，index是位置
    // str[0..index-1]已经走过了！之前的决定，都在path上
    // 之前的决定已经不能改变了，就是path
    // str[index....]还能决定，之前已经确定，而后面还能自由选择的话，
    // 把所有生成的子序列，放入到ans里去
    private static void process(char[] chars, int index, List<String> res, String path) {
        if (index == chars.length) {
            res.add(path);
            return;
        }

        process(chars, index + 1, res, path);
        process(chars, index + 1, res, path + chars[index]);
    }

打印一个字符串的全部子序列，要求不要出现重复字面值的子序列

    /**
     * 打印一个字符串的全部子序列，要求不要出现重复字面值的子序列
     */
    public static List<String> subsNoRepeat(String s) {
        char[] chars = s.toCharArray();

        String path = "";
        Set<String> set = new HashSet<>();
        process1(chars, 0, set, path);
        List<String> ans = new ArrayList<>();
        for (String cur : set) {
            ans.add(cur);
        }
        return ans;
    }

    private static void process1(char[] chars, int index, Set<String> res, String path) {
        if (index == chars.length) {
            res.add(path);
            return;
        }

        process1(chars, index + 1, res, path);
        process1(chars, index + 1, res, path + chars[index]);
    }

打印一个字符串的全部排列

   public static List<String> permutation(String s) {
        List<String> res = new ArrayList<>();
        if (s == null || s.length() == 0) {
            return res;
        }
        char[] chars = s.toCharArray();
        List<Character> list = new ArrayList<>();
        for (char ch : chars) {
            list.add(ch);
        }
        String path = "";
        process(list, path, res);
        return res;
    }

    private static void process(List<Character> rest, String path, List<String> res) {
        if (rest.isEmpty()) {
            res.add(path);
            return;
        }

        for (int i = 0; i < rest.size(); i++) {
            char ch = rest.get(i);
            rest.remove(i);
            process(rest, path + ch, res);
            rest.add(i, ch);
        }
    }

    public static List<String> permutation1(String s) {
        List<String> res = new ArrayList<>();
        if (s == null || s.length() == 0) {
            return res;
        }
        char[] chars = s.toCharArray();
        process1(chars, 0, res);
        return res;
    }

    private static void process1(char[] chars, int index, List<String> res) {
        if (index == chars.length) {
            res.add(String.valueOf(chars));
            return;
        }

        for (int i = index; i < chars.length; i++) {
            swap(chars, index, i);
            process1(chars, index + 1, res);
            swap(chars, index, i);
        }
    }

    private static void swap(char[] chs, int i, int j) {
        char tmp = chs[i];
        chs[i] = chs[j];
        chs[j] = tmp;
    }

打印一个字符串的全部排列，要求不要出现重复的排列

    private static void swap(char[] chs, int i, int j) {
        char tmp = chs[i];
        chs[i] = chs[j];
        chs[j] = tmp;
    }

    public static List<String> permutationNoRepeat(String s) {
        List<String> ans = new ArrayList<>();
        if (s == null || s.length() == 0) {
            return ans;
        }
        char[] str = s.toCharArray();
        process3(str, 0, ans);
        return ans;
    }

    private static void process3(char[] chars, int index, List<String> res) {
        if (index == chars.length) {
            res.add(String.valueOf(chars));
            return;
        }
        boolean[] visited = new boolean[256];
        for (int i = index; i < chars.length; i++) {
            if (!visited[chars[i]]) {
                visited[chars[i]] = true;
                swap(chars, index, i);
                process3(chars, index + 1, res);
                swap(chars, index, i);
            }
        }
    }

给你一个栈，请你逆序这个栈，不能申请额外的数据结构，只能使用递归函数，如何实现？

package com.zh.class10_17;

import java.util.Stack;

public class ReverseStackUsingRecursive {
    public static void reverse(Stack<Integer> stack) {
        if (stack.isEmpty()) {
            return;
        }
        int i = f(stack);
        reverse(stack);
        stack.push(i);
    }

    // 栈底元素移除掉
    // 上面的元素盖下来
    // 返回移除掉的栈底元素
    public static int f(Stack<Integer> stack) {
        int result = stack.pop();
        if (stack.isEmpty()) {
            return result;
        } else {
            int last = f(stack);
            stack.push(result);
            return last;
        }
    }

    public static void main(String[] args) {
        Stack<Integer> test = new Stack<Integer>();
        test.push(1);
        test.push(2);
        test.push(3);
        test.push(4);
        test.push(5);
        reverse(test);
        while (!test.isEmpty()) {
            System.out.println(test.pop());
        }
    }
}