LeetCode172--复杂链表的复制(O35)、二叉搜索树与双向链表(O36)、栈的压入、弹出序列(O31)、字符串的排序(O38)

1、复杂链表的复制

//请实现 copyRandomList 函数，复制一个复杂链表。在复杂链表中，每个节点除了有一个 next 指针指向下一个节点，还有一个 random 指针指
//向链表中的任意节点或者 null。
//
//
//
// 示例 1：
//
//
//
// 输入：head = [[7,null],[13,0],[11,4],[10,2],[1,0]]
//输出：[[7,null],[13,0],[11,4],[10,2],[1,0]]
//
//
// 示例 2：
//
//
//
// 输入：head = [[1,1],[2,1]]
//输出：[[1,1],[2,1]]
//
//
// 示例 3：
//
//
//
// 输入：head = [[3,null],[3,0],[3,null]]
//输出：[[3,null],[3,0],[3,null]]
//
//
// 示例 4：
//
// 输入：head = []
//输出：[]
//解释：给定的链表为空（空指针），因此返回 null。
//
//
//
//
// 提示：
//
//
// -10000 <= Node.val <= 10000
// Node.random 为空（null）或指向链表中的节点。
// 节点数目不超过 1000 。
//
//
//
//
// 注意：本题与主站 138 题相同：https://leetcode-cn.com/problems/copy-list-with-random-point
//er/
//
//
// Related Topics 哈希表 链表

复杂链表主要通过建立新老链表之间的关联来进行赋值，首先建立一个hashMap，将新链表的节点和老链表进行一一对应，然后当我们需要进行next连接两个节点的时候就有map.get(pre).random=map.get(pre.random)。

public Node copyRandomList(Node head) {
        if(head == null){
            return null;
        }
        Node cur = head;
        Map<Node, Node> map = new HashMap<>();
        //复制各节点,并建立“源节点”到“新节点”的Map映射
        while(cur != null){
            map.put(cur, new Node(cur.val));
            cur = cur.next;
        }
        cur = head;
        //4.构建起新链表的next和random指向
        while(cur != null){
            map.get(cur).next = map.get(cur.next);
            map.get(cur).random = map.get(cur.random);
            cur = cur.next;
        }
        return map.get(head);
    }

2、二叉搜索树与双向链表

//输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的循环双向链表。要求不能创建任何新的节点，只能调整树中节点指针的指向。
//
//
//
// 为了让您更好地理解问题，以下面的二叉搜索树为例：
//
//
//
// 我们希望将这个二叉搜索树转化为双向循环链表。链表中的每个节点都有一个前驱和后继指针。对于双向循环链表，第一个节点的前驱是最后一个节点，最后一个节点的后继是
//第一个节点。
//
// 下图展示了上面的二叉搜索树转化成的链表。“head” 表示指向链表中有最小元素的节点。
//
//
//
//
//
//
//
// 特别地，我们希望可以就地完成转换操作。当转化完成以后，树中节点的左指针需要指向前驱，树中节点的右指针需要指向后继。还需要返回链表中的第一个节点的指针。
//
//
//
// 注意：本题与主站 426 题相同：https://leetcode-cn.com/problems/convert-binary-search-tree-
//to-sorted-doubly-linked-list/
//
// 注意：此题对比原题有改动。
// Related Topics 栈 树 深度优先搜索 二叉搜索树 链表 二叉树 双向链表

这个题实际上是中序遍历，然后在中间需要保留前一次遍历的节点来和后面建立关系，直接看代码：

class Solution {
    Node head, pre;
    public Node treeToDoublyList(Node root) {
        if(root==null) return null;
        dfs(root);

        pre.right = head;
        head.left =pre;//进行头节点和尾节点的相互指向，这两句的顺序也是可以颠倒的

        return head;

    }

    public void dfs(Node cur){
        if(cur==null) return;
        dfs(cur.left);

        //pre用于记录双向链表中位于cur左侧的节点，即上一次迭代中的cur,当pre==null时，cur左侧没有节点,即此时cur为双向链表中的头节点
        if(pre==null) head = cur;
        //反之，pre!=null时，cur左侧存在节点pre，需要进行pre.right=cur的操作。
        else pre.right = cur;
       
        cur.left = pre;//pre是否为null对这句没有影响,且这句放在上面两句if else之前也是可以的。

        pre = cur;//pre指向当前的cur
        dfs(cur.right);//全部迭代完成后，pre指向双向链表中的尾节点
    }
}

3、栈的压入、弹出序列

//输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如，序列 {1,2,3,4,5} 是某栈
//的压栈序列，序列 {4,5,3,2,1} 是该压栈序列对应的一个弹出序列，但 {4,3,5,1,2} 就不可能是该压栈序列的弹出序列。
//
//
//
// 示例 1：
//
// 输入：pushed = [1,2,3,4,5], popped = [4,5,3,2,1]
//输出：true
//解释：我们可以按以下顺序执行：
//push(1), push(2), push(3), push(4), pop() -> 4,
//push(5), pop() -> 5, pop() -> 3, pop() -> 2, pop() -> 1
//
//
// 示例 2：
//
// 输入：pushed = [1,2,3,4,5], popped = [4,3,5,1,2]
//输出：false
//解释：1 不能在 2 之前弹出。
//
//
//
//
// 提示：
//
//
// 0 <= pushed.length == popped.length <= 1000
// 0 <= pushed[i], popped[i] < 1000
// pushed 是 popped 的排列。
//
//
// 注意：本题与主站 946 题相同：https://leetcode-cn.com/problems/validate-stack-sequences/
// Related Topics 栈 数组 模拟

这题直接采用一个模拟栈来进行验证，通过将·pushed中的元素压入栈中，遍历popped数组，如果栈顶元素和popped中的相等就出栈，不相等继续入栈直至相等，等遍历完poped之后，栈一定为空。

public boolean validateStackSequences(int[] pushed, int[] popped) {
        Stack<Integer> stack = new Stack<>();
        int index = 0;
        for (int num : pushed) {
            stack.push(num);
            //栈顶元素和出栈元素相等就出栈，否则就入栈
            while(!stack.isEmpty() && stack.peek() == popped[index]){
                stack.pop();
                index++;
            }
        }
        return stack.isEmpty();
    }

4、自符的排序

//输入一个字符串，打印出该字符串中字符的所有排列。
//
//
//
// 你可以以任意顺序返回这个字符串数组，但里面不能有重复元素。
//
//
//
// 示例:
//
// 输入：s = “abc”
//输出：[“abc”,“acb”,“bac”,“bca”,“cab”,“cba”]
//
//
//
//
// 限制：
//
// 1 <= s 的长度 <= 8
// Related Topics 字符串 回溯

一道普通的回溯，但是需要我们采用一个数组来标记哪些字母已经用过了，需要一个set来保证里面的数据不存在重复的。

class Solution {
    public String[] permutation(String s) {
        Set<String> set = new HashSet<>();
        int index = 0;
        boolean[] vis = new boolean[s.length()];
        dfs(s, "", set, index, vis);
        String[] str = new String[set.size()];
        int i = 0;
        for (String item : set) {
            str[i++] = item;
        }
        return str;
    }
    private void dfs(String s, String result, Set set, int index, boolean[] vis){
        if(index == s.length()){
            set.add(result);
            return;
        }
        for (int i = 0; i < s.length(); i++) {
            if(!vis[i]){
                vis[i] = true;
                result += s.charAt(i);
                dfs(s, result, set, index+1, vis);
                //回溯
                result = result.substring(0, result.length()-1);
                vis[i] = false;
            }
        }
    }
}