《剑指offer》算法题第七天

今日题目：

1. 复杂链表的复制
2. 二叉搜索树与双向链表
3. 序列化二叉树
4. 字符串的排序

1.复杂链表的复制

题目描述：
输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的head。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）

思路：
这道题比较简单的做法是利用哈希表，把旧节点当成key，把新节点当成value，然后再来建立关系，时间和空间复杂度均为O(n)
另外一种做法是将新生成的节点插入旧节点之间，然后再进行提取，时间复杂度为O(n)，空间复杂度为O(1)。

代码如下：

//利用HashMap
public class Solution {
    public RandomListNode Clone(RandomListNode pHead)
    {
        if(pHead == null) return null;
        Map<RandomListNode, RandomListNode> map = new HashMap<RandomListNode, RandomListNode>();
        RandomListNode p = pHead;
        while(p != null){
            map.put(p,new RandomListNode(p.label));
            p = p.next;
        }
        p = pHead;
        while(p != null){
            RandomListNode new_node = map.get(p);
            if(p.next != null)
                new_node.next = map.get(p.next);
            if(p.random != null)
                new_node.random = map.get(p.random);
            p = p.next;
        }
        return map.get(pHead);
    }
}


//没用到HashMap
public class Solution {
    public RandomListNode Clone(RandomListNode pHead)
    {
        if(pHead == null) return null;
        RandomListNode p = pHead;
        while(p != null){
            RandomListNode next = p.next;
            p.next = new RandomListNode(p.label);
            p.next.next = next;
            p = next;
        }
         
        p = pHead;
        while(p != null){
            if(p.random != null)
                p.next.random = p.random.next;
            p = p.next.next;
        }
         
        RandomListNode dummy = new RandomListNode(0);
        RandomListNode q = dummy;
        p = pHead;
        while(p != null){
            RandomListNode tmp = p.next.next;
            q.next = p.next;
            q = q.next;
             
            p.next = tmp;
             
            p = tmp;
        }
         
        return dummy.next;
    }
}

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

题目描述：
输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。

思路：
这道题利用二叉搜索树中序遍历序列递增的特性来求解，比较直接。

代码如下：

public class Solution {
    public TreeNode Convert(TreeNode root) {
        if(root == null) return null;
        Stack<TreeNode> stack = new Stack();
        boolean flag = true;
        TreeNode p = root;
        TreeNode pre = null;
        while(p != null || !stack.empty()){
            if(p != null){
                stack.push(p);
                p = p.left;
            }else{
                TreeNode node = stack.pop();
                if(flag){
                    root = node;
                    flag = false;
                }
                if(pre != null)
                    pre.right = node;
                node.left = pre;
                pre = node;
                p = node.right;
            }
        }
        return root;
        
    }
}

3. 序列化二叉树

题目描述：
请实现两个函数，分别用来序列化和反序列化二叉树

思路：
序列化：比较直接，先序遍历二叉树来生成序列
反序列化：也是根据先序遍历的思想来做的，但是可能比起序列化来说没那么直观。

代码如下：

public class Solution {
    int index = -1;
    String Serialize(TreeNode root) {
        StringBuffer sb = new StringBuffer();
        if(root == null){
            sb.append("#,");
            return sb.toString();
        }
        sb.append(root.val+",");
        sb.append(Serialize(root.left));
        sb.append(Serialize(root.right));
        return sb.toString();
  }
    TreeNode Deserialize(String str) {
        index++;
       int len = str.length();
        if(index >= len){
            return null;
        }
        String[] strr = str.split(",");
        TreeNode node = null;
        if(!strr[index].equals("#")){
            node = new TreeNode(Integer.valueOf(strr[index]));
            node.left = Deserialize(str);
            node.right = Deserialize(str);
        }
         
        return node;
  }
}

4. 字符串的排列

题目描述：
输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。

思路：
回溯法的题目做多了这道题就不是什么难事，唯一要注意的是字符串中的字符有可能是有重复的。
参考答案给了另外一种基于交换的解法，比博主自己写的回溯要好得多，下面贴出代码给大家参考。

代码如下：

//博主写的回溯法
public class Solution {
    public ArrayList<String> Permutation(String str) {
        ArrayList<String> res = new ArrayList();
        if(str.length() == 0) return res;
        char[] arr = str.toCharArray();
        Arrays.sort(arr);
        backtrack(arr,res,new StringBuffer(),new HashSet());
        return res;
    }
     
    public void backtrack(char[] arr,ArrayList<String> res,StringBuffer sb,HashSet<Integer> visited){
        if(sb.length() == arr.length){
            res.add(sb.toString());
            return;
        }
        for(int i = 0; i < arr.length; i++){
            if(visited.contains(i)) continue;
            sb.append(arr[i]);
            visited.add(i);
            backtrack(arr,res,sb,visited);
            visited.remove(i);
            sb.deleteCharAt(sb.length()-1);
            while(i < arr.length-1 && arr[i] == arr[i+1]) i++;
        }
    }
}


//参考答案给的方法，强烈推荐！！
public class Solution {
    public ArrayList<String> Permutation(String str) {
        ArrayList<String> res = new ArrayList();
        if(str.length() == 0) return res;
        char[] arr = str.toCharArray();
        backtrack(arr,res,0);
        Collections.sort(res);
        return res;
    }
     
    public void backtrack(char[] arr,ArrayList<String> res,int ind){
        if(ind == arr.length-1){
            res.add(String.valueOf(arr));
            return;
        }
        for(int i = ind; i < arr.length; i++){
            if(i != ind && arr[i] == arr[ind]) continue;
            char swap = arr[ind];
            arr[ind] = arr[i];
            arr[i] = swap;
             
            backtrack(arr,res,ind+1);
             
            swap = arr[ind];
            arr[ind] = arr[i];
            arr[i] = swap;
        }
    }
}