剑指offer 66道题目java实现全部代码

个人博客：小景哥哥

包含剑指offer全部题目，有题目描述，注释，个别题目有解题思路，还有一题多解等。

在这里提供给大家，供大家参考，欢迎大家提出不足和意见，目前在牛客网都是100%AC的。

package top.jinglisen.JianzhiOffer;

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Stack;

public class Solution {

    /**
     * 1
     * 在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
     * 
     * @param target
     * @param array
     * @return
     */
    public boolean Find(int target, int[][] array) {
        int rows = array.length;
        int cols = array[0].length;
        int i = rows - 1, j = 0;
        while (i >= 0 && j < cols) {
            if (target < array[i][j])
                i--;
            else if (target > array[i][j])
                j++;
            else
                return true;
        }
        return false;
    }

    /**
     * 2 请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are
     * Happy.则经过替换之后的字符串为We%20Are%20Happy。
     * 
     * @param str
     * @return
     */
    public String replaceSpace(StringBuffer str) {
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < str.toString().length(); i++) {
            if (String.valueOf(str.charAt(i)).endsWith(" ")) {
                sb.append("%20");
            } else {
                sb.append(String.valueOf(str.charAt(i)));
            }
        }
        return sb.toString();
    }

    /**
     * 
     * 请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are
     * Happy.则经过替换之后的字符串为We%20Are%20Happy。
     * 
     * @param str
     * @return
     */
    public String replaceSpace2(StringBuffer str) {
        return str.toString().replaceAll("\\s", "%20");
    }

    /**
     * 3 输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。
     * 
     * @author jason
     *
     */
    class ListNode {
        int val;
        ListNode next = null;

        ListNode(int val) {
            this.val = val;
        }
    }

    public ArrayList printListFromTailToHead(ListNode listNode) {
        ArrayList list = new ArrayList();
        if (listNode == null) {
            return list;
        }
        if (listNode != null) {
            list = printListFromTailToHead(listNode.next);
            list.add(listNode.val);
        }
        return list;
    }

    /**
     * 4
     * 输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。
     * 
     * @author jason
     *
     */
    class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;

        TreeNode(int x) {
            val = x;
        }
    }

    public TreeNode reConstructBinaryTree(int[] pre, int[] in) {
        TreeNode root = ConstructTree(pre, 0, pre.length - 1, in, 0, in.length - 1);
        return root;
    }

    public TreeNode ConstructTree(int[] pre, int start1, int end1, int[] in, int start2, int end2) {
        if (start1 > end1 || start2 > end2)
            return null;
        int rootData = pre[start1];
        TreeNode head = new TreeNode(rootData);
        // 在中序遍历中找到根节点所在的位置
        int rootIndex = findIndexInArray(in, rootData, start2, end2);
        int offSet = rootIndex - start2 - 1;
        // 构建左子树
        TreeNode left = ConstructTree(pre, start1 + 1, start1 + 1 + offSet, in, start2, start2 + offSet);
        // 构建右子树
        TreeNode right = ConstructTree(pre, start1 + offSet + 2, end1, in, rootIndex + 1, end2);
        head.left = left;
        head.right = right;
        return head;
    }

    public int findIndexInArray(int[] a, int x, int begin, int end) {
        for (int i = 0; i <= end; i++) {
            if (a[i] == x)
                return i;
        }
        return -1;
    }

    /**
     * 5 用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。
     */
    Stack stack1 = new Stack();
    Stack stack2 = new Stack();

    public void push(int node) {
        stack1.push(node);
    }

    public int pop() throws Exception {
        if (!stack2.isEmpty())
            return stack2.pop();
        else {
            while (!stack1.isEmpty()) {
                stack2.push(stack1.pop());
            }
            if (stack2.isEmpty())
                throw new Exception("query is empty");
            return stack2.pop();
        }
    }

    /**
     * 6.旋转数组的最小数字
     * 
     * 把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非减排序的数组的一个旋转，输出旋转数组的最小元素。
     * 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。
     * 
     * @param array
     * @return
     */
    public int minNumberInRotateArray(int[] array) {
        if (array.length <= 0)
            return 0;
        int index1 = 0;
        int index2 = array.length - 1;
        int indexMid = index1;
        while (array[index1] >= array[index2]) {
            if (index2 - index1 == 1) {
                indexMid = index2;
                break;
            }
            indexMid = (index1 + index2) / 2;
            if (array[indexMid] >= array[index1])
                index1 = indexMid;
            else if (array[indexMid] <= array[index2])
                index2 = indexMid;
        }
        return array[indexMid];
    }

    /**
     * 7 题目描述 大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0）。 n<=39
     */
    // 简单粗暴递归法
    public int Fibonacci2(int n) {

        if (n == 0)
            return 0;
        else if (n == 1)
            return 1;
        else
            return Fibonacci(n - 1) + Fibonacci(n - 2);
    }

    // 每个Fibonacci只计算一次，时间复杂度为O(n)
    public int Fibonacci(int n) {
        int result[] = new int[] { 0, 1 };
        if (n < 2)
            return result[n];
        int fibNMinusOne = 1;
        int fibNMinusTwo = 0;
        int fibN = 0;
        for (int i = 2; i <= n; i++) {
            fibN = fibNMinusOne + fibNMinusTwo;
            fibNMinusTwo = fibNMinusOne;
            fibNMinusOne = fibN;
        }
        return fibN;
    }

    /**
     * 8.跳台阶 题目描述 一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。
     * 
     * @param target
     * @return
     */
    public int JumpFloor(int target) {
        if (target <= 1)
            return 1;
        else
            return JumpFloor(target - 1) + JumpFloor(target - 2);
    }

    /**
     * 9
        关于本题，前提是n个台阶会有一次n阶的跳法。分析如下:
        f(1) = 1
        f(2) = f(2-1) + f(2-2)     //f(2-2) 表示2阶一次跳2阶的次数。
        f(3) = f(3-1) + f(3-2) + f(3-3)
        ...
        f(n) = f(n-1) + f(n-2) + f(n-3) + ... + f(n-(n-1)) + f(n-n)
        说明：
        1）这里的f(n) 代表的是n个台阶有一次1,2,...n阶的 跳法数。
        2）n = 1时，只有1种跳法，f(1) = 1
        3) n = 2时，会有两个跳得方式，一次1阶或者2阶，这回归到了问题（1） ，f(2) = f(2-1) + f(2-2)
        4) n = 3时，会有三种跳得方式，1阶、2阶、3阶，
        那么就是第一次跳出1阶后面剩下：f(3-1);第一次跳出2阶，剩下f(3-2)；第一次3阶，那么剩下f(3-3)
        因此结论是f(3) = f(3-1)+f(3-2)+f(3-3)
        5) n = n时，会有n中跳的方式，1阶、2阶...n阶，得出结论：
        f(n) = f(n-1)+f(n-2)+...+f(n-(n-1)) + f(n-n) => f(0) + f(1) + f(2) + f(3) + ... + f(n-1)
        6) 由以上已经是一种结论，但是为了简单，我们可以继续简化：
        f(n-1) = f(0) + f(1)+f(2)+f(3) + ... + f((n-1)-1) = f(0) + f(1) + f(2) + f(3) + ... + f(n-2)
        f(n) = f(0) + f(1) + f(2) + f(3) + ... + f(n-2) + f(n-1) = f(n-1) + f(n-1)
        可以得出：
        f(n) = 2*f(n-1)
        7) 得出最终结论,在n阶台阶，一次有1、2、...n阶的跳的方式时，总得跳法为：
        | 1    ,(n=0 )
        f(n) = | 1    ,(n=1 )
         | 2*f(n-1),(n>=2)
     * @param target
     * @return
     */
    public int JumpFloorII(int target) {
        if (target <= 0) {
            return -1;
        } else if (target == 1) {
            return 1;
        } else {
            return 2 * JumpFloorII(target - 1);
        }
    }

    /**
     *（1）假定第一次跳的是一阶，那么剩下的是n-1个台阶，跳法是f(n-1)；假定第一次跳的是2阶，那么剩下的是n-2个台阶，跳法是f(n-2)；假定第一次跳的是3阶，那么剩下的是n-3个台阶，跳法是f(n-3)......假定第一次跳的是n-1阶，那么剩下的是1个台阶，跳法是f(1)； 假定第一次跳的是n阶，那么剩下的是0个台阶，跳法是1种；
     *（2）总跳法为: f(n) = 1+f(n-1) + f(n-2)+....+f(1) （第一个1是跳n阶只有一种方法）
     *（3）根据（2）可以得出有一阶的时候 f(1) = 1 ；有两阶的时候可以有 f(2) = 1+f(1)=2；有三阶的时候可以有 f(3) = 1+f(2)+f(1)=4...依次内推，有n阶时f(n)=2^(n-1)。
     * @param target
     * @return
     */
    public int JumpFloorII2(int target) {
        int a = 1;
        return a << (target - 1);
    }

    /**
     * 题目描述
     * 我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？
     */
    public int RectCover(int target) {
        if (target < 1) {
            return 0;
        } else if (target == 1 || target == 2) {
            return target;
        } else {
            return RectCover(target-1) + RectCover(target-2);
        }
    }

    /**
     * 11 二进制中1的个数
     * 题目描述
     * 输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。
     */

    public int NumberOf1(int n) {
        int count = 0;
        while(n != 0){
            ++count;
            n = (n - 1) & n;
        }
        return count;
    }


    /**
     * 12 数值的整数次方
     * 题目描述
     * 给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。
     */
    public double Power(double base, int exponent){
        if(exponent > 0){
            return PowerWithUnsignedExponent(base,exponent);
        }else if(exponent < 0){
            return 1 / PowerWithUnsignedExponent(base, -exponent);
        }else
            return 1;

    }
    public double PowerWithUnsignedExponent(double base, int exponent) {

        if(exponent == 0)
            return 1.0;
        if(exponent == 1)
            return base * 1.0;
        double result = PowerWithUnsignedExponent(base, exponent >> 1);
        result *= result;
        if(exponent % 2 == 1)
            result *= base;
        return result;
    }


    /**
     * 13.调整数组顺序使奇数位于偶数前面
     * 题目描述
     * 输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。
     */
    public void reOrderArray(int [] array) {
        int index = -1;
        int indexOdd = -1;
        boolean flag = false;
        for(int i = 0; i < array.length; i++){
            if(array[i] % 2 == 0){
                if(!flag)
                    indexOdd = i;
                flag = true;
            }
            if((array[i] % 2 == 1) && flag){
                for(int j = i; j > indexOdd; j--){
                    int temp = array[j];
                    array[j] = array[j - 1];
                    array[j - 1] = temp;
                }
                indexOdd++;
            }

        }
    }

    /**
     * 14. 链表中倒数第k个结点
     * 题目描述
     *输入一个链表，输出该链表中倒数第k个结点。
     */
    public ListNode FindKthToTail(ListNode head,int k) {
        if(head == null || k < 1)
            return null;
        ListNode cur = head;
        ListNode backKth = null;
        int number = 0;
        while(cur!=null){
            number++;
            if(number == k)
                backKth = head;
            if(number > k)
                backKth = backKth.next;
            cur = cur.next;
        }
        return backKth;
    }
    /**
     * 15.反转链表
     * 题目描述
     * 输入一个链表，反转链表后，输出新链表的表头。
     */
    public ListNode ReverseList(ListNode head) {
        ListNode pReversedHead = null;
        ListNode pNode = head;
        ListNode pPrev = null;
        while(pNode != null){
            ListNode pNext = pNode.next;
            if(pNext == null)
                pReversedHead = pNode;
            pNode.next = pPrev;
            pPrev = pNode;
            pNode = pNext;
        }
        return pReversedHead;
    }

    /**
     * 16.合并两个排序的链表
     * 题目描述
     * 输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。
     */
    public ListNode Merge(ListNode list1,ListNode list2) {
        if(list1 == null)
            return list2;
        else if(list2 == null)
            return list1;
        ListNode pMergedHead = null;
        if(list1.val < list2.val){
            pMergedHead = list1;
            pMergedHead.next = Merge(list1.next, list2);
        }else{
            pMergedHead = list2;
            pMergedHead.next = Merge(list1, list2.next);
        }
        return pMergedHead;
    }

    /**
     * 17.树的子结构
     * 题目描述
     * 输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）
     */
    public boolean HasSubtree(TreeNode root1,TreeNode root2) {
        boolean result = false;
        if(root1 != null && root2 != null){
            if(root1.val == root2.val)
                result = DoesTree1HaveTree2(root1, root2);
            if(!result)
                result = HasSubtree(root1.left, root2);
            if(!result)
                result = HasSubtree(root1.right, root2);
        }
        return result;
    }

    public boolean DoesTree1HaveTree2(TreeNode root1, TreeNode root2){
        if(root2 == null)
            return true;
        if(root1 == null)
            return false;

        if(root1.val != root2.val)
            return false;
        return DoesTree1HaveTree2(root1.left, root2.left) && DoesTree1HaveTree2(root1.right, root2.right);
    }

    /**
     *18.二叉树的镜像
     *题目描述
     *操作给定的二叉树，将其变换为源二叉树的镜像。
     *输入描述:
     *二叉树的镜像定义：源二叉树 
     *          8
      *        /  \
     *        6   10
     *       / \  / \
     *      5  7 9 11
     *      镜像二叉树
     *          8
     *         /  \
     *        10   6
     *       / \  / \
     *      11 9 7  5
     */
    public void Mirror(TreeNode root) {
        LRMirror(root);
    }
    public TreeNode LRMirror(TreeNode root){
        if(root == null)
            return root;
        TreeNode temp = root.left;
        root.left = LRMirror(root.right);
        root.right = LRMirror(temp);
        return root;
    }


    /**
     *19.顺时针打印矩阵
     *题目描述
     *输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下4 X 4矩阵： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.
     */
    public ArrayList printMatrix(int[][] array) {
        ArrayList result = new ArrayList();
        if (array.length == 0)
            return result;
        int rows = array.length, columns = array[0].length;
        if (array == null)
            return result;
        int layers = Math.min(rows, columns) / 2 + Math.min(rows, columns) % 2;// 这个是层数(圈数),偶数时正好可以整除，奇数时相当于先加1再除以2
        int i,j,k;
        for (i = 0; i < layers; i++) {
            for(j = i; j <= columns - i - 1; j++)
                result.add(array[i][j]);
            for(k = i + 1; k <= rows - i - 1; k++)
                result.add(array[k][j - 1]);
            for(j = columns - i -2; j >= i && rows - i - 1 > i && columns - i - 1 > i; j--)
                result.add(array[k - 1][j]);
            for(k = rows - i - 2; k > i && columns - i - 1 > i && rows - i - 2 > i;k--)
                result.add(array[k][j + 1]);
        }
        return result;
    }



    /**
     *20.包含min函数的栈
     *定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。
     */
    class SolutionStack {

        private Stack dataStack = new Stack();
        private Stack minStack = new Stack();

        public void push(int node) {
            dataStack.push(node);
            if(minStack.isEmpty() || node <= minStack.peek())
                minStack.push(node);
        }

        public void pop() {
            if(dataStack.peek() == minStack.peek())
                minStack.pop();
            dataStack.pop();

        }

        public int top() {
            return dataStack.peek();
        }

        public int min() {
            return minStack.peek();
        }
    }


    /**
     * 21.栈的压入、弹出序列
     * 题目描述
     * 输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4,5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的）
     */
    public boolean IsPopOrder(int [] pushA,int [] popA) {
        if(pushA.length == 0 || popA.length == 0)
            return false;
        Stack s = new Stack();
        int popIndex = 0;
        for(int i = 0; i < pushA.length; i++){
            s.push(pushA[i]);
            while(!s.empty() && s.peek() == popA[popIndex]){
                s.pop();
                popIndex++;
            }
        }
        return s.empty();
    }


    /**.
     * 22.从上往下打印二叉树
     * 题目描述
     * 从上往下打印出二叉树的每个节点，同层节点从左至右打印。
     */
    public ArrayList PrintFromTopToBottom(TreeNode root) {
        ArrayList result = new ArrayList();
        Queue q = new LinkedList();
        if(root == null)
            return result;

        q.add(root);
        while(!q.isEmpty()){
            TreeNode tn = q.poll();
            result.add(tn.val);
            if(tn.left != null)
                q.add(tn.left);
            if(tn.right != null)
                q.add(tn.right);
        }
        return result;
    }

    /**
     * 23.二叉搜索树的后序遍历序列
     * 题目描述
     * 输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。
     */
    public boolean VerifySquenceOfBST(int [] sequence) {
        if(sequence.length == 0)
            return false;
        if(sequence.length == 1)
            return true;
        return isBTPost(sequence, 0, sequence.length - 1);
    }

    public boolean isBTPost(int[] sequence, int start, int root){
        if(start >= root)
            return true;
        int i = 0;
        while(iint j = i;
        while(j < root){
            if(sequence[j] < sequence[root]){
                return false;
            }
            j++;
        }
        return isBTPost(sequence,start,i - 1) && isBTPost(sequence, i, root - 1);
    }


/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

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

    }

}
*/

    /**
     * 24.二叉树中和为某一值的路径
     * 题目描述
     * 输入一颗二叉树的根节点和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。(注意: 在返回值的list中，数组长度大的数组靠前)
     */
    private ArrayList> listAll = new ArrayList>();
    private ArrayList list = new ArrayList();
    public ArrayList> FindPath(TreeNode root,int target) {

        if(root == null)
            return listAll;
        list.add(root.val);
        target -= root.val;
        if(target == 0 && root.left == null && root.right == null)
            listAll.add(new ArrayList(list));
        FindPath(root.left, target);
        FindPath(root.right, target);
        list.remove(list.size() - 1);
        return listAll;
    }



    class RandomListNode {
        int label;
        RandomListNode next = null;
        RandomListNode random = null;

        RandomListNode(int label) {
            this.label = label;
        }
    }
    /**
    *25.复杂链表的复制
    *题目描述
    *输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的head。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）
    *解题思路：
    *1、遍历链表，复制每个结点，如复制结点A得到A1，将结点A1插到结点A后面；
    *2、重新遍历链表，复制老结点的随机指针给新结点，如A1.random = A.random.next;
    *3、拆分链表，将链表拆分为原链表和复制后的链表
    */
    public RandomListNode Clone(RandomListNode pHead)
    {
        if(pHead == null)
            return pHead;

        //Clone RandomListNode
        RandomListNode pNode = pHead;
        while(pNode != null){
            RandomListNode pCloned = new RandomListNode(pNode.label);
            pCloned.next = pNode.next;
            pCloned.random = null;

            pNode.next = pCloned;
            pNode = pCloned.next;
        }

        //
        pNode = pHead;
        while(pNode != null){
            RandomListNode pCloned = pNode.next;
            if(pNode.random != null)
                pCloned.random = pNode.random.next;
            pNode = pCloned.next;
        }

        //seperate two list
        pNode = pHead;
        RandomListNode pClonedHead = null;
        RandomListNode pCloned = null;
        if(pNode != null){
            pClonedHead = pCloned = pNode.next;
            pNode.next = pCloned.next;
            pNode = pNode.next;
        }
        while(pNode != null){
            pCloned.next = pNode.next;
            pCloned = pCloned.next;
            pNode.next = pCloned.next;
            pNode = pNode.next;
        }
        return pClonedHead;
    }


    /**
    *26.二叉搜索树与双向链表
    *题目描述
    *输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。
    *(也就是说只能创建引用，来调整链表的指向)
    */
    /**
    解题思路：
    1.将左子树构造成双链表，并返回链表头节点。
    2.新增一个全局变量记录左子树的最后一个节点。
    3.如果左子树链表不为空的话，将当前root追加到左子树链表。
    4.将右子树构造成双链表，并返回链表头节点。
    5.如果右子树链表不为空的话，将该链表追加到root节点之后。
    6.根据左子树链表是否为空确定返回的节点。
    */
    /**class TreeNode {
        int val = 0;
        TreeNode left = null;
        TreeNode right = null;

        public TreeNode(int val) {
            this.val = val;
        }
    }
    */
    protected TreeNode lastLeft = null;
    public TreeNode Convert(TreeNode root) {
        if(root == null)
            return null;
        if(root.left == null && root.right == null){
            lastLeft = root;
            return root;
        }


        TreeNode left = Convert(root.left);

        if(lastLeft != null){
            lastLeft.right = root;
            root.left = lastLeft;
        }
        lastLeft = root;

        TreeNode right = Convert(root.right);
        if(right != null){
            root.right = right;
            right.left = root;
        }
        return left != null? left:root;
    }



    /**
    *27.字符串的排序
    *题目描述
    *输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。
    *输入描述:
    *输入一个字符串,长度不超过9(可能有字符重复),字符只包括大小写字母。
    */
    //字典生成算法
    public ArrayList Permutation(String str) {
        ArrayList res = new ArrayList<>();

        if (str != null && str.length() > 0) {
            char[] seq = str.toCharArray();
            Arrays.sort(seq); // 排列
            res.add(String.valueOf(seq)); // 先输出一个解

            int len = seq.length;
            while (true) {
                int p = len - 1, q;
                // 从后向前找一个seq[p - 1] < seq[p]
                while (p >= 1 && seq[p - 1] >= seq[p])
                    --p;
                if (p == 0)
                    break; // 已经是“最小”的排列，退出
                // 从p向后找最后一个比seq[p]大的数
                q = p;
                --p;
                while (q < len && seq[q] > seq[p])
                    q++;
                --q;
                // 交换这两个位置上的值
                swap(seq, q, p);
                // 将p之后的序列倒序排列
                reverse(seq, p + 1);
                res.add(String.valueOf(seq));
            }
        }

        return res;
    }

    public static void reverse(char[] seq, int start) {
        int len;
        if (seq == null || (len = seq.length) <= start)
            return;
        for (int i = 0; i < ((len - start) >> 1); i++) {
            int p = start + i, q = len - 1 - i;
            if (p != q)
                swap(seq, p, q);
        }
    }

    public static void swap(char[] cs, int i, int j) {
        char temp = cs[i];
        cs[i] = cs[j];
        cs[j] = temp;
    }

    //递归实现
    public ArrayList Permutation2(String str) {
        ArrayList res = new ArrayList<>();

        if (str != null && str.length() > 0) {
            PermutationHelper(str.toCharArray(), 0, res);
            Collections.sort(res);
        }

        return res;
    }

    private static void PermutationHelper(char[] cs, int i, ArrayList list) {
        if(i == cs.length - 1) { //解空间的一个叶节点
            list.add(String.valueOf(cs)); //找到一个解
        } else {
            for(int j = i; j < cs.length; ++j) {
                if(j == i || cs[j] != cs[i]) {
                    swap(cs, i, j);
                    PermutationHelper(cs, i + 1, list);
                    swap(cs, i, j); //复位
                }
            }
        }
    }


    /**
    *28.数组中出现次数超过一半的数字
    *题目描述
    *数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。
    */
    public int MoreThanHalfNum_Solution(int [] array) {
        if(array.length <= 0)
            return 0;
        if(array.length == 1)
            return array[0];
        Arrays.sort(array);
        int length = array.length;
        if(length % 2 == 0 && array[length / 2 - 1] == array[length / 2]){
            return array[length / 2];
        }else if(length % 2 == 1 && array[length / 2] == array[length / 2 + 1])
            return array[length / 2];
        else 
            return 0;
    }
    //方法二，基于快速排序算法思想
    public int MoreThanHalfNum_Solution2(int[] array) {
        if (array == null || array.length == 0)
            return 0;
        int middle = array.length >> 1;
        int start = 0;
        int end = array.length - 1;
        int index = Partition(array, start, end);

        while (index != middle) {
            if (index > middle) {
                end = index - 1;
                index = Partition(array, start, end);
            } else {
                start = index + 1;
                index = Partition(array, start, end);
            }
        }
        int result = array[middle];
        if (!CheckMoreThanHalf(array, result))
            result = 0;
        return result;
    }

    public static boolean CheckMoreThanHalf(int array[], int number) {
        int times = 0;
        for (int i = 0; i < array.length; ++i) {
            if (array[i] == number)
                times++;
        }
        boolean isMoreThanHalf = true;
        if (times * 2 <= array.length) {
            isMoreThanHalf = false;
        }
        return isMoreThanHalf;
    }

    public static int Partition(int array[], int start, int end) {
        int pivotkey = (int) start + (int) Math.random() * (end - start);
        while (start < end) {
            while (start < end && array[end] >= array[pivotkey])
                end--;
            int temp = array[start];
            array[start] = array[end];
            array[end] = temp;
            while (start < end && array[start] <= array[pivotkey])
                start++;
            temp = array[start];
            array[start] = array[end];
            array[end] = temp;
        }
        return start;
    }


    /**
    *29.最小的k个数
    *题目描述
    *输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4。
    */
    public ArrayList GetLeastNumbers_Solution(int [] input, int k) {
        ArrayList list = new ArrayList();
        if(input.length <= 0 || k <= 0 || k > input.length)
            return list;
        int start = 0;
        int end = input.length - 1;
        int index = Partition(input,start,end);
        while(index != k - 1){
            if(index > k - 1){
                end = index - 1;
                index = Partition(input,start,end);
            }else{
                start = index + 1;
                index = Partition(input,start,end);
            }
        }

        for(int i = 0; i < k; i++)
            list.add(input[i]);
        return list;
    }

    /**
    *30.连续子数组的最大和
    *题目描述
    *HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。给一个数组，返回它的最大连续子序列的和，你会不会被他忽悠住？(子向量的长度至少是1)
    */
    public int FindGreatestSumOfSubArray(int[] array) {

        int result = array[0];
        int max = result;
        for(int i = 1; i < array.length; ++i){
            if(result <= 0){
                result = 0;
            }
            result += array[i];
            if(max < result)
                max = result;
        }
        return max;
    }


    /**
    *31.整数中1出现的次数（从1到n整数中1出现的次数）
    *题目描述
    *求出1~13的整数中1出现的次数,并算出100~1300的整数中1出现的次数？为此他特别数了一下1~13中包含1的数字有1、10、11、12、13因此共出现6次,但是对于后面问题他就没辙了。ACMer希望你们帮帮他,并把问题更加普遍化,可以很快的求出任意非负整数区间中1出现的次数（从1 到 n 中1出现的次数）。
    */
    public int NumberOf1Between1AndN_Solution(int n) {
        int num = 0;
        for(int i = 1; i <= n; i++)
            num += Ones(i);
        return num;
    }
    public static int Ones(int n){
        int one = 0;
        while(n > 0){
            if(n % 10 == 1)
                one++;
            n = n / 10;
        }
        return one;
    }

    /**
    *32.把数组排成最小的数
    *题目描述
    *输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。
    */
    public String PrintMinNumber(int [] numbers) {
        ArrayList list = new ArrayList();

        for(int i = 0; i < numbers.length; i++)
            list.add(numbers[i]);

        Collections.sort(list, new Comparator(){
            public int compare(Integer str1, Integer str2){
                String s1 = str1 + "" + str2;
                String s2 = str2 + "" + str1;
                return s1.compareTo(s2);
            }
        });
        String str = "";
        for(int i : list)
            str += i;
        return str;
    }

    /**
    *33.丑数
    *题目描述
    *把只包含质因子2、3和5的数称作丑数（Ugly Number）。例如6、8都是丑数，但14不是，因为它包含质因子7。 习惯上我们把1当做是第一个丑数。求按从小到大的顺序的第N个丑数。
    *思路：我们只用比较3个数：用于乘2的最小的数、用于乘3的最小的数，用于乘5的最小的
    */
    public int GetUglyNumber_Solution(int n){
        if(n<=0)return 0;
        ArrayList list=new ArrayList();
        list.add(1);
        int i2=0,i3=0,i5=0;
        while(list.size()//循环的条件
        {
            int m2=list.get(i2)*2;
            int m3=list.get(i3)*3;
            int m5=list.get(i5)*5;
            int min=Math.min(m2,Math.min(m3,m5));
            list.add(min);
            if(min==m2)i2++;
            if(min==m3)i3++;
            if(min==m5)i5++;
        }
        return list.get(list.size()-1);
    }

    /**
    *34.第一个只出现一次的字符
    *题目描述
    *在一个字符串(0<=字符串长度<=10000，全部由字母组成)中找到第一个只出现一次的字符,并返回它的位置, 如果没有则返回 -1（需要区分大小写）.
    */
    public int FirstNotRepeatingChar(String str) {

        char[] a = str.toCharArray();
        for (int i=0;iif (!str.substring(0,i).contains(a[i]+"")&&!str.substring(i+1).contains(a[i]+""))
                return i;
        }
        return -1;
    }


    /**
    *35.数组中的逆序对
    *题目描述
    在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。 即输出P%1000000007
    输入描述:
    题目保证输入的数组中没有相同的数字
    数据范围：
        对于%50的数据,size<=10^4
        对于%75的数据,size<=10^5
        对于%100的数据,size<=2*10^5
    示例1:
    输入
    1,2,3,4,5,6,7,0
    输出
    7
    */
    public int InversePairs(int [] array) {
        if(array == null || array.length == 0)
            return 0;
        int [] copy = new int[array.length];
        for(int i = 0; i < array.length; i++)
            copy[i] = array[i];
        int count = InversePairsCore(array, copy, 0, array.length - 1);
        return count;
    }

    public static int InversePairsCore(int[] array, int[] copy, int low, int high){
        if(low == high)
            return 0;
        int mid = (low + high) >> 1;
        int leftCount = InversePairsCore(array, copy, low, mid) % 1000000007;
        int rightCount = InversePairsCore(array, copy, mid + 1, high) % 1000000007;

        int count = 0;
        int i = mid;
        int j = high;
        int locCopy = high;
        while(i >= low && j > mid ){
            if(array[i] > array[j]){
                count += j - mid;
                copy[locCopy--] = array[i--];
                if(count >= 1000000007)
                    count %= 1000000007;
            }else
                copy[locCopy--] = array[j--];
        }
        for( ;i >= low; i--)
            copy[locCopy--] = array[i];
        for( ;j > mid; j--)
            copy[locCopy--] = array[j];
        for(int s = low; s <= high; s++)
            array[s] =  copy[s];
        return (leftCount + rightCount + count) % 1000000007;
    }


    /**
    *36.两个链表的第一个公共结点
    *题目描述
    *输入两个链表，找出它们的第一个公共结点。
    */
    public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
        int len1 = 0, len2 = 0;
        ListNode lp1 = pHead1;
        ListNode lp2 = pHead2;
        ListNode pHeadLong = pHead1;
        ListNode pHeadShort = pHead2;
        int nLengthDif = 0;
        while(lp1 != null){
            len1++;
            lp1 = lp1.next;
        }
        while(lp2 != null){
            len2++;
            lp2 = lp2.next;
        }
        if(len2 > len1){
            pHeadLong = pHead2;
            pHeadShort = pHead1;
            nLengthDif = len2 - len1;
        }else{
            nLengthDif = len1 - len2;
        }

        for(int i = 0; i < nLengthDif; ++i)
            pHeadLong = pHeadLong.next;

        while(pHeadLong != null && pHeadShort != null && pHeadLong != pHeadShort){
            pHeadLong = pHeadLong.next;
            pHeadShort = pHeadShort.next;
        }
        ListNode res = pHeadLong;
        return res;
    }

    /**
    *37.数字在排序数组中出现的次数
    *题目描述
    *统计一个数字在排序数组中出现的次数。
    */
    //暴力解决
    public int GetNumberOfK1(int [] array , int k) {
        int count = 0;
         for(int i = 0; i < array.length; i++){
             if(array[i] == k)
                 count++;
         }
         return count;
     }
    //二分查找思想，时间复杂度(log n)
     public int GetNumberOfK(int [] array , int k) {
        int count = 0;
         int index = biSearch(array, k, 0, array.length - 1);
         if(index == -1)
             return 0;
         for(int i = index; i < array.length; i++){
             if(array[i] == k)
                 count++;
         }
         return count;
     }

     public static int biSearch(int[] array, int k, int low, int high){
         if(low > high)
             return -1;
         int mid = (low + high) / 2;
         int midData = array[mid];
         if(midData == k){
             if(mid > 0 && array[mid - 1] != k || mid == 0)
                 return mid;
             else{
                 while(mid > 0 && array[mid - 1] == k)
                     mid--;
                 return mid;
             }
         }else if(midData > k)
             high = mid - 1;
         else
             low = mid + 1;
         return biSearch(array, k, low, high);
     }

     /**
     38.二叉树的深度
     题目描述
     输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。
     */
     public int TreeDepth(TreeNode root) {
         if(root == null)
             return 0;
         if(root != null && root.left == null && root.right == null)
             return 1;
         int leftLen = TreeDepth(root.left);
         int rightLen = TreeDepth(root.right);
         return leftLen > rightLen? leftLen + 1: rightLen + 1;
     }

     /**
     *39.平衡二叉树
     *题目描述
     *输入一棵二叉树，判断该二叉树是否是平衡二叉树。
     */
     public boolean IsBalanced_Solution(TreeNode root) {
         if(root == null)
             return true;
         int left = TreeDepth(root.left);
         int right = TreeDepth(root.right);
         int diff = left - right;
         if( diff > 1 || diff < -1)
             return false;
         return IsBalanced_Solution(root.left) && IsBalanced_Solution(root.right);
     }

     /**
     *40.数组中只出现一次的数字
     *题目描述
     *一个整型数组里除了两个数字之外，其他的数字都出现了偶数次。请写程序找出这两个只出现一次的数字。
     */

     //num1,num2分别为长度为1的数组。传出参数
     //将num1[0],num2[0]设置为返回结果
     public void FindNumsAppearOnce1(int [] array,int num1[] , int num2[]) {
         int result = 0;
         boolean num1Value = false;
         for(int i = 0; i < array.length ; i++){
             boolean isUnique = true;
             for(int j = 0; j < array.length; j++){
                 if(array[i] == array[j] && i != j)
                     isUnique = false;
             }
             if(isUnique && num1Value == false){
                 num1[0] = array[i];
                 num1Value = true;
             }

             if(isUnique && num1Value)
                 num2[0] = array[i];
         }
     }

     public void FindNumsAppearOnce(int [] array,int num1[] , int num2[]) {
         List list = new ArrayList<>();
         for(int i=0;iif(!list.contains(String.valueOf(array[i]))){
                 list.add(String.valueOf(array[i]));
             }else{
                 list.remove(String.valueOf(array[i]));
             }
         }
         if(list.size()!=0){
             num1[0] = Integer.valueOf(list.get(0));
             num2[0] = Integer.valueOf(list.get(1));
         }
     }

     /**
     *41.和为S的连续正数序列
     *题目描述
     *小明很喜欢数学,有一天他在做数学作业时,要求计算出9~16的和,他马上就写出了正确答案是100。但是他并不满足于此,他在想究竟有多少种连续的正数序列的和为100(至少包括两个数)。没多久,他就得到另一组连续正数和为100的序列:18,19,20,21,22。现在把问题交给你,你能不能也很快的找出所有和为S的连续正数序列? Good Luck!
     *输出描述:
     *输出所有和为S的连续正数序列。序列内按照从小至大的顺序，序列间按照开始数字从小到大的顺序
     */
     public ArrayList > FindContinuousSequence1(int sum) {
         ArrayList> alllist = new ArrayList>();
        if(sum < 3)
            return alllist;
         int small = 1;
         int big = 2;
         int middle = (1 + sum) / 2;
         int curSum = small + big;
         while(small < middle){
             if(curSum == sum){
                 ArrayList list = new ArrayList();
                 for(int i = small; i <= big; i++)
                     list.add(i);
                 alllist.add(list);
             }
             while(curSum > sum && small < middle){
                 curSum -= small;
                 small++;
                 if(curSum == sum){
                     ArrayList list = new ArrayList();
                     for(int i = small; i <= big; i++)
                         list.add(i);
                     alllist.add(list);
                 }
             }
             big++;
             curSum += big;
         }
         return alllist;
     }

     public ArrayList > FindContinuousSequence(int sum) {
         ArrayList> ans = new ArrayList<>();
         for (int n = (int) Math.sqrt(2 * sum); n >= 2; n--) {
             if ((n & 1) == 1 && sum % n == 0 || (sum % n) * 2 == n) {
                 ArrayList list = new ArrayList<>();
                 for (int j = 0, k = (sum / n) - (n - 1) / 2; j < n; j++, k++) {
                     list.add(k);
                 }
                 ans.add(list);
             }
         }
         return ans;
     }

     /**
     *42.和为S的两个数字
     *题目描述
     *输入一个递增排序的数组和一个数字S，在数组中查找两个数，使得他们的和正好是S，如果有多对数字的和等于S，输出两个数的乘积最小的。
     *输出描述:
     *对应每个测试案例，输出两个数，小的先输出。
     */
     public ArrayList FindNumbersWithSum(int [] array,int sum) {
         ArrayList list = new ArrayList();

         if(array.length < 1)
             return list;
         int ahead = array.length - 1;
         int behind = 0;

         while(ahead > behind){
             long curSum = array[ahead] + array[behind];
             if(curSum == sum){
                 list.add(array[ahead]);
                 list.add(array[behind]);
                 break;
             }else if(curSum > sum)
                 ahead--;
             else behind++;
         }
         Collections.sort(list);
         return list;
     }

     /**
     *43.左旋转字符串
     *题目描述
     *汇编语言中有一种移位指令叫做循环左移（ROL），现在有个简单的任务，就是用字符串模拟这个指令的运算结果。对于一个给定的字符序列S，请你把其循环左移K位后的序列输出。例如，字符序列S=”abcXYZdef”,要求输出循环左移3位后的结果，即“XYZdefabc”。是不是很简单？OK，搞定它！
     */
     public String LeftRotateString(String str,int n) {
         if(n > str.toCharArray().length)
             return "";
         return str.substring(n) + str.substring(0,n);
     }

     /**
     *44.翻转单词顺序列
     *题目描述
     *牛客最近来了一个新员工Fish，每天早晨总是会拿着一本英文杂志，写些句子在本子上。同事Cat对Fish写的内容颇感兴趣，有一天他向Fish借来翻看，但却读不懂它的意思。例如，“student. a am I”。后来才意识到，这家伙原来把句子单词的顺序翻转了，正确的句子应该是“I am a student.”。Cat对一一的翻转这些单词顺序可不在行，你能帮助他么？
     */
   //利用java中String函数，简单明了
     public String ReverseSentence1(String str) {
         if(str.trim().isEmpty())
             return str;
         String[] temp = str.split(" ");
         String res = "";
         int i = temp.length - 1;
         for(; i > 0; i--){
             res = res + temp[i] + " ";
         }
         return res + temp[0];
     }
     //利用剑指offer上思想，两次反转字符串
     public String ReverseSentence(String str) {
         if(str.trim().isEmpty())
             return str;
         char[] c = str.toCharArray();
         Reverse(c, 0, c.length - 1);
         int pBegin = 0, pEnd = 0;
         while(pBegin < c.length){
             if(c[pBegin] == ' '){
                 pBegin++;
                 pEnd++;
             }else if(c[pEnd] == ' '){
                 Reverse(c, pBegin, pEnd - 1);
                 pBegin = ++pEnd;
             }else if(pEnd == c.length - 1){
                 Reverse(c, pBegin, pEnd);
                 pBegin = ++pEnd;
             }else
                 pEnd++;
         }
         return String.valueOf(c);
     }
     public static void Reverse(char[] c, int begin, int end){
         if(begin >= end)
             return;
         while(begin < end){
             char temp = c[begin];
             c[begin] = c[end];
             c[end] = temp;
             begin++;
             end--;
         }
     }

     /**
     *45.扑克牌顺子
     *题目描述
     *LL今天心情特别好,因为他去买了一副扑克牌,发现里面居然有2个大王,2个小王(一副牌原本是54张^_^)...他随机从中抽出了5张牌,想测测自己的手气,看看能不能抽到顺子,如果抽到的话,他决定去买体育彩票,嘿嘿！！“红心A,黑桃3,小王,大王,方片5”,“Oh My God!”不是顺子.....LL不高兴了,他想了想,决定大\小 王可以看成任何数字,并且A看作1,J为11,Q为12,K为13。上面的5张牌就可以变成“1,2,3,4,5”(大小王分别看作2和4),“So Lucky!”。LL决定去买体育彩票啦。 现在,要求你使用这幅牌模拟上面的过程,然后告诉我们LL的运气如何， 如果牌能组成顺子就输出true，否则就输出false。为了方便起见,你可以认为大小王是0。
     */
   //solution one
     public boolean isContinuous1(int [] numbers) {
         if(numbers.length <= 0)
             return false;

         Arrays.sort(numbers);

         int numberOfZero = 0;
         int numberOfGap = 0;
         for(int i = 0; i < numbers.length && numbers[i] == 0; i++){
             ++numberOfZero;
         }

         int small = numberOfZero, big = small + 1;
         while(big < numbers.length){
             if(numbers[small] == numbers[big])
                 return false;
             numberOfGap += numbers[big] - numbers[small] - 1;
             small = big;
             ++big;
         }
         return (numberOfGap > numberOfZero)? false : true;
     }
     //solution two
     /**
         max 记录 最大值
         min 记录  最小值
         min ,max 都不记0
         满足条件  1 max - min <5
                 2 除0外没有重复的数字(牌)
                 3 数组长度 为5
     */
     public boolean isContinuous(int [] numbers) {
         if(numbers.length <= 0)
             return false;
         int[]d = new int[14]; 
         d[0] = -5; 
         int len = numbers.length; 
         int max = -1; 
         int min = 14; 
         for(int i = 0; i < len; i++){
             d[numbers[i]]++; 
             if(numbers[i] == 0){
                 continue; 
             }
             if(d[numbers[i]] > 1){
                 return false; 
             }
             if(numbers[i] > max){
                 max = numbers[i]; 
             } if(numbers[i] < min){
                 min = numbers[i]; 
             }

         }
         if(max - min < 5){
             return true; 
         }
             return false;
     }

     /**
     *46.孩子们的游戏(圆圈中最后剩下的数)
     *题目描述
     *每年六一儿童节,牛客都会准备一些小礼物去看望孤儿院的小朋友,今年亦是如此。HF作为牛客的资深元老,自然也准备了一些小游戏。其中,有个游戏是这样的:首先,让小朋友们围成一个大圈。然后,他随机指定一个数m,让编号为0的小朋友开始报数。每次喊到m-1的那个小朋友要出列唱首歌,然后可以在礼品箱中任意的挑选礼物,并且不再回到圈中,从他的下一个小朋友开始,继续0...m-1报数....这样下去....直到剩下最后一个小朋友,可以不用表演,并且拿到牛客名贵的“名侦探柯南”典藏版(名额有限哦!!^_^)。请你试着想下,哪个小朋友会得到这份礼品呢？(注：小朋友的编号是从0到n-1)
     */
     public int LastRemaining_Solution(int n, int m) {
         if(n < 1 || m < 1)
             return -1;
         int last = 0;
         for(int i = 2; i <= n; i++){
             last = (last + m) % i;
         }
         return last;
     }


     /**
     *47.求1+2+3+...+n
     *题目描述
     *求1+2+3+...+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。
     */
   //solution one
     public int Sum_Solution1(int n) {
         try{
             int i = 2 % n;
         }catch(Exception e){
             return n;
         }
         return n + Sum_Solution(--n);
     }
     //solution two
     public int Sum_Solution(int n){
         return ((int)Math.pow(n,2)+n)>>1;
     }

     /**
     *48.不用加减乘除做加法
     *题目描述
     *写一个函数，求两个整数之和，要求在函数体内不得使用+、-、*、/四则运算符号。
     */
     public int Add(int num1,int num2) {
         int sum, carry;
         do{
             sum = num1 ^ num2;
             carry = (num1 & num2) << 1;
             num1 = sum;
             num2 = carry;
         }while(num2 != 0);
         return num1;
     }

     /**
     *49.把字符串转换成整数
     *题目描述
     将一个字符串转换成一个整数(实现Integer.valueOf(string)的功能，但是string不符合数字要求时返回0)，要求不能使用字符串转换整数的库函数。 数值为0或者字符串不是一个合法的数值则返回0。
     输入描述:
     输入一个字符串,包括数字字母符号,可以为空
     输出描述:
     如果是合法的数值表达则返回该数字，否则返回0
     输入:
     +2147483647
         1a33
     输出:
     2147483647
         0
     */
     public int StrToInt(String str) {
         char[] c = str.toCharArray();
         int sum = 0;
         boolean negative = false;
         for(int i = 0; i < c.length; i++){
             if(i == 0 && c[i] == '-'){
                 negative = true;
                 continue;
             }
             if(i == 0 && c[i] == '+')
                 continue;
             if(c[i] >= '0' && c[i] <= '9'){
                 sum = sum * 10 + (c[i] - '0');
             }else{
                 return 0;
             }
         }
         if(negative)
             sum = 0 - sum;
         return sum;
     }

     /**
     *50.数组中重复的数字
     *题目描述
     *在一个长度为n的数组里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。 例如，如果输入长度为7的数组{2,3,1,0,2,5,3}，那么对应的输出是第一个重复的数字2。
     */
  // Parameters:
     //    numbers:     an array of integers
     //    length:      the length of array numbers
     //    duplication: (Output) the duplicated number in the array number,length of duplication array is 1,so using duplication[0] = ? in implementation;
     //                  Here duplication like pointor in C/C++, duplication[0] equal *duplication in C/C++
     //    这里要特别注意~返回任意重复的一个，赋值duplication[0]
     // Return value:       true if the input is valid, and there are some duplications in the array number
     //                     otherwise false
     public boolean duplicate(int numbers[],int length,int [] duplication) {
         int[] isDup = new int[length];
         //辅助数组初始化为-1.
         for(int i = 0; i < length; i++){
             isDup[i] = -1;
         }
         for(int i = 0; i < length; i++){
             if(isDup[numbers[i]] == numbers[i]){
                 duplication[0] = numbers[i];
                 return true;
             }else{
                 isDup[numbers[i]] = numbers[i];
             }
         }
         return false;
     }

     /**
     *51.构建乘积数组
     *题目描述
     *给定一个数组A[0,1,...,n-1],请构建一个数组B[0,1,...,n-1],其中B中的元素B[i]=A[0]*A[1]*...*A[i-1]*A[i+1]*...*A[n-1]。不能使用除法。
     */
     //暴力解决
     public int[] multiply1(int[] A) {
         int[] B = new int[A.length];
         for(int i = 0; i < A.length; i++){
             int temp = 1;
             for(int j = 0; j < B.length; j++){
                 if(i != j){
                     temp *= A[j];
                 }
             }
             B[i] = temp;
         }
         return B;
     }
     //剑指offer上算法思想，时间复杂度O(n)
     public int[] multiply(int[] A){
         int length = A.length;
         int[] B = new int[length];
         if(length != 0 ){
             B[0] = 1;
             //计算下三角连乘
             for(int i = 1; i < length; i++){
                 B[i] = B[i-1] * A[i-1];
             }
             int temp = 1;
             //计算上三角
             for(int j = length-2; j >= 0; j--){
                 temp *= A[j+1];
                 B[j] *= temp;
             }
         }
         return B;
     }

     /**
     *52.正则表达式匹配
     *题目描述
     *请实现一个函数用来匹配包括'.'和'*'的正则表达式。模式中的字符'.'表示任意一个字符，而'*'表示它前面的字符可以出现任意次（包含0次）。 在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串"aaa"与模式"a.a"和"ab*ac*a"匹配，但是与"aa.a"和"ab*a"均不匹配
     */
   //剑指offer书上算法思想
     public boolean match(char[] str, char[] pattern)
     {
         if(str.length <= 0 && pattern.length <= 0)
             return true;

         return matchCore(str,pattern,0, 0);
     }

     public static boolean matchCore(char[] str, char[] pattern, int s, int p){
         if(s == str.length && p == pattern.length)
             return true;
         if(s != str.length && p == pattern.length)
             return false;
         //处理遇到*的情况
         if(p + 1 < pattern.length && pattern[p + 1] == '*'){
             if((s != str.length && pattern[p] == str[s]) || (pattern[p] == '.' && s != str.length)){
                 return matchCore(str, pattern, s, p + 2)//相当于*匹配零个，模式串上移动两个
                     || matchCore(str, pattern, s + 1, p);//字符串上移动一个，模式上保持不变
             }else{
                 return matchCore(str, pattern, s, p + 2);
             }
         }
         //两个字符相等，或者匹配.
         if((s != str.length && pattern[p] == str[s]) || (pattern[p] == '.' && s != str.length))
             return matchCore(str, pattern, s + 1, p + 1);
         return false;
     }

     //投机取巧法
     public boolean match2(char[] str, char[] pattern){
         String regex = String.valueOf(pattern);
         String s = String.valueOf(str);
         return s.matches(regex);
     }

     /**
     *53.表示数值的字符串
     *题目描述
     *请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。例如，字符串"+100","5e2","-123","3.1416"和"-1E-16"都表示数值。 但是"12e","1a3.14","1.2.3","+-5"和"12e+4.3"都不是。
     */
     public boolean isNumeric1(char[] str) {
         String string = String.valueOf(str);
         return string.matches("[\\+-]?[0-9]*(\\.[0-9]*)?([eE][\\+-]?[0-9]+)?");
     }
     public boolean isNumeric(char[] str) {
         try {
             double re = Double.parseDouble(new String(str));
         } catch (NumberFormatException e) {
             return false;
         }
         return true;
     }
     public boolean isNumeric2(char[] str) {
          String s = String.valueOf(str);
          if(s.contains("e") || s.contains("E")){
              String[] split = s.split("e|E");
              if(split.length != 2)
                 return false;
              return isNum(split[0]) && isNum2(split[1]);
          }else{
              return isNum(s);
          }
      }
      public static boolean isNum(String s){
         String regex = "[0-9]*\\.*[0-9]*";
         if((s.substring(0,1).equals("-")) || (s.substring(0,1).equals("+"))) {
             return s.substring(1).matches(regex);
         }
          return s.matches(regex);
      }
     public static boolean isNum2(String s){
         String regex = "[0-9]*";
         if((s.substring(0,1).equals("-")) || (s.substring(0,1).equals("+"))) {
             return s.substring(1).matches(regex);
         }
          return s.matches(regex);
      }

     /**
     *54.字符流中第一个不重复的字符
     *题目描述
     *请实现一个函数用来找出字符流中第一个只出现一次的字符。例如，当从字符流中只读出前两个字符"go"时，第一个只出现一次的字符是"g"。当从该字符流中读出前六个字符“google"时，第一个只出现一次的字符是"l"。
     *输出描述:
     *如果当前字符流没有存在出现一次的字符，返回#字符。
     */
     int[] hashtable = new int[256];
     StringBuffer s = new StringBuffer();
     //Insert one char from stringstream
     public void Insert(char ch)
     {
         s.append(ch);
         if(hashtable[ch] == 0)
             hashtable[ch] = 1;
         else hashtable[ch] += 1;
     }
   //return the first appearence once char in current stringstream
     public char FirstAppearingOnce()
     {
       char[] str=s.toString().toCharArray();
       for(char c:str)
       {
           if(hashtable[c] == 1)
               return c;
       }
       return '#';
     }


     /**
     55.链表中环的入口结点
     题目描述
     给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。
     */
   //solution one
     /**
     假设fast每次走两步，slow每次走一步，当二者相遇时，假设slow走了s步，fast走了2s步。二者相遇时，slow指针肯定没有遍历完链表，而fast指针也在环内循环了n圈(n >= 1)，则2s= s + nr.从而s=nr.
     设整个链表长L，入口环与相遇点设x，起始点到环入口距离为a，则a+x = nr,故a+x = (n-1)r + L-a,从而 a=(n-1)r+)(L-a-x).
     (L-a-x)为相遇点到环入口点的距离，从链表头到环入口点等于(n-1)环内循环+相遇点到环入口点，于是在链表头与相遇点分别设一个指针，每次各走一步，两者必定相遇，且相遇第一点为环入口点。
     */
     public ListNode EntryNodeOfLoop1(ListNode pHead)
     {
         ListNode slow = pHead, fast = pHead;

         while(fast != null && fast.next != null){
             slow = slow.next;
             fast = fast.next.next;
             if(slow == fast)
                 break;
         }

         if(fast == null || fast.next == null)
             return null;
         slow = pHead;
         while(slow != fast){
             slow = slow.next;
             fast = fast.next;
         }
         return slow;
     }

     //solution two
     //找到一快一满指针相遇处的节点，相遇的节点一定是在环中
     public static ListNode meetingNode(ListNode head) {
         if(head==null)
             return null;

         ListNode slow = head.next;
         if(slow==null)
             return null;

         ListNode fast = slow.next;
         while (slow != null && fast != null) {
             if(slow==fast){
                 return fast;
             }
             slow=slow.next;
             fast=fast.next;

             if(fast!=slow){
                 fast=fast.next;
             }
         }
         return null;
     }
     /**
         如果链表中环 有n个结点，指针P1在链表上向前移动n步，然后两个指针以相同的速度向前移动。当第二个指针指向环的入口结点时，第一个指针已经围绕着环走了一圈又回到了入口结点。所以首先要得到环中结点的数目。
     */
     public ListNode EntryNodeOfLoop(ListNode pHead) {
         ListNode meetingNode=meetingNode(pHead);
         if(meetingNode==null)
             return null;
         //得到环中的节点个数
         int nodesInLoop=1;
         ListNode p1=meetingNode;
         while(p1.next!=meetingNode){
             p1=p1.next;
             ++nodesInLoop;
         }
         //移动p1
         p1=pHead;
         for(int i=0;i//移动p1，p2
         ListNode p2=pHead;
         while(p1!=p2){
             p1=p1.next;
             p2=p2.next;
         }
         return p1;
     }

     /**
     56.删除链表中重复的结点
     题目描述
     在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 例如，链表1->2->3->3->4->4->5 处理后为 1->2->5
     */
     public ListNode deleteDuplication(ListNode pHead)
     {
         if(pHead == null)
             return null;
         if(pHead != null && pHead.next == null)
             return pHead;
         ListNode current;
         if(pHead.next.val == pHead.val){
             current = pHead.next.next;
             while(current != null && current.val == pHead.val)
                 current = current.next;
             return deleteDuplication(current);
         }else{
             current = pHead.next;
             pHead.next = deleteDuplication(current);
             return pHead;
         }

     }

     /**
     *57.二叉树的下一个结点
     *题目描述
     *给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。
     */
     class TreeLinkNode {
            int val;
            TreeLinkNode left = null;
            TreeLinkNode right = null;
            TreeLinkNode next = null;

            TreeLinkNode(int val) {
                this.val = val;
            }
     }
     public TreeLinkNode GetNext(TreeLinkNode pNode)
     {
         if(pNode == null)
             return null;
         TreeLinkNode pNext = null;
         if(pNode.right != null){
             TreeLinkNode pRight = pNode.right;
             while(pRight.left != null)
                 pRight = pRight.left;
             pNext = pRight;
         }else if(pNode.next != null){
             TreeLinkNode pCurrent = pNode;
             TreeLinkNode pParent = pNode.next;
             while(pParent != null && pCurrent == pParent.right){
                 pCurrent = pParent;
                 pParent = pParent.next;
             }
             pNext = pParent;
         }
         return pNext;
     }

     /**
     *58.对称的二叉树
     *题目描述
     *请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。
     */
     public boolean isSymmetrical(TreeNode pRoot)
     {
         if(pRoot == null)
             return true;
         return isSymmetrical(pRoot.left, pRoot.right);
     }
     public static boolean isSymmetrical(TreeNode p1, TreeNode p2){
         if(p1 == null && p2 == null)
             return true;
         if(p1 == null || p2 == null)
             return false;
         if(p1.val != p2.val)
             return false;
         return isSymmetrical(p1.left, p2.right) && isSymmetrical(p1.right, p2.left);
     }

     /**
     *59.按之字形顺序打印二叉树
     *题目描述
     *请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。
     */
     public static ArrayList> Print(TreeNode pRoot) {
         int layer = 1;
         //s1存奇数层节点
         Stack s1 = new Stack();
         s1.push(pRoot);
         //s2存偶数层节点
         Stack s2 = new Stack();

         ArrayList> list = new ArrayList>();

         while (!s1.empty() || !s2.empty()) {
             if (layer%2 != 0) {
                 ArrayList temp = new ArrayList();
                 while (!s1.empty()) {
                     TreeNode node = s1.pop();
                     if(node != null) {
                         temp.add(node.val);
                         System.out.print(node.val + " ");
                         s2.push(node.left);
                         s2.push(node.right);
                     }
                 }
                 if (!temp.isEmpty()) {
                     list.add(temp);
                     layer++;
                     System.out.println();
                 }
             } else {
                 ArrayList temp = new ArrayList();
                 while (!s2.empty()) {
                     TreeNode node = s2.pop();
                     if(node != null) {
                         temp.add(node.val);
                         System.out.print(node.val + " ");
                         s1.push(node.right);
                         s1.push(node.left);
                     }
                 }
                 if (!temp.isEmpty()) {
                     list.add(temp);
                     layer++;
                     System.out.println();
                 }
             }
         }
         return list;
     }

     /**
     *60.把二叉树打印成多行
     *题目描述
     *从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行。
     */
     public ArrayList > Print1(TreeNode pRoot) {
         ArrayList> list = new ArrayList>();
         if(pRoot == null)
             return list;
         Queue q = new LinkedList();
         q.add(pRoot);
         while(!q.isEmpty()) {
             int l = 0, h = q.size();
             ArrayList temp = new ArrayList<>();
             while(l++ < h) {
                 TreeNode tn = q.poll();
                 temp.add(tn.val);
                 if(tn.left != null)
                     q.add(tn.left);
                 if(tn.right != null)
                     q.add(tn.right);
             }
             list.add(temp);
         }
         return list;
     }

     /**
     *61.序列化二叉树
     *题目描述
     *请实现两个函数，分别用来序列化和反序列化二叉树
     */
     public int index = -1;
     public 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();

    }
     public 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;
    }

     /**
     *62.二叉搜索树的第k个结点
     *题目描述
     *给定一棵二叉搜索树，请找出其中的第k小的结点。例如， （5，3，7，2，4，6，8）    中，按结点数值大小顺序第三小结点的值为4。
     */
     private int index1 = 0;
     public TreeNode KthNode(TreeNode pRoot, int k)
     {
         if(pRoot != null){
             TreeNode node = KthNode(pRoot.left, k);
             if(node != null)
                 return node;
             index1++;
             if(index1 == k)
                 return pRoot;
             node = KthNode(pRoot.right, k);
             if(node != null)
                 return node;
         }
         return null;
     }

     /**
     *63.数据流中的中位数
     *题目描述
     *如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。我们使用Insert()方法读取数据流，使用GetMedian()方法获取当前读取数据的中位数。
     */
     private int count = 0;
     private PriorityQueue minHeap = new PriorityQueue<>();
     private PriorityQueue maxHeap = new PriorityQueue(15, new Comparator() {
         @Override
         public int compare(Integer o1, Integer o2) {
             return o2 - o1;
         }
     });

     public void Insert(Integer num) {
         if (count %2 == 0) {//当数据总数为偶数时，新加入的元素，应当进入小根堆
             //（注意不是直接进入小根堆，而是经大根堆筛选后取大根堆中最大元素进入小根堆）
             //1.新加入的元素先入到大根堆，由大根堆筛选出堆中最大的元素
             maxHeap.offer(num);
             int filteredMaxNum = maxHeap.poll();
             //2.筛选后的【大根堆中的最大元素】进入小根堆
             minHeap.offer(filteredMaxNum);
         } else {//当数据总数为奇数时，新加入的元素，应当进入大根堆
             //（注意不是直接进入大根堆，而是经小根堆筛选后取小根堆中最大元素进入大根堆）
             //1.新加入的元素先入到小根堆，由小根堆筛选出堆中最小的元素
             minHeap.offer(num);
             int filteredMinNum = minHeap.poll();
             //2.筛选后的【小根堆中的最小元素】进入大根堆
             maxHeap.offer(filteredMinNum);
         }
         count++;
     }

     public Double GetMedian() {
         if (count %2 == 0) {
             return new Double((minHeap.peek() + maxHeap.peek())) / 2;
         } else {
             return new Double(minHeap.peek());
         }
     }

     /**
     *64.滑动窗口的最大值
     *题目描述
     *给定一个数组和滑动窗口的大小，找出所有滑动窗口里数值的最大值。例如，如果输入数组{2,3,4,2,6,2,5,1}及滑动窗口的大小3，那么一共存在6个滑动窗口，他们的最大值分别为{4,4,6,6,6,5}； 针对数组{2,3,4,2,6,2,5,1}的滑动窗口有以下6个： {[2,3,4],2,6,2,5,1}， {2,[3,4,2],6,2,5,1}， {2,3,[4,2,6],2,5,1}， {2,3,4,[2,6,2],5,1}， {2,3,4,2,[6,2,5],1}， {2,3,4,2,6,[2,5,1]}。
     */
     /**
     用一个双端队列，队列第一个位置保存当前窗口的最大值，当窗口滑动一次
     1.判断当前最大值是否过期
     2.新增加的值从队尾开始比较，把所有比他小的值丢掉
     */
     public ArrayList maxInWindows(int [] num, int size)
     {
         ArrayList res = new ArrayList<>();
         if(size == 0) return res;
         int begin; 
         ArrayDeque q = new ArrayDeque<>();
         for(int i = 0; i < num.length; i++){
             begin = i - size + 1;
             if(q.isEmpty())
                 q.add(i);
             else if(begin > q.peekFirst())
                 q.pollFirst();

             while((!q.isEmpty()) && num[q.peekLast()] <= num[i])
                 q.pollLast();
             q.add(i);  
             if(begin >= 0)
                 res.add(num[q.peekFirst()]);
         }
         return res;
     }


     /**
     *65.矩阵中的路径
     *题目描述
     *请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一个格子开始，每一步可以在矩阵中向左，向右，向上，向下移动一个格子。如果一条路径经过了矩阵中的某一个格子，则之后不能再次进入这个格子。 例如 a b c e s f c s a d e e 这样的3 X 4 矩阵中包含一条字符串"bcced"的路径，但是矩阵中不包含"abcb"路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入该格子。
     */
     public boolean hasPath(char[] matrix, int rows, int cols, char[] str) {
         int flag[] = new int[matrix.length];
         for (int i = 0; i < rows; i++) {
             for (int j = 0; j < cols; j++) {
                 if (helper(matrix, rows, cols, i, j, str, 0, flag))
                     return true;
             }
         }
         return false;
     }

     private boolean helper(char[] matrix, int rows, int cols, int i, int j, char[] str, int k, int[] flag) {
         int index = i * cols + j;
         if (i < 0 || i >= rows || j < 0 || j >= cols || matrix[index] != str[k] || flag[index] == 1)
             return false;
         if(k == str.length - 1) return true;
         flag[index] = 1;
         if (helper(matrix, rows, cols, i - 1, j, str, k + 1, flag)
                 || helper(matrix, rows, cols, i + 1, j, str, k + 1, flag)
                 || helper(matrix, rows, cols, i, j - 1, str, k + 1, flag)
                 || helper(matrix, rows, cols, i, j + 1, str, k + 1, flag)) {
             return true;
         }
         flag[index] = 0;
         return false;
     }

     /**
     *66.机器人的运动范围
     *题目描述
     *地上有一个m行和n列的方格。一个机器人从坐标0,0的格子开始移动，每一次只能向左，右，上，下四个方向移动一格，但是不能进入行坐标和列坐标的数位之和大于k的格子。 例如，当k为18时，机器人能够进入方格（35,37），因为3+5+3+7 = 18。但是，它不能进入方格（35,38），因为3+5+3+8 = 19。请问该机器人能够达到多少个格子？
     */
     public int movingCount(int threshold, int rows, int cols) {
         int flag[][] = new int[rows][cols]; //记录是否已经走过
         return helper(0, 0, rows, cols, flag, threshold);
     }

     private int helper(int i, int j, int rows, int cols, int[][] flag, int threshold) {
         if (i < 0 || i >= rows || j < 0 || j >= cols || numSum(i) + numSum(j)  > threshold || flag[i][j] == 1) return 0;    
         flag[i][j] = 1;
         return helper(i - 1, j, rows, cols, flag, threshold)
             + helper(i + 1, j, rows, cols, flag, threshold)
             + helper(i, j - 1, rows, cols, flag, threshold)
             + helper(i, j + 1, rows, cols, flag, threshold)
             + 1;
     }

     private int numSum(int i) {
         int sum = 0;
         do{
             sum += i%10;
         }while((i = i/10) > 0);
         return sum;
     }



     public static void main(String[] args) {
         String regex = "[0-9]*.[0-9]*";
         String str = ".123";
     }
}