《剑指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;
         }
     }
 }