剑指编程（6）

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

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 p = new RandomListNode(pHead.label);
        //由于复制只需要复制链表本身，随机节点指针引用原来的即可
        p.random = pHead.random;
        p.next = Clone(pHead.next);
        return p;
    }
}

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

class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;
    public TreeNode(int val) {
        this.val = val;
    }
}
public class Solution {
    //二叉搜索树的中序遍历的输出就是排序的
    //只需要left指向前，right指向后
    TreeNode head = null;
    TreeNode pre = null;
    public TreeNode Convert(TreeNode pRootOfTree) {
        if(pRootOfTree == null) {
            return null;
        }
        //递归的中序遍历
        Convert(pRootOfTree.left);
        if(head == null) {
            head = pRootOfTree;
            pre = pRootOfTree;
        }else {
            pre.right = pRootOfTree;
            pRootOfTree.left = pre;
            pre = pRootOfTree;
        }
        Convert(pRootOfTree.right);
        return head;
    }
}

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

public class Solution {
    //全排列问题可以用递归
    public ArrayList<String> Permutation(String str) {
       char[] chs = str.toCharArray();
       ArrayList<String> res = new ArrayList<>();
        if(str == null || str.length() == 0) {
            return res;
        }
       //因为可能有字符重复，所以需要set去重
       Set<String> set = new TreeSet<>();//treeSet保证结果集为字典序
       recursion(chs, set, 0);
       res.addAll(set);
       return res;
    }

    public void recursion(char[] chs, Set<String> set, int pos) {
        if(pos == chs.length) {
            set.add(String.valueOf(chs));
            return;
        }
        //策略就是把某个位置可能出现的字符的所有情况列出，并递归搜索下去
        for(int i = pos; i < chs.length; i++) {
            //i == pos时，表示该位置保持不变，同样合法
            swap(chs, i, pos);
            recursion(chs, set, pos + 1);
            swap(chs, i, pos);
        }
    }

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

四、
数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。
例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。
由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。
如果不存在则输出0。

public class Solution {
    //以空间换时间，用HashMap存出现次数
    public int MoreThanHalfNum_Solution(int [] array) {
        Map<Integer, Integer> map = new HashMap<>();
        for(int i = 0; i < array.length; i++) {
            if(!map.containsKey(array[i])) {
                map.put(array[i], 1);
            }else {
                map.put(array[i], map.get(array[i]) + 1);
            }
        }
        for(int i : map.keySet()) {
            if(map.get(i) > array.length / 2) {
                return i;
            }
        }
        return 0;
    }
}

五、
输入n个整数，找出其中最小的K个数。
例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4,。

public class Solution {
    //有关数组前K个数的，用堆排序基本能解决且效率高
    //最小的K个数，则应构建大顶堆
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        ArrayList<Integer> res = new ArrayList<>();
        if(input == null || input.length == 0 || k > input.length) {
            return res;
        }
        for(int i = input.length / 2 - 1; i >= 0; i--) {
            adjustHeap(input, i, input.length);
        }
        for(int i = input.length - 1; i > input.length - 1 - k; i--) {
            res.add(input[0]);
            int tmp = input[0];
            input[0] = input[i];
            input[i] = tmp;
            adjustHeap(input, 0, i);
        }
        return res;
    }

    public void adjustHeap(int[] input, int pos, int len) {
        int tmp = input[pos];
        while(2 * pos + 1 < len) {
            int child = 2 * pos + 1;
            if(child + 1 < len && input[child + 1] < input[child]) {
                child++;
            }
            if(input[child] < tmp) {
                input[pos] = input[child];
            }else {
                break;
            }
            pos = child;
        }
        input[pos] = tmp;
    }
}