13.分解让复杂问题简单（3）

题一：【复杂链表的复制】

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

 分析：复制一个链表，则需要复制链表中的每一个节点和节点之间的关系，而不只是只复制一个头节点直接引用那么简单。

　　 

/*
public class RandomListNode {
    int label;
    RandomListNode next = null;
    RandomListNode random = null;

    RandomListNode(int label) {
        this.label = label;
    }
}
*/
public class Solution {
    public RandomListNode Clone(RandomListNode pHead)
    {
        if(pHead==null) return null;
        RandomListNode head = pHead;
        //1.在旧链表中创建新链表，此时不处理新链表的兄弟节点
        while(head!=null){
            RandomListNode node = new RandomListNode(head.label);//复制链表的结点
            node.next = head.next;
            head.next = node;
            head = head.next.next;
        }
        //2.根据旧链表的兄弟节点，初始化新链表的兄弟节点random
        head = pHead;//此时head是原来链表和复制后的链表集合
        while(head!=null){
            RandomListNode node = head.next;
            if(head.random!=null){
                node.random = head.random.next;
            }
            head = head.next.next;
        }
        //3.从旧链表中拆分得到新链表
        head = pHead;
        RandomListNode newHead = head.next;
        while(head!=null){
            RandomListNode node = head.next;
            head.next = node.next;
            if(node.next!=null){
                node.next = node.next.next;
            }
            head = head.next;
        }
        return newHead;
    }
}

题二：【二叉搜索树与双向链表】

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

分析：中序遍历，先将遍历的节点添加进一个列表中，再重新节点索引。

import java.util.ArrayList;
/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
public class Solution {
    ArrayList<TreeNode> list = new ArrayList<TreeNode>();
    public TreeNode Convert(TreeNode pRootOfTree) {
        if(pRootOfTree==null) return null;
        helpConvert(pRootOfTree);
        sort(list);
        return list.get(0);
    }
    public void helpConvert(TreeNode pRootOfTree){
        if(pRootOfTree==null) return;
        helpConvert(pRootOfTree.left);
        list.add(pRootOfTree);
        helpConvert(pRootOfTree.right);
    }
    public void sort(ArrayList<TreeNode> list){
        for(int i=0;i<list.size()-1;i++){
            list.get(i).right = list.get(i + 1);
            list.get(i + 1).left = list.get(i);
        }
    }
}

题三：【字符串的排列】

输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。（输入一个字符串,长度不超过9(可能有字符重复),字符只包括大小写字母。）

分析：使用递归。每次将当前索引处字符和后边字符轮流交换，例如i=0，j=i，j++时，字符a轮流后bcde交换。每次交换之后递归字串，例如a和b交换后变成bacde，再递归acde，以此类推。直到当i=4时，递归结束，将此时字符添加进列表中。

　　【注意1】每次递归前swap交换字符，递归后要复位，再进行一次swap，例如ab cde（空格忽略，此处为标识），此时交换cc、cd、ce，若进行到交换cd时，此时字符串为ab dce，若abd ce（字串）递归完成，要将cd再次交换成ab cde，进行ce的交换递归。

　　【注意2】

import java.util.*;
public class Solution {
    public ArrayList<String> Permutation(String str) {
        ArrayList<String> list = new ArrayList<String>();
        char[] arr = str.toCharArray();
        if(str.length()>0&&str!=null){
            Permutation(arr, 0, list);
            Collections.sort(list);
        }
        return list;
    }
    public void Permutation(char[] arr, int i, ArrayList<String> list){
        if(i==arr.length-1){
            list.add(String.valueOf(arr));
        }else{
            for(int j=i;j<arr.length;j++)
            {            
                if(!(arr[i]==arr[j]&&i!=j)) //此处防止重复字符
                {                
                    swap(arr,i,j);
                    Permutation(arr,i+1,list);
                    swap(arr,i,j);
                }
            }
        }
    }
    public void swap(char[] arr, int i, int j){
        char tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }
}