2019秋招复习笔记--剑指OFFER题解

二分法查找算法模板:

1. mid不在左边边界上就在右边边界上

2. 当有个边界时mid-1时，则为了防止死循需要在计算mid时+1；

版本1
当我们将区间[l, r]划分成[l, mid]和[mid + 1, r]时，其更新操作是r = mid或者l = mid + 1;，计算mid时不需要加1。

更新操作为什么是r = mid 或者是l = mid +1呢？因为划分为[l, mid]和[mid+1, r]后，我们要保留的区间肯定在这两个区间中的一个, 要么保留[l, mid]，此时 r 更新成了mid; 要么保留的是[mid+1, r], 此时l更新成了mid+1;

版本2
当我们将区间[l, r]划分成[l, mid - 1]和[mid, r]时，其更新操作是r = mid - 1或者l = mid;，此时为了防止死循环，计算mid时需要加1。

通用类：

//Definition for TreeNode
public class ListNode {
    int val;
    ListNode next = null;

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

public class TreeLinkNode {
    int val;
    TreeLinkNode left = null;
    TreeLinkNode right = null;
    TreeLinkNode next = null;//next指针指向中序遍历的条件下当前节点的下一个节点，从树的结构上看是指向父结点的指针

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

//  Definition for binary tree
public class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

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

题目：

/*
*给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。
* */

/*
* 题解
* 考虑到指数有可能为负数的情况
* */
public class 代码的完整性_数值的整数次方 {
    public double Power(double base, int exponent) {
        boolean flag = exponent >= 0? true:false;
        exponent = exponent >= 0? exponent:-exponent;
        double res = 1;
        for(int i = 0; i<exponent; i++){
            res *= base;
        }
        if(!flag)
            res = 1/res;
        return res;
    }
}

/*
* 题目描述
输入一个整数数组，实现一个函数来调整该数组中数字的顺序，
使得所有的奇数位于数组的前半部分，所有的偶数位于数组的
后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。
* */


/*
*
* */
public class 代码的完整性_整数组顺序使奇数位于偶数前面 {

    //雪菜写的双指针算法
    public void reOrderArray(int [] array) {
        int i = 0;
        int j = array.length-1;
        while(i<=j){
            while(array[i]%2==1) i++;
            while(array[j]%2==0) j--;
            if(i<j) swap(array,i,j);
        }
    }



    //自己写的双指针移动
    public static void reOrderArray1(int [] array) {
        int i = 0;
        int j ;
        while(i<array.length && array[i]%2==1 )
            i++;
        j = i+1;
        while(j<array.length){
            while( j<array.length && array[j]%2==0 )
                j++;
            if(j<array.length){
                swap(array, i, j);
                while(i<array.length && array[i]%2==1 )
                    i++;
                j = i+1;
            }
        }
    }



    //自己写的可以保证交换后顺序不变的写法
    public void reOrderArray2(int [] array) {
        int [] help1 = new int[array.length];
        int [] help2 = new int[array.length];
        int m = 0;
        int n = 0;
        for(int i = 0; i<array.length; i++){
            if(array[i]%2==1)
                help1[m++] = array[i];
            else
                help2[n++] = array[i];
        }
        int k = 0;
        for(int i = 0; i<m;i++)
            array[k++] = help1[i];
        for(int i = 0; i<n;i++)
            array[k++] = help2[i];
    }

    static void swap(int[] array, int i, int j){
        int tmp = array[i];
        array[i] = array[j];
        array[j] = tmp;
    }

    public static void main(String[] args) {
        int[] array = {1,2,3,4,5,6,7};
        int[] array1 = {1,2,4,6,5,9,7};
//        reOrderArray(array);
        for(int i:array)
            System.out.print(i+ " ");
    }
}

/*题目描述
输入一个链表，反转链表后，输出新链表的表头。*/
//解释见本文件夹下的 代码的鲁棒性_反转链表详细解释.png
public class 代码的鲁棒性_反转链表 {
    //    递归方法
    public ListNode ReverseList(ListNode head) {
        if (head == null || head.next == null)
            return head;
        ListNode h = ReverseList(head.next);//带着成为新头节点的尾节点一直到递归最外层成为头
        head.next.next = head;
        head.next = null;
        return h;
    }

//    https://blog.csdn.net/geekmanong/article/details/51097196 经典单链表反转递归与非递归算法
//    非递归方法
//    利用两个结点指针和一个中间结点指针temp(用来记录当前结点的下一个节点的位置)，分别指向当前结点和前一个结点，
//    每次循环让当前结点的指针域指向前一个结点即可，翻转结束后，记得将最后一个节点的链域置为空。

    public ListNode ReverseList2(ListNode head) {
        ListNode pre = null;
        ListNode cur = head;
        while(cur!=null){
            ListNode next = cur.next;
            cur.next = pre;
            pre = cur;
            cur = next;
        }
        return pre;
    }
}

/*
*题目描述
输入两个单调递增的链表，输出两个链表合成后的链表，
当然我们需要合成后的链表满足单调不减规则。
* */

/*
* 归并排序的步骤
* */
public class 代码的鲁棒性_合并两个排序的链表 {
    public ListNode Merge(ListNode list1,ListNode list2) {
        ListNode head = new ListNode(-1);
        ListNode l = head;

        while(list1!=null&&list2!=null){
            if(list1.val<list2.val){
                l.next = list1;
                l = l.next;
                list1 = list1.next;
            }else{
                l.next = list2;
                l = l.next;
                list2 = list2.next;
            }
        }

        if(list1!=null){
            l.next = list1;
        }
        if(list2!=null){
            l.next = list2;
        }

        return head.next;
    }
}

/*
* 题目描述
输入一个链表，输出该链表中倒数第k个结点。
* */

/*
* */
public class 代码的鲁棒性_链表中倒数第k个结点 {
    public static ListNode FindKthToTail(ListNode head,int k) {

        int i = 0;
        ListNode l = head;
        while(l!=null){
            i++;
            l = l.next;
        }

        int m = i-k+1;
        if (k>i)
            return null;
        l = head;
        while(m>1){//注意理清节点以及遍历次数，一个好的想法是可以举例子来判断边界是否正确
            m--;
            l = l.next;
        }
        return l;
    }

    public static void main(String[] args) {
        ListNode head = new ListNode(1);
        ListNode l = head;
        l.next = new ListNode(2);
        l = l.next;
        l.next = new ListNode(3);
        l = l.next;
        l.next = new ListNode(4);
        l = l.next;
        l.next = new ListNode(5);

        FindKthToTail(head, 1);
    }

}

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

/*
* 题解
*迭代进行如下两步，直到 n 变成0为止：

如果 n 在二进制表示下末尾是1，则在答案中加1；
将 n 右移一位，也就是将 nn 在二进制表示下的最后一位删掉；
这里有个难点是如何处理负数。

在C++中如果我们右移一个负整数，系统会自动在最高位补1，这样会导致 n 永远不为0，就死循环了。
解决办法是把 nn 强制转化成无符号整型，这样 n 的二进制表示不会发生改变，但在右移时系统会自动在最高位补0。

在java里面:
<< 表示左移
>> 表示右移 （带符号右移，负数高位补0正数高位补1）
>>> 表示无符号右移（无论正负高位补0）

补充雪菜关于补码的理解：
在十进制下也有补码的概念:
3的补码是7因为 3+7=10；
22的补码是78 因为 22+78 = 100；
就是能把你加到刚好到进位的那个数，就是你的补码；
二进制也是一样:
1的补码是
1111 1111 1111 1111
10的补码是
1111 1111 1111 1110
11的补码是
1111 1111 1111 1101
一个负数在计算机里，用它绝对值的补码表示,
也就是说，-2用2(10)的补码 1111 1111 1111 1110 表示


时间复杂度
每次会将 nn 除以2，最多会除 lognlogn 次，所以时间复杂度是 O(logn)O(logn)。
题解来自大雪菜
* */
public class 位运算_二进制中1的个数 {
    public int NumberOf1(int n)
    {
        int res = 0;
        while(n!=0){
            res += n&1;
            n = n>>>1;
        }
        return res;
    }
}

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

/*
* 解法：
* —— —— —— —— ——
* 令s表示到从头开始到第i-1个元素的累计和，因为要求的是最大和
* 所以当s<0时，前i-1个元素对和的贡献为负数，所以如果要选第i个元素，则前i-1个元素不应该选取, 将s置为0
* 所以到第i个元素时，
* 若s<=0:
*    s =  0 + array[i];
* 若s>0:
*   s =   s + array[i];
*
* res 是整个过程中s能取得最大值
* */
public class 前缀和_连续子数组的最大和 {
    public int FindGreatestSumOfSubArray(int[] array) {
        int res = Integer.MIN_VALUE;
        int s = 0;
        for(int i: array){
            if(s <= 0)
                s = 0 ;
            s += i;
            res = Math.max(res, s);
        }
        return res;
    }
}

/*题目描述
写一个函数，求两个整数之和，要求在函数体内不得使用+、-、*、/
四则运算符号。*/

/*
* 解题思路：
* 计算机中的加法首先将数字转为二进制，然后使用与和非这两种操作完成的
* 例如要计算A+B,得到的结果用CD表示：
*  如果A = 1 B = 0， 则A+B = 01(CD,C=0,D=1)
*  如果A = 1 B = 1， 则A+B = 10(CD,C=1,D=0)
*  如果A = 0 B = 1， 则A+B = 01(CD,C=0,D=1)
*  如果A = 0 B = 0， 则A+B = 00(CD,C=0,D=0)
*  可以看出D = A^B(低位是不进位加法)
*        C = A&B;（高位是A和B与的结果，即只有A和B同时为1时才有进位）
*
* 在计算时，可以先计算不进位加法 A^B = num  ,
*          再用计算进位 A&B = carry (carry需要左移一位加到新数上)
*          再将两个结果加起来(仍然使用上面的方法做这个加法)，直到carry变为0
* */
public class 发散思维能力_不用加减乘除做加法 {
    public static int Add(int num1,int num2) {
        int res = num1^num2;
        int carry = (num1&num2)<<1;
        int tmp;
        while(carry!=0){
            tmp = res^carry;
            carry = (res&carry)<<1;
            res = tmp;
        }
        return res;
    }

    public static void main(String[] args) {
        System.out.println(Add(111,899));
    }
}

/*
* 题目: https://www.acwing.com/problem/content/24/
* 给你一根长度为 n 绳子，请把绳子剪成 m 段（m、n 都是整数，2≤n≤58 并且 m≥2）。

每段的绳子的长度记为k[0]、k[1]、……、k[m]。k[0]k[1] … k[m] 可能的最大乘积是多少？

例如当绳子的长度是8时，我们把它剪成长度分别为2、3、3的三段，此时得到最大的乘积18。

样例
输入：8

输出：18
* */

/*
* 题解来自大雪菜
* 1.至少要剪成两段；
* 2.剪出长度为1的绳子对最大乘积没有贡献，因此如果想乘积最大，则一定不能剪出长度为1的绳子（绳长为2的不得不剪成两根1，绳长为3的不得不剪成1个1一个2）；
* 3.当绳长足够长时(长度大于5)，使得乘积最大的剪法是剪成若干个3和0至两个2：
* 证明如下:
* 假设剪出的某个绳长为n(n>5),则我们可以从中再剪出一个3来,得到的乘积：
* (n-3)*3 > n 的条件是2*n>9, 则说明n>5时将n剪出一个3来的乘积一定比不剪开要大;
* n = 4时 剪成两个 2
* 为什么不剪成多于两个的2呢？
* 因为6 = 2+2+2，乘积为8，剪成3+3，乘积为9
* 所以
* 本题的算法是:
* 如果n除3余1，则 n = 2+2 + 3 + ... +3;
* 如果n除3余2，则  n =2  + 3 + ... +3;
* 如果n除3余0，则  n =3 + ... +3;
* n = 2，3，4的时候需要特判
*
*
* 这道题目是数学中一个很经典的问题。
下面我们给出证明：

首先把一个正整数 NN 拆分成若干正整数只有有限种拆法，所以存在最大乘积。
假设 N=n1+n2+…+nkN=n1+n2+…+nk，并且 n1×n2×…×nkn1×n2×…×nk 是最大乘积。

显然1不会出现在其中；
如果对于某 ii 有 ni≥5ni≥5，那么把 nini 拆分成 3+(ni−3)3+(ni−3)，我们有 3(ni−3)=3ni−9>ni3(ni−3)=3ni−9>ni；
如果 ni=4ni=4，拆成 2+22+2乘积不变，所以不妨假设没有4；
如果有三个以上的2，那么 3×3>2×2×23×3>2×2×2，所以替换成3乘积更大；
综上，选用尽量多的3，直到剩下2或者4时，用2。

时间复杂度分析：当 nn 比较大时，nn 会被拆分成 ⌈n/3⌉⌈n/3⌉ 个数，我们需要计算这么多次减法和乘法，所以时间复杂度是 O(n)O(n)。

作者：yxc
链接：https://www.acwing.com/solution/acwing/content/731/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
* */
public class 发散思维能力_剪绳子 {
    public static int maxProductAfterCutting(int length)
    {
        int res = 1;
        if(length == 2)
            res = 1;
        if(length == 3)
            res = 2;
        if(length == 4)
            res = 4;
        else if(length > 4){
            int n3 = 0;
            if(length%3 == 1){
                n3 = (length-4)/3;
                res *= 4*Math.pow(3,n3);
            }
            if(length%3 == 2){
                n3 = length/3;
                res *= 2*Math.pow(3,n3);
            }
            else if(length%3 == 0){
                n3 = length/3;
                res *=Math.pow(3,n3);
            }
        }
        return res;
    }

    public static void main(String[] args) {
        maxProductAfterCutting(7);
    }

}

//本题有两个，一个来自ACwing, 解法比较巧妙
//还有一个见下方，来自牛客

/*
描述：
* 数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。

假设数组非空，并且一定存在满足条件的数字。

要求只能使用 O(n) 的时间和额外 O(1) 的空间，该怎么做呢？
* */
import java.util.*;

/*
 * 题解
 * 用一个cnt记录次数
 * 一个val记录值
 * 如果下一个数与保存的val相同，则cnt++;
 * 否则
 * cnt--
 * 当cnt减到0了，就把val重新赋给新值
 * 因为数组中有一个数多于一半，所以最后val中保存的一定是这个数字
 * */
public class 发散思维能力_数组中出现次数超过一半的数字 {
    public int MoreThanHalfNum_Solution(int[] array) {
        int cnt = 0;
        int val = -1;
        for (int x : array) {
            if (cnt == 0) {
                val = x;
                cnt = 1;
            } else {
                if (x == val)
                    cnt++;
                else
                    cnt--;
            }

        }
        return val;
    }

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

//    下面的解法是牛客网上题目的解法，其实牛客的这道题目意义不大，就是统计每个数字出现次数找出出现次数最大的数字这样一个过程
//    下面的解法主要训练了自己使用HashMap按照value降序排序的一个方法
    public static int m(int[] array) {
        Map<Integer, Integer> res = new HashMap<>();
        for (int x : array) {
            if (res.containsKey(x))
                res.put(x, res.get(x) + 1);
            else
                res.put(x, 1);
        }
        List<Map.Entry<Integer, Integer>> list = new ArrayList<>(res.entrySet());
        Collections.sort(list, (Map.Entry<Integer, Integer> o1, Map.Entry<Integer, Integer> o2)->o2.getValue().compareTo(o1.getValue()));
        int max = list.get(0).getValue();
        if (max > array.length / 2)
            return list.get(0).getKey();
        else
            return 0;
    }

    public static void main(String[] args) {
        发散思维能力_数组中出现次数超过一半的数字 a = new 发散思维能力_数组中出现次数超过一半的数字();
        int [] arr = {1,2,3,2,2,2,5,4,2};
        System.out.println(a.m(arr));
    }
}

/*
*求1+2+3+...+n，要求不能使用乘除法、
* for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。
* */
//链接：https://www.nowcoder.com/questionTerminal/7a0da8fc483247ff8800059e12d7caf1
//        来源：牛客网
/*题目说了不许用循环，那就摆明了是要递归了。*/
/*链接：https://www.nowcoder.com/questionTerminal/7a0da8fc483247ff8800059e12d7caf1
来源：牛客网

1.需利用逻辑与的短路特性实现递归终止。
2.当n==0时，(n>0)&&((sum+=Sum_Solution(n-1))>0)只执行前面的判断，为false，然后直接返回0；
3.当n>0时，执行sum+=Sum_Solution(n-1)，实现递归计算Sum_Solution(n)。*/
public class 发散思维能力_求1加2加3加n {
    public int Sum_Solution(int n) {
        int sum = n;
        boolean flag = (sum>0)&&((sum+=Sum_Solution(--n))>0); //短路特性， boolean值没有意义
        return sum;
    }
}

import java.util.Deque;
import java.util.LinkedList;

/*
*题目描述
地上有一个m行和n列的方格。一个机器人从坐标0,0的格子开始移动，
每一次只能向左，右，上，下四个方向移动一格，但是不能进入行坐
标和列坐标的数位之和大于k的格子。 例如，当k为18时，机器人能
够进入方格（35,37），因为3+5+3+7 = 18。但是，它不能进入方
格（35,38），因为3+5+3+8 = 19。请问该机器人能够达到多少个格子？
* */

/*
* 解题思路：
* 宽搜
* */
public class 回溯法_机器人的运动范围 {
    public int movingCount(int threshold, int rows, int cols) {
        int res = 0;
        if (rows == 0 || cols == 0)
            return 0;
        boolean[][] mark = new boolean[rows][cols];
        Deque<int[]> pair = new LinkedList<>();
        pair.push(new int[]{0, 0});

        int[] dx = {-1, 0, 1, 0};
        int[] dy = {0, -1, 0, 1};

        while (!pair.isEmpty()) {
            int[] t = pair.poll();
            if (get_sum(t) > threshold || mark[t[0]][t[1]])
                continue;
            res++;
            mark[t[0]][t[1]] = true;
            for (int i = 0; i < 4; i++) {
                int x = t[0] + dx[i];
                int y = t[1] + dy[i];
                if(x>=0 && x<rows && y>=0 && y<cols)
                    pair.push(new int[] {x,y});
            }
        }
        return res;
    }

    static int get_sum(int[] p) {
        return get_sum(p[0]) + get_sum(p[1]);
    }

    static int get_sum(int x) {
        int s = 0;
        while (x > 0) {
            s += x % 10;
            x /= 10;
        }
        return s;
    }
}

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

//      枚举所有起点
        for (int i = 0; i < rows; i++)
            for (int j = 0; j < cols; j++)
//                dfs是在该起点的基础上枚举所有方向
                if (dfs(matrix, str, 0, i, j, rows, cols))
                    return true;
        return false;
    }

    //    dfs的作用是枚举所有方向
    static boolean dfs(char[] matrix, char[] str, int u, int x, int y, int rows, int cols) {
//        如果当前u的长度达到了要匹配的字符串的末尾，则返回true
        if (u == str.length) return true;
//        如果当前字符和str上要找u处的字符不同，返回false
        if (matrix[x*cols+y] != str[u]) return false;
//        枚举方向的常用方法
        int[] dx = {-1, 0, 1, 0};
        int[] dy = {0, 1, 0, -1};
//        为了保证不走重复路线（不往回走），需要将走过的位置标记，但是在退出该条枚举路线之前需要还原现场
        char t = matrix[x*cols+y];
        matrix[x*cols+y] = '*';
//        枚举四个方向
        for (int i = 0; i < 4; i++) {
            int a = x + dx[i];
            int b = y + dy[i];
            if (a >= 0 && a < rows && b >= 0 && b < cols) {
//                如果后面递归的结果是true,那么到了本层应该把true传递到下一层
                if (dfs(matrix, str, u + 1, a, b, rows, cols))
                    return true;
            }
        }
        matrix[x*cols+y] = t;
        return false;
    }

    public static void main(String[] args) {
        char[] a = {'A'};
        char[] b = {'A'};
        System.out.println(hasPath(a, 1, 2, b));
    }
}
//下面是通过的题解2,不用转为二维矩阵
/*
*  static boolean hasPath(char[] matrix, int rows, int cols, char[] str) {
        if (matrix.length == 1)
            return matrix[0] == str[0];

        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                if (dfs(matrix, 0, i, j, str, rows, cols))
                    return true;
            }
        }
        return false;
    }

    static boolean dfs(char[] matrix, int u, int x, int y, char[] str, int rows, int cols) {
        if (u == str.length) return true;
        if (matrix[x * cols + y] != str[u]) return false;
        char tmp = matrix[x * cols + y];
        matrix[x * cols + y] = '*';
        int[] dx = {-1, 0, 1, 0};
        int[] dy = {0, 1, 0, -1};
        for (int i = 0; i < 4; i++) {
            int a = x + dx[i];
            int b = y + dy[i];
//
            if (a >= 0 && a < rows && b >= 0 && b < cols) {
                if (dfs(matrix, u + 1, a, b, str, rows, cols))
                    return true;
            }
        }
        matrix[x * cols + y] = tmp;
        return false;
    }
* */
//下面是通过的题解1,要先转为二维矩阵
/*public class Solution {
 public boolean hasPath(char[] matrix, int rows, int cols, char[] str) {
        if(matrix.length==1)
            return matrix[0] == str[0];
        char[][] matrix_ = new char[rows][cols];
        int k = 0;
        for (int i = 0; i < rows; i++)
            for (int j = 0; j < cols; j++)
                matrix_[i][j] = matrix[k++];

        for (int i = 0; i < rows; i++)
            for (int j = 0; j < cols; j++)
                if (dfs(matrix_, str, 0, i, j))
                    return true;
        return false;
    }

    boolean dfs(char[][] matrix, char[] str, int u, int x, int y) {
        if (u == str.length) return true;
        if (matrix[x][y] != str[u]) return false;
        int[] dx = {-1, 0, 1, 0};
        int[] dy = {0, -1, 0, 1};
        char t = matrix[x][y];
        matrix[x][y] = '*';
        for (int i = 0; i < 4; i++) {
            int a = x + dx[i];
            int b = y + dy[i];
            if (a >= 0 && a < matrix.length && b >= 0 && b < matrix[a].length) {
                if (dfs(matrix, str, u + 1, a, b))
                    return true;
            }
        }
        matrix[x][y] = t;
        return false;
    }
}*/

import java.util.Comparator;
import java.util.PriorityQueue;

/*题目描述
如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。
如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。
我们使用Insert()方法读取数据流，使用GetMedian()方法获取当前读取数据的中位数。*/

/*
* 解题思路（来自雪菜）：
* 维护两个堆（图见 堆_数据流的中位数.png）
* 维护一个大根堆和一个小根堆，如图:
* 小根堆在上，存的是较大的数（小根堆的堆顶是堆里最小的数，小根堆里其他数都比它大）；
* 大根堆在下，存的是较小的数（大根堆的堆顶是堆里较大的数，大根堆里其他数都比它小）；
* 我们的目的是维护这两个堆，使得小根堆里面存的数都比大根堆里面存的数大
* 每次插入数据都从下面的小根堆插入，插入后，比较大根堆和小根堆堆顶数的大小，如果下面的大根堆的堆顶比上面的小根堆的堆顶要大，
* 则交换两个堆的堆顶；
* 然后再进行一步判断:如果下面的大根堆的数据的个数比上面小根堆的数据个数多2个，则直接取出下面大根堆堆顶元素插入上面的小根堆中；
*
* 最后判断:
* 如果两个堆中元素的总个数为奇数，则中位数是下面大根堆的堆顶；
* 如果两个堆中元素的总个数为偶数，则中位数是两个堆堆顶元素的平均数
* */
public class 堆_数据流的中位数 {

//    优先队列默认是按自然顺序排序，也就是从小到大排序的
    PriorityQueue<Integer> min_heap = new PriorityQueue<>();
    PriorityQueue<Integer> max_heap = new PriorityQueue<>(Comparator.reverseOrder());
    public void Insert(Integer num) {
        max_heap.offer(num);
// 每次插入数据都从下面的小根堆插入，插入后，比较大根堆和小根堆堆顶数的大小，如果下面的大根堆的堆顶比上面的小根堆的堆顶要大，
// 则交换两个堆的堆顶；
        if(!min_heap.isEmpty() && !max_heap.isEmpty() && min_heap.peek()<max_heap.peek()){
            int tmp_big = max_heap.poll();
            int tmp_small = min_heap.poll();
            min_heap.offer(tmp_big);
            max_heap.offer(tmp_small);
        }
        //如果下面的大根堆的数据的个数比上面小根堆的数据个数多2个，则直接取出下面大根堆堆顶元素插入上面的小根堆中；
        if(max_heap.size() - min_heap.size() > 1){
            min_heap.offer(max_heap.poll());
        }
    }

//    如果两个堆中元素的总个数为奇数，则中位数是下面大根堆的堆顶；
//    如果两个堆中元素的总个数为偶数，则中位数是两个堆堆顶元素的平均数
    public Double GetMedian() {
        if ((max_heap.size() + min_heap.size())%2 != 0)
            return new Double(max_heap.peek());
        else
            return (max_heap.peek().doubleValue()+min_heap.peek().doubleValue())/2;

    }
}

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

    public static void main(String[] args) {
        System.out.println(字符串_替换空格.replaceSpace(new StringBuffer("   I love you ")));
    }
}

/*
* 请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。例如，
* 字符串"+100","5e2","-123","3.1416"和"-1E-16"都表示数值。
* 但是"12e","1a3.14","1.2.3","+-5"和"12e+4.3"都不是。
* */
public class 字符串_表示数值的字符串 {
    public static void main(String[] args) {
        int[] p;

    }
}

/*
*题目描述
输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。
如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。
* */

/*
*题解：
*算法1
(后序遍历，递归) O(n)O(n)
后序遍历，数组的最后一个值是二叉树的根节点

所以前面的值一部分小于根节点，一部分大于根节点，因为是二叉搜索树

找到比根节点小的，则为左子树

比根节点大的为右子树

然后递归整个数组即可
* */
//本题是week4的题目
public class 循环和递归_二叉搜索树的后序遍历序列 {
    int[] seq;
    public boolean VerifySquenceOfBST(int [] sequence) {
        if(sequence.length == 0 ) return false;
        seq = sequence;
        return dfs(0, sequence.length-1);
    }

    boolean dfs(int l, int r){
        if(l >= r) return true;//如果子树的长度为0，则遍历到叶子节点，为真
        int root = seq[r]; //后序遍历的最后一个值是搜索二叉树的根节点
        int k = l;
        while(k<r && seq[k]<root)
            k++;//找到以root为根的左子树序列的位置（由于二叉搜索树的属性，其左子树都比根节点要小）
        for(int i = k; i < r; i++){
            if(seq[i]<root){
                return false;//从左子树的右边开始是右子树，根据二叉搜索树的性质，根节点的右子树
                             //都比根节点要大，如果出现了比根节点小的节点，则说明这棵树不合定义，返回false
            }
        }
        return dfs(l, k-1) && dfs(k+1,r);//递归检查左右子树
    }
}

/*
*题目描述
输入一颗二叉树的跟节点和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。
路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。(注意: 在返回值的list中，数组长度大的数组靠前)
* */

/*
 * 题解
 *本题就是一个遍历,遍历每条路径,保存符合要求的路径
 * 如何保存并还原现场是一个难点
 * */

import java.util.ArrayList;

/**
 * public class TreeNode {
 * int val = 0;
 * TreeNode left = null;
 * TreeNode right = null;
 * <p>
 * public TreeNode(int val) {
 * this.val = val;
 * <p>
 * }
 * <p>
 * }
 */

public class 循环和递归_二叉树中和为某一值的路径 {
    ArrayList<ArrayList<Integer>> ans = new ArrayList<>();
    ArrayList<Integer> path = new ArrayList<>();

    public ArrayList<ArrayList<Integer>> FindPath(TreeNode root, int target) {
        dfs(root, target);
        return ans;
    }

    void dfs(TreeNode root, int sum) {
        if (root == null)//如果遍历到头(即到了空节点),直接返回
            return;
        path.add(root.val);//如果当前不是空节点,把该节点放进路径链表中
        sum -= root.val;//将目标值减去该节点
        //某条路径符合要求的条件是:1.该节点是叶子节点 (root.left == null && root.right == null)
//                             2. 并且到该节点时路径上所有节点总和为sum (&& sum == 0)
        if (root.left == null && root.right == null && sum == 0)
//            错误写法：
//            ans.add(path); path是变量，如果把path直接存进ans里面，存的是path的引用，而path在之后还会发生变化，所以存进ans里面的答案会随之
//            变化(记住ans.add(path)这样在ans里面存的是path的引用),所以需要拷贝当前path的副本,把副本存到ans里面去,这样后面path的变化不会影响到
//            存到ans里面的路径
            ans.add(new ArrayList<>(path));//将符合要求的路径保存进答案中
        dfs(root.left, sum);//递归遍历左子树
        dfs(root.right, sum);//递归遍历右子树
        //还原现场,因为我们不光遍历一个分支,还要遍历其他分支.所以在遍历完当前子树之后(不论当前路径是否符合要求)
        //要把当前节点造成的影响消除,在path中去掉当前的节点(因为当前节点所在的路径已经被考察过)
        path.remove(path.size()-1);
        //sum不用还原,因为sum传过来的时标量不是地址
    }

    public static void main(String[] args) {
        TreeNode h = new TreeNode(10);
        h.left = new TreeNode(5);
        h.right = new TreeNode(12);
        h.left.left = new TreeNode(4);
        h.left.right = new TreeNode(7);

        循环和递归_二叉树中和为某一值的路径 a = new 循环和递归_二叉树中和为某一值的路径();
        System.out.println(a.FindPath(h,22).toString());
    }
}

/*
*题目描述
操作给定的二叉树，将其变换为源二叉树的镜像。
输入描述:
二叉树的镜像定义：源二叉树
            8
           /  
          6   10
         /   / 
        5  7 9 11
        镜像二叉树
            8
           /  
          10   6
         /   / 
        11 9 7  5
* */

/*
* 题解
* */
public class 循环和递归_二叉树的镜像 {
    public void Mirror(TreeNode root) {
        if(root == null)
            return;
        else{
            //后序
            Mirror(root.left);
            Mirror(root.right);
            //执行交换
            TreeNode tmp = root.left;
            root.left = root.right;
            root.right = tmp;
//            前序也可以
/*            Mirror(root.left);
            Mirror(root.right);
            TreeNode tmp = root.left;
            root.left = root.right;
            root.right = tmp;*/
        }
    }
}

/*
* 题目描述
一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。
求该青蛙跳上一个n级的台阶总共有多少种跳法。
* */
public class 循环和递归_变态跳台阶 {
    //    递归
    static public int JumpFloorII(int target) {
        if (target < 2)
            return 1;
        else {
            int res = 0;
            for (int i = 0; i < target; i++)
                res = res + JumpFloorII(i);
            return res;
        }
    }

    //    动态规划
    static public int JumpFloorIII(int target) {
        int[] val = new int[target];
        int res = 0;
        for (int i = 0; i < target; i++)
            res = res + dp(i, val);
        return res;
    }

    static int dp(int target, int[] val) {
        if (target < 2) {
            val[target] = 1;
            return val[target];
        } else {
            if (val[target] == 0) {
                for (int i = 0; i < target; i++) {
                    val[target] += dp(i, val);
                }
            }
            return val[target];
        }
    }

    public static void main(String[] args) {
        System.out.println(JumpFloorIII(4));
        System.out.println(JumpFloorII(4));
    }
}

/*题目描述
大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0）。
n<=39*/
public class 循环和递归_斐波那契数列 {
    public static int Fibonacci(int n) {
        int[] dp = new int[n + 1];
        return Fib(n, dp);
    }

    static int Fib(int i, int[] dp) {
        if (i < 2) {
            dp[i] = i;
            return dp[i];
        } else {
            if (dp[i] == 0)
                dp[i] = Fib(i - 1, dp) + Fib(i - 2, dp);
            return dp[i];
        }
    }

    public static void main(String[] args) {
        System.out.println(Fibonacci(0));
    }

}

/*
*题目描述
输入两棵二叉树A，B，判断B是不是A的子结构。
（ps：我们约定空树不是任意一个树的子结构）
* */

/*
*题解:
* 代码分为两个部分：

遍历树A中的所有非空节点R；
判断树A中以R为根节点的子树是不是包含和树B一样的结构，且我们从根节点开始匹配；
对于第一部分，我们直接递归遍历树A即可，遇到非空节点后，就进行第二部分的判断。

对于第二部分，我们同时从根节点开始遍历两棵子树：

如果树B中的节点为空，则表示当前分支是匹配的，返回true；
如果树A中的节点为空，但树B中的节点不为空，则说明不匹配，返回false；
如果两个节点都不为空，但数值不同，则说明不匹配，返回false；
否则说明当前这个点是匹配的，然后递归判断左子树和右子树是否分别匹配即可；
时间复杂度
最坏情况下，我们对于树A中的每个节点都要递归判断一遍，每次判断在最坏情况下需要遍历完树B中的所有节点。
所以时间复杂度是 O(nm)O(nm)，其中 nn 是树A中的节点数， mm 是树B中的节点数。

链接：https://www.acwing.com/solution/acwing/content/745/
* */
public class 循环和递归_树的子结构 {
    public boolean HasSubtree(TreeNode root1,TreeNode root2) {
        if(root1 == null || root2 == null) return false;
        if(isPart(root1, root2)) return true;
        return HasSubtree(root1.left, root2)||HasSubtree(root1.right, root2);
    }

    public boolean isPart(TreeNode p1, TreeNode p2){
        if(p2 == null) return true;
        if(p1 == null || p1.val!=p2.val) return false;
        return isPart(p1.left, p2.left)&&isPart(p1.right, p2.right);
    }
}

/*
* 我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。
* 请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？
* */

/*
* 解题思路：
　　观察题目中的矩形，2*n的，是个长条形。本来脑中想象的是复杂的华容道，但是既然只是简单的长条形，
    那么依然逆向分析。既然是长条形的，那么从后向前，最后一个矩形2*2的，只有两种情况：

　　 第一种是最后是由一个2*(n-1)的矩形加上一个竖着的2*1的矩形
　　另一种是由一个2*(n-2)的矩形，加上两个横着的2*1的矩形
　　因此我们可以得出，
　　第2*n个矩形的覆盖方法等于第2*(n-1)加上第2*(n-2)的方法。使用代码可以表示为：
    for(i=3;i<71;i++){
        arr[i] = arr[i-1]+arr[i-2];
    }
　　仍然要注意数据类型，为long long型
    题解来自 https://www.cnblogs.com/xing901022/p/3753718.html
* */
public class 循环和递归_矩形覆盖 {
    public int RectCover(int target) {
        int[] res = new int[1000000];
        res[0] = 0;
        res[1] = 1;
        res[2] = 2;
        if(target<3)
            return res[target];
        else
            return cal(target, res);
    }

    public int cal(int n, int[] res){
        if(res[n]!=0)
            return res[n];
        else{
            int tmp = cal(n-1,res)+cal(n-2,res);
            res[n] = tmp;
            return res[n];
        }
    }
}

/*一只青蛙一次可以跳上1级台阶，也可以跳上2级。
求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。*/
public class 循环和递归_跳台阶 {
    //    递归
    public int JumpFloor(int target) {
        if (target < 2)
            return 1;
        else
            return JumpFloor(target - 1) + JumpFloor(target - 2);
    }

    //    动态规划

    public int JumpFloorI(int target) {
        int[] val = new int[target + 1];
        return dp(target, val);
    }

    public int dp(int target, int[] val) {
        if (target < 2) {
            val[target] = 1;
            return val[target];
        } else {
            if (val[target] == 0)
                val[target] = dp(target - 1, val) + dp(target - 2, val);
            return val[target];
        }
    }
}

/*
* 给定一个数字，我们按照如下规则把它翻译为字符串：
0翻译成”a”，1翻译成”b”，……，11翻译成”l”，……，25翻译成”z”。
一个数字可能有多个翻译。例如12258有5种不同的翻译，它们分别是”bccfi”、”bwfi”、”bczi”、”mcfi”和”mzi”。
请编程实现一个函数用来计算一个数字有多少种不同的翻译方法。
样例
输入："12258"
输出：5
* */

/*
 *这是一个DP问题：
 * 1.状态怎么表示
 *   f[i]表示前i位数字有多少种不同的翻译方式：
 *       a.如果将第i位翻译成一个单独的字母，则f[i] = f[i-1];
 *       b.如果i-1位和第i位共同翻译成一个字母，则f[i] = f[i-2]+f[i-1]
 *   前i个字母翻译结果的所有情况会被这两部分完全覆盖，且这两部分没有交集。
 *   这两类加起来就是所有的情况。
 *
 * 2.状态如何计算
 * 3.边界
 * */
public class 把数字翻译成字符串 {
    public static int getTranslationCount(String s) {
        char[] sc = s.toCharArray();
        int n = sc.length;
        int[] f = new int[n + 1];
        f[1] = 1;
        for (int i = 2; i <= n; i++) {

            f[i] = f[i - 1];//第i位数字单独翻译成一个字母时，前i个数字的翻译方案数等于前i-1个数字的翻译方案数
//          检查第i-1和第i-2位是否可以组成合法的可翻译为一个字母的数字
//          注意这里下标在f[]中和在sc[]中表示的数位有偏移，在sc中，下标从0开始； 在f[]中，下标从1开始；所以前i位的方案数用f[i]表示，但第i个字符用sc[i-1]表示
            int t = (sc[i - 2] - '0') * 10 + sc[i - 1] - '0';//t表示由第i位和第i-1位数字组成的两位数字
//          第i和第i-1位的组合结果有两种状态不能被翻译成一个字母：一、05这样的前面有0的；二、>=26的。
//          所以只有在10~26之间的数字可以合法的被一个字母翻译
            if (t >= 10 && t <= 25)
//          如果满足上述条件，则前i个数字的翻译方案还可以是前i-2位数字的翻译方案数，
                f[i] += f[i - 2];
        }
        return f[n];
    }

    public static void main(String[] args) {
        getTranslationCount("12258");
    }
}

/*
* 题目描述
输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。
例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。
* */

import java.util.Arrays;
//import java.util.Comparator;

/*
 *我们想，如果比较大小的时候，可以按照拼接结果的大小来对数组进行排序，则排序结果天然就能满足要求
 *1.需要定义一个新的比较大小的规则
 * 比较a和b两个数，如果a<b <==> ab < ba (ab表示将数字a和数字b直接连接成一个新的数字ab)
 *2.利用上述定义的大小比较规则将给定的数组排序
 *3.从排好序的数组里按从小到大的顺序取出数字来拼接成最终答案
 * 就是最小数字了
 *
 * 首先，满足上述大小比较规则的结果一定能是最小的结果，这是不言而喻的（a<b <==> ab < ba 这个性质决定的）
 * 其次，如果要定义一种大小比较规则，则离散数学告诉我们，这个规则必须满足一下两个定律该大小比较规则才能成立:
 * a.反对称性:a<=b, b<=a 则 => a=b
 * b.传递性: a<=b, b<=c, 则 => a<=c
 * 可以自行证明一下上面两条规律
 * */
public class 把数组排成最小的数 {

/*    class cmp implements Comparator<String>{
        @Override
        public int compare(String o1, String o2) {
            return (o1+o2).compareTo(o2+o1);
        }
    }*/

    public String PrintMinNumber(int [] numbers) {
//        先转为字符串
        String [] snum = new String[numbers.length];
        int j = 0;
        for(int i: numbers)
            snum[j++] = String.valueOf(i);
//        重写大小比较规则
        Arrays.sort(snum,(String s1, String s2)->(s1+s2).compareTo(s2+s1));
        StringBuilder res = new StringBuilder();
        for(String x:snum)
            res.append(x);
        return res.toString();
    }
}

/*
* 数字以0123456789101112131415…的格式序列化到一个字符序列中。
在这个序列中，第5位（从0开始计数）是5，第13位是1，第19位是4，等等。
请写一个函数求任意位对应的数字。
样例
输入：13
输出：1
来源:Acwing
* */

/*
*
* */
public class 数字序列中某一位的数字 {
}

/*
* 数字以0123456789101112131415…的格式序列化到一个字符序列中。
在这个序列中，第5位（从0开始计数）是5，第13位是1，第19位是4，等等。
请写一个函数求任意位对应的数字。

样例
输入：13
输出：1
* */

/*
* 题解:
* 我们要求的是该字符串中位置p上的数字
* 1.确定该位置p所属数字n是几位数: 假设n-10-90*2-900*3 = 256，说明n是四位数字，且p的位置在从1000开始往后数的第256位，
* 2.确定数字n是哪个数: 四位数字的开始是1000，又四位数每个数字有四位，故n=1000+256/4 =1064
* 3.确定位置p属于数字n的第几位：256除以4余数为0，故是该位数字的最后一位
* */
public class 数字题_数字序列中某一位的数字 {
    public int digitAtIndex(int n) {
        long i = 1;
        long s = 9;
        long base = 1;
        while(n>i*s){
            n -= i*s;
            i++;
            s *= 10;
            base *= 10;
        }
//        2.算出p位置所属的数字n是多少
//        n除以i,上取整的写法：(n+i-1)/i-1
        long number = base + (n+i-1)/i-1;
//        3.求p在数字n中是第几个数字，如果余数为零是左后一位数字，将r置为i
        long r = n%i!=0? n%i:i;
//        取出i位数的第r位出来
        for(int j = 0; j<i-r; j++)
            number/=10;
        return (int)number%10;
    }
}

/*题目描述
在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，
每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一
个整数，判断数组中是否含有该整数*/
public class 数组_二维数组中的查找 {
    public static boolean Find(int target, int[][] array) {
        if (array == null || array.length==0 ||(array.length==1&&array[0].length==0)||array[0][0] > target)
            return false;
        else {

            for (int i = 0; i < array.length; i++) {
                if (array[i][0] > target || array[i][array.length - 1] < target)
                    continue;
                else if (二分查找_判断有无给定元素.binarySearch2(target, array[i]))
                    return true;
            }
            return false;
        }
    }


    public static void main(String[] args) {
//        int[][] a = {{1,2,8,9},{2,4,9,12},{4,7,10,13},{6,8,11,15}};
//        int[][] a = {{}};
//        System.out.println(Find(1, a));
        int[] a = {1, 2, 8, 9};
        System.out.println(二分查找_判断有无给定元素.binarySearch(1, a, 0, a.length-1));
    }
}

/*
*题目描述
输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，
例如，如果输入如下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.
* */

import java.util.ArrayList;

/*
*题解:
* 算法
(模拟) O(n2)O(n2)
我们顺时针定义四个方向：上右下左。
从左上角开始遍历，先往右走，走到不能走为止，然后更改到下个方向，再走到不能走为止，依次类推，遍历 n2n2 个格子后停止。

时间复杂度
矩阵中每个格子遍历一次，所以总时间复杂度是 O(n^2)。
* */
public class 数组_顺时针打印矩阵 {
    public ArrayList<Integer> printMatrix(int [][] matrix) {

        ArrayList<Integer> res = new ArrayList<>();

        if(matrix == null || matrix[0] == null)
            return res;
        int m = matrix.length;
        int n = matrix[0].length;
        int[][] visited = new int[m][n];//记录是否访问过

        int[] dx = {-1,0,1,0};
        int[] dy = {0,1,0,-1};

        int x = 0;
        int y = 0;
        int d = 1;

        for(int i = 0; i < m; i++){
            for(int j = 0; j<n; j++){
                res.add(matrix[x][y]);
                visited[x][y] =  1;
                int a = x+dx[d];
                int b = y+dy[d];
                if(a<0||a>=m||b<0||b>=n || visited[a][b]==1){
                    d = (d+1)%4;
                    a = x+dx[d];
                    b = y+dy[d];
                }
                x = a;
                y = b;
            }
        }
        return res;
    }
}

/*
 * 求出1~13的整数中1出现的次数,并算出100~1300的整数中1出现的次数？
 * 为此他特别数了一下1~13中包含1的数字有1、10、11、12、13因此共出现6次,
 * 但是对于后面问题他就没辙了。ACMer希望你们帮帮他,并把问题更加普遍化,
 * 可以很快的求出任意非负整数区间中1出现的次数（从1 到 n 中1出现的次数）。
 * */

import java.util.ArrayList;
import java.util.List;

/*
 *
 * */
public class 整数中1出现的个数 {
    public int NumberOf1Between1AndN_Solution(int n) {
        if (n == 0)
            return 0;
        List<Integer> number = new ArrayList<>();
        while (n != 0) {
            number.add(n % 10);
            n /= 10;
        }
        int res = 0;
        for (int i = number.size() - 1; i >= 0; i--) {
            int left = 0;
            int right = 0;
            int t = 1;
            for (int j = number.size() - 1; j > i; j--) {
                left = left * 10 + number.get(j);
            }
            for (int j = i - 1; j >= 0; j--) {
                right = right * 10 + number.get(j);
                t *= 10;
            }
            res += left * t;
            if (number.get(i) == 1) res += right+1;
            else if (number.get(i) > 1)
                res += t;
        }
        return res;
    }
}

/*题目描述
输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，
则最小的4个数字是1,2,3,4,。*/

import java.util.ArrayList;
import java.util.PriorityQueue;
import java.util.Comparator;

/*
 * 解法:
 * 从一堆数字里面找到前n大的数要建最小堆，这样堆顶是当前堆里的最小数，来了一个新数，如果它比堆顶的最小数大，就把堆顶的数替换成当前数，并调整堆使得当前堆顶仍然是最小数
 * 同理从一堆数字里面找到前n小的数要建最大堆，因此下面的优先队列的比较器需要重写
 * */
public class 时间效率_最小的K个数 {
    public ArrayList<Integer> GetLeastNumbers_Solution(int[] input, int k) {
        ArrayList<Integer> result = new ArrayList<>();
        int length = input.length;
        if (k > length || k == 0) {
            return result;
        }

//        匿名函数
        /*PriorityQueue<Integer> maxHeap = new PriorityQueue<Integer>(k, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2.compareTo(o1);
            }
        });*/

//        lambda表达式
/*        PriorityQueue<Integer> maxHeap = new PriorityQueue<Integer>(k,
                (Integer o1, Integer o2) -> o2.compareTo(o1)
        );*/

//       简写
        PriorityQueue<Integer> maxHeap = new PriorityQueue<>(k,
                Comparator.reverseOrder()//按从大到小顺序排序
        );


        for (int i = 0; i < length; i++) {
            /*if (maxHeap.size() != k) {
                maxHeap.offer(input[i]);
            } else if (maxHeap.peek() > input[i]) {
                Integer temp = maxHeap.poll();
                temp = null;
                maxHeap.offer(input[i]);
            }*/

            //这样写也是可以的，一旦超出大小就删掉堆顶元素，不用判断（来自雪菜）
//            代码复杂度低，运行复杂度比上面的高
//          笔试面试题中建议写这种代码复杂度较低，逻辑清晰，容易调试的代码。
            maxHeap.offer(input[i]);
            if (maxHeap.size() > k)
                maxHeap.poll();
        }
        result.addAll(maxHeap);
        return result;
    }
}

/*
 * 题目:
 * 请实现一个函数用来匹配包括'.'和'*'的正则表达式。模式中的字符'.'表示任意一个字符，
 * 而'*'表示它前面的字符可以出现任意次（包含0次）。 在本题中，匹配是指字符串的所有
 * 字符匹配整个模式。例如，字符串"aaa"与模式"a.a"和"ab*ac*a"匹配，但是与"aa.a"
 * 和"ab*a"均不匹配
 * */

/*
 * 题解:
 *
 * */
public class 未完成_动态规划字符串_正则表达式匹配 {
    int[][] f;
    int m;
    int n;
    char[] p;
    char[] s;

    public boolean match(char[] str, char[] pattern) {
        p = pattern;
        s = str;
        n = s.length;
        m = p.length;
        f = new int[n+1][m+1];
        return dp(0, 0);
    }

    boolean dp(int x, int y) {
        if (f[x][y] != 0) return f[x][y] == 1;
        if (y == m){
            f[x][y] = x==n? 1:-1;
            return f[x][y] == 1;
        }
        boolean first_match = x<n &&(p[y] == '.' || s[x] == p[y]);
        if(y+1<m && p[y+1] == '*'){
            f[x][y] = dp(x,y+2)||dp(x+1,y)?1:-1;
        }
        else{
            f[x][y] = first_match && dp(x+1,y+1)?1:-1;
        }
        return f[x][y]==1;
    }

    public static void main(String[] args) {
        未完成_动态规划字符串_正则表达式匹配 a = new 未完成_动态规划字符串_正则表达式匹配();
        a.match("a".toCharArray(),"ab*a".toCharArray());
    }
}

/*题目描述
把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。
输入一个非减排序的数组的一个旋转，输出旋转数组的最小元素。
例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。
NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。*/
public class 查找和排序_旋转数组的最小数字 {
    /*链接：https://www.nowcoder.com/questionTerminal/9f3231a991af4f55b95579b44b7a01ba

旋转之后的数组实际上可以划分成两个有序的子数组（以最小元素为分界）：前面子数组的大小都大于后面子数组中的元素

本题目给出的数组一定程度上是排序的，因此我们试着用二分查找法寻找这个最小的元素。

思路：

（1）我们用两个指针left,right分别指向数组的第一个元素和最后一个元素。按照题目的旋转的规则，第一个元素应该是大于最后一个元素的（没有重复的元素）。

但是如果不是旋转，第一个元素肯定小于最后一个元素。旋转数组的最后一个元素在原递增数组中的后继就是旋转数组的第一个元素

（2）找到数组的中间元素。

中间元素大于第一个元素（说明中间元素处于前一个有序子数组的有序位置），则中间元素位于前面的递增子数组，此时最小元素应该位于中间元素的后面。我们可以让第一个指针left指向中间元素。

移动之后，第一个指针仍然位于前面的递增数组中。

中间元素小于第一个元素，说明中间元素位于后面的递增子数组，此时最小元素位于中间元素的前面。我们可以让第二个指针right指向中间元素。

移动之后，第二个指针仍然位于后面的递增数组中。



（3）按照以上思路，第一个指针left总是指向前面递增数组的元素，第二个指针right总是指向后面递增的数组元素。

最终第一个指针将指向前面数组的最后一个元素，第二个指针指向后面数组中的第一个元素。

也就是说他们将指向两个相邻的元素，而第二个指针指向的刚好是最小的元素，这就是循环的结束条件。*/
    public static int minNumberInRotateArray(int[] array) {
        int n = array.length - 1;
        if (n < 0) return -1;
        //将n指向旋转数组尾部元素，如果尾部有多个相等的元素，则指向其中第一个
//        如 {3，4，5，6，1，1，2，2}则n指向倒数第二个2
        while (n > 0 && array[n] == array[0]) n--;
        int l = 0;
        int r = n;
//        如果最后一个比第一个元素大，说明0到n就是有序的，最小的就是array[0]
        if(array[n]>=array[0]) return array[0];
//        接下来使用二分查找
        while (l < r) {
            int mid = l + ((r-l)>>1);//使用查找模板[l,mid], [mid+1, r]
            if(array[mid]<array[0])//如果array[mid]<array[0],则0和mid之间失序，mid属于右边有序数组，最小值出现在mid左边, 令 r = mid;
                r = mid;
            else//如果array[mid]>=array[0],则mid和0之间是有序数组，mid属于左边有序数组，最小值出现在mid右边, 令 l = mid+1;
                l = mid + 1;

        }
//        return array[l];
        return array[r];
    }

    public static void main(String[] args) {
        int[] a = {1,1,2,3,3,4,5,6,6,1,1};
        System.out.println(minNumberInRotateArray(a));
    }
}

/*
* 题目描述
用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。
* */
import java.util.Stack;
public class 栈和队列_两个栈实现队列 {
    Stack<Integer> stackIn = new Stack<>();
    Stack<Integer> stackOut = new Stack<>();

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

    public int pop() {
        /*如果第二个栈是空的，要把第一个栈里面所有的数倒进第二个栈里面*/
        /*但第二个栈一定要是空的才能从第一个栈里倒数进来，并且要将第一个栈的数全部倒进来*/
        if(stackOut.empty()){
            while (!stackIn.empty())
                stackOut.push(stackIn.pop());
        }
        return stackOut.pop();
    }
}

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

/*
*题解：
* 算法
(单调栈) O(1)O(1)
我们除了维护基本的栈结构之外，还需要维护一个单调栈，来实现返回最小值的操作。
下面介绍如何维护单调栈：

当我们向栈中压入一个数时，如果该数 ≤≤ 单调栈的栈顶元素，则将该数同时压入单调栈中；否则，不压入，这是由于栈具有先进后出性质，所以在该数被弹出之前，栈中一直存在一个数比该数小，所以该数一定不会被当做最小数输出。
当我们从栈中弹出一个数时，如果该数等于单调栈的栈顶元素，则同时将单调栈的栈顶元素弹出。
单调栈由于其具有单调性，所以它的栈顶元素，就是当前栈中的最小数。
时间复杂度
四种操作都只有常数次入栈出栈操作，所以时间复杂度都是 O(1)O(1).

https://www.acwing.com/solution/acwing/content/749/
* */

import java.util.Stack;

public class 栈和队列_包含min函数的栈 {
    Stack<Integer> stk = new Stack<>();
    Stack<Integer> min_stk = new Stack<>();

    public void push(int node) {
        if(min_stk.isEmpty()||min_stk.peek()>=node)
            min_stk.push(node);
        stk.push(node);
    }

    public void pop() {
        if(min_stk.peek() == stk.pop())
            min_stk.pop();
    }

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

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

import java.util.ArrayList;
import java.util.Deque;
import java.util.LinkedList;

/*
* 题目描述
给定一个数组和滑动窗口的大小，找出所有滑动窗口里数值的最大值。
例如，如果输入数组{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]}。
* */
/*
 * 时间复杂度， 每个元素只会进出窗口一次， 复杂度为O（N）*/
public class 栈和队列_滑动窗口的最大值 {
    static public ArrayList<Integer> maxInWindows(int[] num, int size) {
        ArrayList<Integer> res = new ArrayList<>();
        if (num.length == 0 || size == 0) {
//            do nothing
        } else {
//            q保存的是num中的下标，从双端队列q的左边弹出元素，从右边压入元素
//            保证存在q中的下标所对应在num里的元素是单调递减的，这样窗口中的最大值一直都是最左边的元素，也就是first元素
            Deque<Integer> q = new LinkedList<>();
            for (int i = 0; i < num.length; i++) {
//               用来控制窗口的大小始终为size, i是当前下标（窗口的右边下标）， q的first是窗口的左边下标，保证窗口左边 >= 窗口右边 - 窗口大小;
//               队列左边< i-size 的部分是过期的窗口，需要从队列中删除
                while (!q.isEmpty() && q.peekFirst() <= i - size)
                    q.pollFirst();//pullFirst取出的是队列左边的元素

//               从队列的右边压入元素， 压入的元素如果大于当前窗口右边的元素，则可以将窗口右边较小的元素删除（此时需要保证这个窗口的元素从左到右是单调递减的）
//               注意只有从窗口的右边进行比较删除操作才能使得窗口保持单调递减
                while (!q.isEmpty() && num[q.peekLast()] <= num[i])
                    q.pollLast();//pollLast取出的是队列右边，比新到的元素要小的元素
//                将新到的元素从队列右边压入
                q.offerLast(i);
//                当窗口的长度到达size长时开始输出元素。
                if (i >= size - 1)
                    res.add(num[q.peekFirst()]);//一直取队列的左边元素，因为队列从左往右是单调递减的，最左边就是最大的元素
            }
        }
        return res;
    }

    public static void main(String[] args) {
        int[] num = {2, 3, 4, 2, 6, 2, 5, 1};
        System.out.println(maxInWindows(num, 3));
    }
}

/*给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。
注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。*/
public class 树_二叉树的下一个节点 {
    public TreeLinkNode GetNext(TreeLinkNode pNode) {
//        第一种情况，只要当前节点有右子树，则在中序遍历的条件下，
//        当前节点的下一个节点是它右子树的最左边的节点
        if(pNode.right!=null){
            pNode = pNode.right;
//            找到右子树中最左边的节点
            while(pNode.left!=null)
                pNode = pNode.left;
            return pNode;
        }else{
//            如果当前节点没有右子树，则根据中序的顺序，当前节点的后继是其
//            这样的一个祖先，即本节点所在的子树是该祖先节点的左子树
            while(pNode.next!=null && pNode == pNode.next.right)//只要当前节点不是父节点的左孩子，则把指针移到父节点，往上找，直到找到满足pNode == pNode.next.left则找到了后继
                pNode = pNode.next;
//            返回的是pNode的父节点
            return pNode.next;
        }

    }
}

/*
*题目描述
请实现一个函数，
用来判断一颗二叉树是不是对称的。注意，
如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。
* */

/*
*题解:https://www.acwing.com/solution/acwing/content/747/
* (二叉树，递归) O(n)O(n)
递归判断两个子树是否互为镜像。

两个子树互为镜像当且仅当：

两个子树的根节点值相等；
第一棵子树的左子树和第二棵子树的右子树互为镜像，且第一棵子树的右子树和第二棵子树的左子树互为镜像；
时间复杂度
从上到下每个节点仅被遍历一遍，所以时间复杂度是 O(n)O(n)。

* */
public class 树_对称的二叉树 {
    boolean isSymmetrical(TreeNode pRoot)
    {
        if(pRoot == null)
            return true;
        else{
            return dfs(pRoot.left, pRoot.right);
        }
    }

    boolean dfs(TreeNode p1, TreeNode p2){
        if(p1==null||p2==null)
            return p1 == null && p2 ==null;
        if(p1.val!=p2.val) return false;
        return dfs(p1.left, p2.right) && dfs(p1.right,p2.left);
    }
}

//BiliBili大雪菜做法
//自测可以通过，牛客上不AC
public class 树_序列化二叉树 {
    static String Serialize(TreeNode root) {
        StringBuilder res = new StringBuilder();
        dfs_s(root, res);
        return res.toString();
    }

    static void dfs_s(TreeNode node, StringBuilder res) {
        if (node == null) {
            res.append("null ");
            return;
        }
        res.append(node.val + " ");
        dfs_s(node.left, res);
        dfs_s(node.right, res);
    }

    private static int u;

    static TreeNode Deserialize(String str) {
        u = 0;
        return dfs_d(str);
    }

    static TreeNode dfs_d(String str) {
        if (u == str.length()) return null;
        int k = u;
        while (str.charAt(k) != ' ') k++;
        if (str.charAt(u) == 'n') {
            u = k + 1;
            return null;
        }
        int val = 0;
        for (int i = u; i < k; i++)
            val = 10 * val + str.charAt(i) - '0';//0的ascii是48, 也可写作val = 10*val+str.charAt(i)-48
        u = k + 1;
        TreeNode root = new TreeNode(val);
        root.left = dfs_d(str);
        root.right = dfs_d(str);
        return root;
    }

    public static void main(String[] args) {
        TreeNode root = new TreeNode(1);
        root.left = new TreeNode(2);
        root.right = new TreeNode(3);
        root.left.left = new TreeNode(4);
        String s = Serialize(root);
        System.out.println(s);
        System.out.println(Serialize(Deserialize(s)));
    }
}

//来自https://www.nowcoder.com/questionTerminal/cf7e25aa97c04cc1a68c8f040e71fb84
//本题在牛课上AC
public class 树_序列化二叉树牛客论坛做法 {
    static String Serialize(TreeNode root) {
        StringBuilder res = new StringBuilder();
        if (root == null)
            return res.toString();
        else {
            dfs_s(root, res);
            return res.toString();
        }
    }

    static void dfs_s(TreeNode node, StringBuilder res) {
        if (node == null) {
            res.append("#,");
            return;
        } else {
            res.append(node.val + ",");
            dfs_s(node.left, res);
            dfs_s(node.right, res);
        }
    }

    static int index;
    static TreeNode Deserialize(String str){
        if(str.equals(""))
            return null;
        index = -1;
        String[] strr = str.split(",");
        return dfs_d(strr);
    }

    static TreeNode dfs_d(String[] strr){
        index++;
        TreeNode node = null;
        if(!strr[index].equals("#")){
            node = new TreeNode(Integer.valueOf(strr[index]));
            node.left = dfs_d(strr);
            node.right = dfs_d(strr);
        }
        return node;
    }
}

/*
* 题目描述
从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行。
* */

import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedList;
import java.util.Queue;

/*
*题解:
* 每次遍历到该层最后一个位置的时候人为的添加一个null节点来标记下一层的所有节点都已经添加进队列
* 取出的时候如果碰到null节点就做分行处理
* */
public class 树_把二叉树打印成多行 {
    public static ArrayList<ArrayList<Integer> > Print(TreeNode pRoot) {
        ArrayList<ArrayList<Integer>> res = new ArrayList<>();
        ArrayList<Integer> arr = new ArrayList<>();
        Queue<TreeNode> queue = new LinkedList<>();

        queue.offer(pRoot);
        queue.offer(null);
        while(!queue.isEmpty()){
            TreeNode tmp = queue.poll();
            if(tmp == null){
                if(arr.isEmpty()) break;
                //res.add(arr)这样是错误的! 后面arr会变！
                res.add(new ArrayList<>(arr));
                arr.clear();
                queue.offer(null);
            }else{
                arr.add(tmp.val);
                if(tmp.left != null)
                    queue.offer(tmp.left);
                if(tmp.right != null)
                    queue.offer(tmp.right);
            }
        }
        return res;
    }

    public static void main(String[] args) {
        TreeNode head = new TreeNode(8);
        head.left = new TreeNode(6);
        head.right = new TreeNode(10);
        head.left.left = new TreeNode(5);
        head.left.right = new TreeNode(7);
        head.right.left = new TreeNode(9);
        head.right.right = new TreeNode(11);
        ArrayList<ArrayList<Integer>> res =Print(head);
        System.out.println();
    }
}

/*
* 题目描述
请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，
第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。
* */

import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedList;
import java.util.Queue;

/*
*题解:
* 本题与 树_把二叉树打印成多行 十分类似
* 只要在每层的时候判断一下是否对该层结果逆序放到最终的结果中去
* */
public class 树_按之字形顺序打印二叉树 {
    public static ArrayList<ArrayList<Integer>> Print(TreeNode pRoot) {
        ArrayList<ArrayList<Integer>> res = new ArrayList<>();
        ArrayList<Integer> arr = new ArrayList<>();
        Queue<TreeNode> queue = new LinkedList<>();

        queue.offer(pRoot);
        queue.offer(null);
        boolean zigzag = false;
        while(!queue.isEmpty()){
            TreeNode tmp = queue.poll();
            if(tmp == null){
                if(arr.isEmpty()) break;
                //res.add(arr)这样是错误的! 后面arr会变！
                if(zigzag)
                    Collections.reverse(arr);
                res.add(new ArrayList<>(arr));
                arr.clear();
                queue.offer(null);
                zigzag = !zigzag;
            }else{
                arr.add(tmp.val);
                if(tmp.left != null)
                    queue.offer(tmp.left);
                if(tmp.right != null)
                    queue.offer(tmp.right);
            }
        }
        return res;
    }
}

/*
 * 输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。
 * 假设输入的前序遍历和中序遍历的结果中都不含重复的数字。
 * 例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，
 * 则重建二叉树并返回。二叉树重建的结果是按层序遍历返回的数组。
 * */

import java.util.HashMap;
import java.util.Map;

/*
 * 1. 从前序中得到根节点1， 在中序中找到1所在的位置，1 的左边{4，7，2}是左子树的中序， 1的右边{5，3，8，6}是右子树中序
 * 2. 在中序中得到左子树的长度为3，右子树长度为4， 所以在前序中可以得到左子树的前序是{2，4，7}， 右子树前序是{3，5，6，8}
 * 3. 有了左子树的前序和中序，可以重复上面的步骤1和步骤2的过程； 同理有了右子树的前序和中序，也可以递归上述过程；
 * */
public class 树_重建二叉树 {
    Map<Integer, Integer> hash = new HashMap<>();
    int[] pre, in;

    public TreeNode reConstructBinaryTree(int[] _pre, int[] _in) {
        pre = _pre;
        in = _in;

        for (int i = 0; i < pre.length; i++)
            hash.put(in[i], i);
        return dfs(0, pre.length - 1, 0, in.length - 1);
    }

    public TreeNode dfs(int pl, int pr, int il, int ir) {
        if (pl > pr)
            return null;
        else {
            TreeNode root = new TreeNode(pre[pl]);
//            int position = hash.get(pre[pl]);
            int positon = hash.get(root.val);
//            dfs（子树在前序数组中的左边界，子树在前序数组的右边界（=左边界+子树长度，长度可由中序数组推出），子树在中序数组中的左边界，子树在中序数组的右边界（=左边界+左子树长度，长度可由中序数组推出））
            TreeNode left = dfs(pl+1, pl+positon-il, il, positon-1);
            TreeNode right = dfs(pl+positon-il+1,pr, positon+1,il);
            root.left = left;
            root.right = right;
            return root;
        }
    }
}

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

/*
题解:
见 树_链表_二叉搜索树与双向链表.png
* */
public class 树_链表_二叉搜索树与双向链表 {
    public TreeNode Convert(TreeNode pRootOfTree) {
        if (pRootOfTree == null)
            return null;
        TreeNode[] sides = dfs(pRootOfTree);
        return sides[0];
    }

    TreeNode[] dfs(TreeNode root) {
        TreeNode[] res = {};
        if (root.left == null && root.right == null)
            res = new TreeNode[]{root, root};
        if (root.left != null && root.right != null) {
            TreeNode[] lsides = dfs(root.left);
            TreeNode[] rsides = dfs(root.right);
            lsides[1].right = root;
            root.left = lsides[1];
            rsides[0].left = root;
            root.right = rsides[0];
            res = new TreeNode[]{lsides[0], rsides[1]};
        }
        if (root.right == null && root.left != null) {
            TreeNode[] lsides = dfs(root.left);
            lsides[1].right = root;
            root.left = lsides[1];
            res = new TreeNode[]{lsides[0], root};
        }
        if (root.left == null && root.right != null) {
            TreeNode[] rsides = dfs(root.right);
            rsides[0].left = root;
            root.right = rsides[0];
            res = new TreeNode[]{root, rsides[1]};
        }
        return res;
    }
}

/*
*题目描述
从上往下打印出二叉树的每个节点，同层节点从左至右打印。
* */

/*
*宽搜
* */

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;

public class 模拟_上往下打印二叉树 {
    public ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {
        ArrayList<Integer> res = new ArrayList<>();
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()){
            TreeNode tmp = queue.poll();
            if(tmp!=null){
                res.add(tmp.val);
                queue.offer(tmp.left);
                queue.offer(tmp.right);
            }
        }
        return res;
    }
}

/*
* 题目描述
输入两个整数序列，第一个序列表示栈的压入顺序，
请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。
例如序列1,2,3,4,5是某栈的压入顺序，序列4,5,3,2,1是该压栈序列对应的
一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（
注意：这两个序列的长度是相等的）
* */

import java.util.Stack;

/*
*题解:
* (栈) O(n)O(n)
用一个新栈s来模拟实时进出栈操作：

在for loop里依次喂数，每push一个数字就检查有没有能pop出来的。

如果最后s为空（或者popId==popV.size())，说明一进一出刚刚好。

时间复杂度分析：一共push n次，pop n次。

* */
public class 模拟_栈的压入弹出序列 {
    public boolean IsPopOrder(int [] pushA,int [] popA) {
        if(pushA.length!=popA.length) return false;

        Stack<Integer> stk = new Stack<>();
        int j = 0;
        for(int i = 0; i<pushA.length;i++){
            stk.push(pushA[i]);
            while(!stk.isEmpty()){
                if(stk.peek() == popA[j]){
                    stk.pop();
                    j++;
                }else{
                    break;
                }
            }
        }
        return stk.isEmpty();
    }

}

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

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

/*
 * 题解:
 *
 * 与
 *循环和递归_二叉树中和为某一值的路径
 * 类似
 *
 * 这里我们如何保证在有相同的字符的情况下，如何保证排列的结果是不重复不遗漏的呢？
 * 根据要排列的字符串的长度，新建一个等长的字符数组path来记录排列的路径；
 * 然后把字符串分解成字符数组arr，并对其排列，使得相同的字符都在一起;
 * 我们从头开始遍历这个字符数组arr，每次把一个字符放到路径path中的一个位置，用来保证不重不漏的规则是:
 * 1.如果当前从arr中取出的字符是唯一的，则在path中从头开始寻找一个空的位置放入该字符；
 * 2. 如果当前从arr中取出的字符与上一个从arr中取出的字符相同，则在path数组中，从上一个字符放入的位置往后开始，
 * 寻找一个空的位置放入
 *当所有字符被放入，则构成一个合法的排列；
 * 并且以上规则保证排列不会重复；
 *
 * */
public class 递归_分类_字符串的排列 {
    ArrayList<String> ans = new ArrayList<>();//存贮符合要求的排列
    char[] path;//存储每个遍历的路径

    public ArrayList<String> Permutation(String str) {
        path = new char[str.length()];//path的长度等于字符串的长度
        char[] arr = str.toCharArray();
        Arrays.sort(arr);
        dfs(arr, 0, 0, 0);
        Collections.sort(ans);//对答案按字典顺序排序
        return ans;
    }

    //u是当前需要放入path的字符在arr中的位置
    //start是上一个被放入path中字符在path中的位置
    //state表示path中位置被占用的情况，用它的二进制形式来表示，如5 的二进制是101则表示
    void dfs(char[] arr, int u, int start, int state) {
        if (u == arr.length) {
            //如果u达到了字符数组的末尾，说明找到了一条符合要求的路径，将其放入结果集中
            ans.add(new String(path));
            return;
        }
        if (u == 0 || arr[u] != arr[u - 1])//如果u==0（刚开始遍历），或者当前要放入的字符和上一个已经放入path的字符相等
            //则把start置为0，意思是当前字符可以放到任意位置（也就是从头寻找一个空位置放入）
            start = 0;
        for (int i = start; i < arr.length; i++) {//开始放入
            if((state>>i & 1)==0){//用state来记录path数组中被放入的情况，state >> i & 1用来检查state的第i位是否为1，如果为1表示path的第i位已经被占据
                path[i] = arr[u];//将arr中的第u个数放入path路径中
                dfs(arr,u+1,i+1,state+(1<<i)); //state + (1<<i)表示将state的第i位置1
            }
        }
    }
}

/*
 * 输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。*/
import java.util.ArrayList;
import java.util.Stack;

public class 链表_从尾到头打印链表 {
//    非递归做法
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        Stack<Integer> tmp = new Stack<>();
        while(listNode!=null){
            tmp.push(listNode.val);
            listNode = listNode.next;
        }
        ArrayList<Integer> res = new ArrayList<>();
        while (!tmp.empty())
            res.add(tmp.pop());
        return res;
    }

//    递归做法
public ArrayList<Integer> printListFromTailToHead1(ListNode listNode) {
    ArrayList<Integer> re = new ArrayList<>();
    if(listNode==null)
        return re;
    else{
        printListRev(listNode, re);
        return re;
    }
}

    public void printListRev(ListNode l, ArrayList re){
        if(l==null)
            return;
        else{
            printListRev(l.next, re);
            re.add(l.val);
        }
    }
}

/*
 * 在一个排序的链表中，存在重复的结点，
 * 请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。
 * 例如，链表1->2->3->3->4->4->5 处理后为 1->2->5
 * */
public class 链表_删除链表中重复的结点 {
    public ListNode deleteDuplication(ListNode pHead) {
//        设置一个虚拟节点,用来处理头节点有可能被删除的情况.
//        这个节点的值随便,因为在后面的匹配中,我们并不涉及到这个头节点的值.返回的头节点时候记得返回的是虚拟节点的next
        ListNode dumy = new ListNode(-1);
        dumy.next = pHead;

        ListNode p = dumy;//p一开始室指向虚拟节点不是头节点！
        /*每次考察,将q指向p后面一个节点*/
        while (p.next != null) {
            ListNode q = p.next;
//            如果q存在且p的下一个节点的值和q节点的值相等，说明遇到了重复节点, 就将p往后移动一个节点考察下一个节点
//            用图示模拟一下就懂了:
//            V 1 2 2 3 3
//            p q
//            * p q
            while (q!=null && p.next.val == q.val) q = q.next;
//            如果p的下下个节点是q,说明q从p的下个节点往后只移动了一次,变成了下下个节点,说明从p的下一个位置开始没有重复的元素, p往后移动移位考察下个位置
            if (p.next.next == q)
                p = p.next;
//            只要q的位置不在p的下下个位置,说明q移动了超过了一次,说明遇到了相同的元素,将p的next指针指向q,跳过中间所有相同的元素.
            else
                p.next = q;
        }
        return dumy.next;
    }

//    思考,本题是去除所有重复的元素,也就是说如果一个元素有超过了两个,则把他们全部删除;
//    如果要保留至少一个元素应该怎么处理?
//    双指针,如果第二个指针的值等于第一个指针,第一个的next直接指向第二个指针的next,第二个指针指向第一个指针的next.next
//    ListNode dumy = new ListNode(-1);
//    ListNode p1 = dumy;
//    while(p1.next!=null){
//        ListNode p2 = p1.next;
//          if(p2!=null && p1.val == p2.val){
//              p1.next = p2.next;
//          }
//    }
//    return dumy.next;
}

/*题目：https://www.acwing.com/problem/content/85/
* 给定单向链表的一个节点指针，定义一个函数在O(1)时间删除该结点。

假设链表一定存在，并且该节点一定不是尾节点。

样例
输入：链表 1->4->6->8
      删掉节点：第2个节点即6（头节点为第0个节点）

输出：新链表 1->4->8
* */

/*
* 题解：
* 将链表的下一个节点的值赋给当前节点，然后跳过当前节点的下一个节点
* 将下一个节点复制到当前节点的位置取代当前节点，然后删除掉下一个节点；这样相当于删除了本节点。
* */
public class 链表_在O1时间删除链表结点 {
    public void deleteNode(ListNode node) {
        node.val = node.next.val;
        node.next = node.next.next;
    }
}

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

/*
 * 题解
 * 见 链表_复杂链表的复制.png
 * */
public class 链表_复杂链表的复制 {
    public RandomListNode Clone(RandomListNode pHead) {
//        第一步，复制链表中的每个节点，并将其插入到该节点和其后面节点之间
        for(RandomListNode p = pHead; p!=null;){
            RandomListNode np = new RandomListNode(p.label);
            RandomListNode next = p.next;
            np.next = next;
            p.next = np;
            p = next;
        }

//        第二步，依据主链表在副链表上连接相应的random指针
        for(RandomListNode p = pHead;p!=null;p = p.next.next){
            if(p.random!=null)
                p.next.random = p.random.next;
        }

//        第三步,将副链表从主链表上拆下来，串成新链表，并将主链表还原
//        为副链表做一个虚拟头节点
        RandomListNode dummy = new RandomListNode(-1);
        RandomListNode cur = dummy;
        for(RandomListNode p = pHead;p!=null;){
            cur.next=p.next;
            cur = cur.next;
            p.next = cur.next;//将主链表重新连接
            p = p.next;
        }
        return dummy.next;
    }
}

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

    RandomListNode(int label) {
        this.label = label;
    }
}

/*
* 题目描述
给一个链表，若其中包含环，
请找出该链表的环的入口结点，否则，输出null。
* */

import java.util.HashSet;


public class 链表_链表中环的入口结点 {
    /*
     * 题解1:见 链表_链表中环的入口节点.JPG
     * */
    public ListNode EntryNodeOfLoop1(ListNode pHead) {
        ListNode i = pHead;
        ListNode j = pHead;
        while (i != null && j != null) {
            i = i.next;
            j = j.next;
            if (j != null)
                j = j.next;
            else
                return null;
            if (i == j) {
                i = pHead;
                while (i != j) {
                    i = i.next;
                    j = j.next;
                }
                return i;
            }
        }
        return null;
    }
    /*
     * 题解2:用set依次保存节点，主要依据set不能存储重复元素的性质
     * */
    public ListNode EntryNodeOfLoop(ListNode pHead){
        HashSet<ListNode> res = new HashSet<>();
        while(pHead!=null){
            if(res.add(pHead))
                pHead = pHead.next;
            else
                return pHead;
        }
        return null;
    }
}

 

/*题目描述
把只包含质因子2、3和5的数称作丑数（Ugly Number）。例如6、8都是丑数，但14不是，
因为它包含质因子7。 习惯上我们把1当做是第一个丑数。求按从小到大的顺序的第N个丑数。*/

/*思路是，所有的丑数都是由之前的数乘2，或者乘3，或者乘5得来的。
* 我们用i2, i3, i5分别表示前面序列中下一个将要乘2的位置、下一个将要乘3的位置和
* 下一个将要乘5的位置。每次用这 三个数乘以各自因子得到的结果中找出最小的那个数添加到丑数序列中，
* 并更新对这个丑数做出贡献的乘子的下标i2或i3或i5*/
import java.util.*;

public class 搜索_丑数 {
    public static int GetUglyNumber_Solution(int index) {
        List<Integer> res = new ArrayList<>();
        int i2 = 0, i3 = 0, i5 = 0;
        res.add(1);
        int r2, r3, r5, min;
        while (res.size() < index) {
            r2 = res.get(i2) * 2;
            r3 = res.get(i3) * 3;
            r5 = res.get(i5) * 5;

            min = Math.min(r2, Math.min(r3, r5));
            res.add(min);
            //不可写作：
/*           if (min == r2) i2++;
            else if (min == r3) i3++;
            else if (min == r5) i5++;*/
           //因为当有可能出现同时min == r2, min == r3, 此时要同时更新r2,r3

            if (min == r2) i2++;
            if (min == r3) i3++;
            if (min == r5) i5++;
        }
        return res.get(index - 1);
    }

    public static void main(String[] args) {
        GetUglyNumber_Solution(7);
    }
}

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

/*第一次遍历用map记录下来所有字符出现的次数，最终再从头遍历一遍字符串，在map中查看依次查看每个字符出现的次数
，第一次为1的即为答案。时间复杂度为O(n)*/
import java.util.*;
public class 搜索_第一个只出现一次的字符 {
    public int FirstNotRepeatingChar(String str) {
        char[] arr = str.toCharArray();
        Map<Character, Integer> map = new HashMap<>();
        for (char c : arr) {
            if (map.containsKey(c))
                map.put(c, map.get(c) + 1);
            else
                map.put(c, 1);
        }
        int res = 0;
        int i = 0;
        for (i = 0; i < arr.length; i++) {
            if (map.get(arr[i]) == 1) {
                res = i;
                break;
            }
        }
        return i == arr.length ? -1 : res;
    }

    /*可以用数组来节约空间*/
    /*
    * 利用每个字母的ASCII码作hash来作为数组的index。首先用一个58长度的数组来存储每个字母出现
    * 的次数，为什么是58呢，主要是由于A-Z对应的ASCII码为65-90，a-z对应的ASCII码值为97-122，
    * 而每个字母的index=int(word)-65，比如g=103-65=38，而数组中具体记录的内容是该字母出现
    * 的次数，最终遍历一遍字符串，找出第一个数组内容为1的字母就可以了，时间复杂度为O(n)*/

    public static int solution2(String str){
        int[] words = new int[58];
        for(int i = 0;i<str.length();i++){
            words[((int)str.charAt(i))-65] += 1;
        }
        for(int i=0;i<str.length();i++){
            if(words[((int)str.charAt(i))-65]==1)
                return i;
        }
        return -1;
    }
}

/*题目描述
在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,
求出这个数组中的逆序对的总数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 class 搜索_数组中的逆序对 {
    static int count = 0;

    public static int InversePairs(int [] array) {
        if(array == null || array.length == 0)
            return 0;
        sortProcess(array,0,array.length-1);

        return count%1000000007;
    }

    private static void sortProcess(int[] arr, int L, int R){
        if(L == R)
            return;
        else{
            int mid = L + ((R-L)>>1);
            sortProcess(arr,L,mid);
            sortProcess(arr,mid+1,R);
            merge(arr,L,mid,R);
        }
    }

    private static void merge(int[] arr, int l, int mid, int r){
        int[] help =  new int[r-l+1];
        int i = r-l;
        int p1 = mid;
        int p2 = r;

        while (p1>=l && p2>=mid+1){
            if(arr[p1]>arr[p2]){
                help[i--] = arr[p1--];
                count += p2-(mid+1)+1;
            }else{
                help[i--] = arr[p2--];
            }
        }
        while(p1>=l){
            help[i--] = arr[p1--];
        }
        while(p2>=mid+1)
            help[i--] = arr[p2--];

        i = 0;
        while (l<=r)
            arr[l++] = help[i++];
    }

    public static void main(String[] args) {
        int[] a = {1,2,3,4,5,6,7,0};
        System.out.println(InversePairs(a));
        System.out.println();
    }

    //可以通过的代码
    public class Solution {
        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;

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

/*题目描述
输入两个链表，找出它们的第一个公共结点。*/
import java.util.*;
public class 链表_两个链表的第一个公共节点 {
    //思路1，把两个链表往set里面放，第一个放不进去的节点即为交点。空间复杂度为O(m+n)
        public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
            Set<ListNode> set = new HashSet<>();
            while(pHead1!=null){
                set.add(pHead1);
                pHead1 = pHead1.next;
            }
            while(pHead2!=null){
                if(!set.add(pHead2))
                    return pHead2;
                pHead2 = pHead2.next;
            }
            return null;
        }

        /*思路2：分别把两个链表的节点放入两个栈里，这样两个链表的尾节点就位于两个栈的栈顶，
        接下来比较两个栈顶的节点是否相同。如果相同，则把栈顶弹出接着比较下一个栈顶，直到找
        到最后一个相同的节点。
        在上述思路中，我们需要用两个辅助栈。如果链表的长度分别为m和n，那么空间复杂度是O（m+n）。
        这种思路的时间复杂度也是O（m+n）。和最开始的蛮力法相比，时间效率得到了提高，相当于用
        空间消耗换取了时间效率。
*/

        //不需要格外空间的解法
        /*思路3：之所以需要用到栈，是因为我们想同时遍历到达两个栈的尾节点。当两个链表的长度不相同时，
        如果我们从头开始遍历，那么到达尾节点的时间就不一致。其实解决这个问题还有一种更简单的办
        法：首先遍历两个链表得到它们的长度，就能知道哪个链表比较长，以及长的链表比短的链表多几
        个节点。在第二次遍历的时候，在较长的链表上先走若干步，接着同时在两个链表上遍历，找到的
        第一个相同的节点就是它们的第一个公共节点。*/

        /*思路4:
        * 把这个题化为找环的入口，从前往后遍历两个链表并比较，遇到链表末尾了将其指向另一个链表的开头，这样
         * 就类似于找环的入口*/
        public ListNode FindFirstCommonNode2(ListNode pHead1, ListNode pHead2) {
            ListNode p1 = pHead1;
            ListNode p2 = pHead2;
            while (p1!=p2){
                p1 = (p1==null?pHead2:p1.next);
                p2 = (p2==null?pHead1:p2.next);
            }
            return p1;
        }

}

/*题目描述
统计一个数字在排序数组中出现的次数。*/

/*两次二分分别找左右边界*/

/*二分法找左右边界*/
public class 二分查找_数字在排序数组中出现的次数 {
    public static int GetNumberOfK(int [] array , int k) {
        if(array == null || array.length == 0)
            return 0;
        //二分查找模板找左边界
//        模板1: 将区间[l, r]划分成[l, mid]和[mid + 1, r]时，其更新操作是r = mid或者l = mid + 1;，计算mid时不需要加1。
        int l = 0, r = array.length-1;
        while(l<r){
            int mid = l + ((r-l)>>1);
            if(array[mid] >= k)
                r = mid;
            else
                l = mid + 1;
        }
        int left = l;

        l = 0;
        r = array.length-1;

        //二分查找模板找右边界
//        模板2：将区间[l, r]划分成[l, mid - 1]和[mid, r]时，其更新操作是r = mid - 1或者l = mid;，此时为了防止死循环，计算mid时需要加1。
        /*两个模板的记忆：
        * 1.必定有一个mid,要么在左区间要么在右区间
        * 2.更新时mid的值交叉等于，
        * [l,mid],[mid+1,r]时更新时r = mid; [l,mid-1],[mid,r]时更新时l = mid
        * 3. 更新mid时看区间中有没有mid+1, 没有的时候更新时要加1*/
        while(l<r){
            int mid = l + ((r-l)>>1)+1;
            if(array[mid] <= k)
                l = mid;
            else
                r = mid-1;
        }

        int right = l;

        if(array[right]==k)
            return right-left+1;
        else
            return 0;

    }

    public static void main(String[] args) {
        int[] a = {3,3,3,3,4,7};
        System.out.println(GetNumberOfK(a,3));
    }
}

/*题目描述
输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，
最长路径的长度为树的深度。*/

/*思路
* 我们还可以从另外一个角度来理解树的深度。如果一棵树只有一个节点，那么它的深度为1。如果根节点
* 只有左子树而没有右子树，那么树的深度应该是其左子树的深度加1；同样，如果根节点只有右子树而没
* 有左子树，那么树的深度应该是其右子树的深度加1。如果既有右子树又有左子树，那么该树的深度就是
* 其左、右子树深度的较大值再加1。比如，在图6.2所示的二叉树中，根节点为1的树有左、右两棵子树，
* 其左、右子树的根节点分别为节点2和节点3。根节点为2的左子树的深度为3，而根节点为3的右子树的
* 深度为2，因此，根节点为1的树的深度就是4。
这种思路用递归的方法很容易实现，只需对遍历的代码稍作修改即可。*/
public class 二叉树的深度 {
    public int TreeDepth(TreeNode root) {
        if(root == null)
            return 0;
        int nLeft = TreeDepth(root.left);
        int nRight = TreeDepth(root.right);
        return (nLeft>nRight)?(nLeft+1):(nRight+1);
    }
}

/*题目描述
输入一棵二叉树，判断该二叉树是否是平衡二叉树。*/
public class 平衡二叉树 {
    /*有了求二叉树的深度的经验之后再解决这个问题，我们很容易就能想到一种思路：在遍历树的每个节点的时候，
    调用函数TreeDepth得到它的左、右子树的深度。如果每个节点的左、右子树的深度相差都不超过1，那么按照
    定义它就是一棵平衡二叉树。这种思路对应的代码如下：*/

    /*上面的代码固然简洁，但我们也要注意到由于一个节点会被重复遍历多次，这种思路的时间效率不高。例如，
    在函数IsBalance中输入图6.2中的二叉树，我们将首先判断根节点（节点1）是不是平衡的。此时我们往函
    数TreeDepth里输入左子树的根节点（节点2）时，需要遍历节点4、5、7。
     接下来判断以节点2为根节点的子树是不是平衡树的时候，仍然会遍历节点4、5、7。毫无疑问，重复遍历
     同一个节点会影响性能。*/
    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);
    }

    int TreeDepth(TreeNode root){
        if(root == null)
            return 0;
        int nLeft = TreeDepth(root.left);
        int nRight = TreeDepth(root.right);

        return nLeft>nRight?++nLeft:++nRight;
    }

    /*上面的代码固然简洁，但我们也要注意到由于一个节点会被重复遍历多次，这种思路的时间效率不高。例如，
    在函数IsBalance中输入图6.2中的二叉树，我们将首先判断根节点（节点1）是不是平衡的。此时我们往函
    数TreeDepth里输入左子树的根节点（节点2）时，需要遍历节点4、5、7。
     接下来判断以节点2为根节点的子树是不是平衡树的时候，仍然会遍历节点4、5、7。毫无疑问，重复遍历
     同一个节点会影响性能。*/

    /*思路2：如果我们用后序遍历的方式遍历二叉树的每个节点，那么在遍历到一个节点之前我们就已经遍历
    了它的左、右子树。只要在遍历每个节点的时候记录它的深度（某一节点的深度等于它到叶节点的路径的长
    度），我们就可以一边遍历一边判断每个节点是不是平衡的。

    如果改为从下往上遍历，如果子树是平衡二叉树，则返回子树的高度；如果发现子树不是平衡二叉树，则直
    接停止遍历，这样至多只对每个结点访问一次。
    下面是这种思路的参考代码：*/
    public boolean IsBalanced_Solution2(TreeNode root) {
        return getDepth(root) != -1;
    }

    private int getDepth(TreeNode root) {
        if (root == null) return 0;
        int left = getDepth(root.left);
        if (left == -1) return -1;
        int right = getDepth(root.right);
        if (right == -1) return -1;
        return Math.abs(left - right) > 1 ? -1 : 1 + Math.max(left, right);
    }
}

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

/*思路:
*我们还是从头到尾依次异或数组中的每个数字，那么最终得到的结果就是两个只出现一次的数字的异或结果，
* 因为其他数字都出现了两次，在异或中全部抵消了。由于这两个数字肯定不一样，那么异或的结果肯定不为0，
* 也就是说，在这个结果数字的二进制表示中至少有一位为1。我们在结果数字中找到第一个为1的位的位置，
* 记为第n位。现在我们以第n位是不是1为标准把原数组中的数字分成两个子数组，第一个子数组中每个数字
* 的第n位都是1，而第二个子数组中每个数字的第n位都是0。由于我们分组的标准是数字中的某一位是1还是0，
* 那么出现了两次的数字肯定被分配到同一个子数组。因为两个相同的数字的任意一位都是相同的，我们不可
* 能把两个相同的数字分配到两个子数组中去，于是我们已经把原数组分成了两个子数组，每个子数组都包含
* 一个只出现一次的数字，而其他数字都出现了两次。我们已经知道如何在数组中找出唯一一个只出现一次的
* 数字，因此，到此为止所有的问题都已经解决了。
举个例子，假设输入数组{2，4，3，6，3，2，5，5}。当我们依次对数组中的每个数字进行异或运算之后，
得到的结果用二进制表示是0010。异或得到的结果中的倒数第二位是1，于是我们根据数字的倒数第二位是
不是1将该数组分为两个子数组。第一个子数组；2，3，6，3，2}中所有数字的倒数第二位都是1，而第二个
子数组4，5，5}中所有数字的倒数第二位都是0。接下来只要分别对这两个子数组求异或，就能找出第一个
子数组中只出现一次的数字是6，而第二个子数组中只出现一次的数字是4。 */


//num1,num2分别为长度为1的数组。传出参数
//将num1[0],num2[0]设置为返回结果
public class 数组中只出现一次的数字 {
    public void FindNumsAppearOnce(int [] array,int num1[] , int num2[]) {
        if(array == null || array.length == 0)
            return;
        int xor = 0;
        for(int i: array)
            xor ^= i;
        int index = findFirstBitsIs1(xor);
        num1[0] = 0;
        num2[0] = 0;
        for(int i:array){
            if(IsBit1(i,index))
                num1[0] ^= i;
            else
                num2[0] ^= i;
        }
    }
//寻找第一个为1的位的index
    int findFirstBitsIs1(int num){
        int index = 0;
        while((num&1)!=1 && index < 32){
            num = num >>1;
            index++;
        }
        return index;
    }

    boolean IsBit1(int num, int index){
        return ((num>>index)&1) == 1;
    }

    /*扩展题目二：数组中唯一只出现一次的数字。
在一个数组中除一个数字只出现一次之外，其他数字都出现了三次。
请找出那个只出现一次的数字。
如果我们把题目稍微改一改，那么就会容易很多：如果数组中的数字除一个只出现一次之外，其他数字都出现了两次。
我们可以用XOR异或位运算解决这个简化的问题。由于两个相同的数字的异或结果是0，我们把数组中所有数字异或的
结果就是那个唯一只出现一次的数字。
可惜这种思路不能解决这里的问题，因为三个相同的数字的异或结果还是该数字。尽管我们这里不能应用异或运算，
我们还是可以沿用位运算的思路。如果一个数字出现三次，那么它的二进制表示的每一位（0或者1）也出现三次。
如果把所有出现三次的数字的二进制表示的每一位都分别加起来，那么每一位的和都能被3整除。
我们把数组中所有数字的二进制表示的每一位都加起来。如果某一位的和能被3整除，那么那个只出现一次的数字
二进制表示中对应的那一位是0；否则就是1。*/

}

/*题目描述
输入一个递增排序的数组和一个数字S，在数组中查找两个数，使得他们的和正好是S，如果有多对数字的和等于S，输出两个数的乘积最小的。
输出描述:
对应每个测试案例，输出两个数，小的先输出。*/

/*双指针*/
import java.util.*;
public class 和为S的两个数 {
    public ArrayList<Integer> FindNumbersWithSum(int [] array,int sum) {
        ArrayList<Integer> res = new ArrayList<>();
        if(array == null || array.length<2)
            return res;
        int l = 0, r = array.length-1;
        while(l<r){
            if(array[l] + array[r] == sum){
                res.add(array[l]);
                res.add(array[r]);
                return res;
            }
            else if(array[l]+array[r]<sum)
                l++;
            else
                r--;
        }
        return res;
    }
}

/*题目描述
小明很喜欢数学,有一天他在做数学作业时,要求计算出9~16的和,他马上就写出了正确答案是100。
但是他并不满足于此,他在想究竟有多少种连续的正数序列的和为100(至少包括两个数)。没多久,
他就得到另一组连续正数和为100的序列:18,19,20,21,22。现在把问题交给你,你能不能也很
快的找出所有和为S的连续正数序列? Good Luck!

输出描述:
输出所有和为S的连续正数序列。序列内按照从小至大的顺序，序列间按照开始数字从小到大的顺序*/



/*
* 题解:
* 以求和为9的所有连续序列为例，我们先把small初始化为1，big初始化为2。此时介于small和big
* 之间的序列是{1，2}，序列的和为3，小于9，所以我们下一步要让序列包含更多的数字。我们把big
* 增加1变成3，此时序列为{1，2，3}。由于序列的和是6，仍然小于9，我们接下来再增加big变成4，
* 介于small和big之间的序列也随之变成{1，2，3，4}。由于序列的和10大于9，我们要删去序列中
* 的一些数字，于是我们增加small变成2，此时得到的序列是（2，3，4}，序列的和正好是9。我们找
* 到了第一个和为9的连续序列，把它打印出来。接下来我们再增加big，重复前面的过程，可以找到第
* 二个和为9的连续序列{4，5}。
* */
import java.util.*;
public class 和为S的连续正数序列 {
    public ArrayList<ArrayList<Integer> > FindContinuousSequence(int sum) {
        //存放结果
        ArrayList<ArrayList<Integer> > result = new ArrayList<>();
        //两个起点，相当于动态窗口的两边，根据其窗口内的值的和来确定窗口的位置和大小
        int plow = 1,phigh = 2;
        while(phigh > plow){
            //由于是连续的，差为1的一个序列，那么求和公式是(a0+an)*n/2
            int cur = (phigh + plow) * (phigh - plow + 1) / 2;
            //相等，那么就将窗口范围的所有数添加进结果集
            if(cur == sum){
                ArrayList<Integer> list = new ArrayList<>();
                for(int i=plow;i<=phigh;i++){
                    list.add(i);
                }
                result.add(list);
                plow++;
                //如果当前窗口内的值之和小于sum，那么右边窗口右移一下
            }else if(cur < sum){
                phigh++;
            }else{
                //如果当前窗口内的值之和大于sum，那么左边窗口右移一下
                plow++;
            }
        }
        return result;
    }
}

/*
* 题目二：左旋转字符串。
字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。
比如，输入字符串"abcdefg"和数字2，该函数将返回左旋转两位得到的结果"cdefgab"。*/

/*我们可以从翻转字符串的思路中找到启发？在该问题中，如果输入的字符串之中只有两个单词，比如“hello world"，
那么翻转这个句子中的单词顺序就得到了“world hello”。比较这两个字符串，我们是不是可以把"world hello”看
成把原始字符串"hello world”的前面若干个字符转移到后面？也就是说这两个问题是非常相似的，我们同样可以通过
翻转字符串的办法来解决第二个问题。
以“abcdefg”为例，我们可以把它分为两部分。由于想把它的前两个字符移到后面，我们就把前两个字符分到第一部分，
把后面的所有字符分到第二部分。我们先分别翻转这两部分，于是就得到“bagfedc”。接下来翻转整个字符串，得到的
"cdefgab”刚好就是把原始字符串左旋转两位的结果。
通过前面的分析，我们发现只需要调用3次前面的Reverse函数就可以实现字符串的左旋转功能。
*/
public class 左旋转字符串 {

    public String LeftRotateString(String str,int n) {
        //勿忘特殊条件
        if(str == null || str.length() == 0 || n < 0)
            return str;
        n %= str.length();
        String s1 = str.substring(0,n);
        String s2 = str.substring(n,str.length());
        s1 = reverse(s1);
        s2 = reverse(s2);
        return reverse(s1+s2);
    }

    String reverse(String string){
        StringBuilder sb = new StringBuilder();
        for(int i = string.length()-1;i>=0;i--)
            sb.append(string.charAt(i));
        return sb.toString();
    }

    /*思路二可以用队列做实际翻转*/
}

/*题目：翻转单词顺序。
输入一个英文句子，翻转句子中单词的顺序，但单词内字符的顺序不变。为简单起见，标点符号和普通字母一样处理。
例如输入字符串"I am a student."，则输出"student.a am I"。*/

/*这道题目流传甚广，很多公司多次拿来作为面试题，很多应聘者也多次在各种博客或者书籍上看到通过两次翻转
字符串的解法，于是很快就可以跟面试官解释清楚解题思路：第一步翻转句子中所有的字符。比如翻转
"Iam a student."中所有的字符得到".tneduts a maI"，此时不但翻转了句子中单词的顺序，
连单词内的字符顺序也被翻转了。第二步再翻转每个单词中字符的顺序，就得到了"student.a amI"。
这正是符合题目要求的输出。*/
public class 翻转单词序列 {
    public String ReverseSentence(String str) {
        //这句很难想到
        if(str.trim().equals(""))
            return str;
        String tmp = reverse(str);
        String[] arr = tmp.split(" ");
        for(int i = 0; i<arr.length;i++)
            arr[i] = reverse(arr[i]);
        StringBuilder sb = new StringBuilder();
        for(String s: arr)
            sb.append(s).append(" ");
        String res_t = sb.toString();
        return res_t.substring(0,res_t.length()-1);
    }

    String reverse(String string){
        StringBuilder sb = new StringBuilder();
        for(int i = string.length()-1;i>=0;i--)
            sb.append(string.charAt(i));
        return sb.toString();
    }

//    更简单的方法，读成字符串数组让后逆序保存
    public String ReverseSentence2(String str) {
        if(str.trim().equals("")){
            return str;
        }
        String[] a = str.split(" ");
        StringBuilder o = new StringBuilder();
        int i;
        for (i = a.length; i >0;i--){
            o.append(a[i-1]);
            if(i > 1){
                o.append(" ");
            }
        }
        return o.toString();
    }
}

/*
*题目：从扑克牌中随机抽5张牌，判断是不是一个顺子，即这5张牌
|是不是连续的。2~10为数字本身，A为1，J为11，Q为12，K为13，而大、小王可以看成任意数字。
* */

/*
*我们需要把扑克牌的背景抽象成计算机语言。不难想象，我们可以把5张牌看成由5个数字组成的数组。
* 大、小王是特殊的数字，我们不妨把它们都定义为0，这样就能和其他扑克牌区分开来了。
接下来我们分析怎样判断5个数字是不是连续的，最直观的方法是把数组排序。值得注意的是，由于0
可以当成任意数字，我们可以用0去补满数组中的空缺。如果排序之后的数组不是连续的，即相邻的两
个数字相隔若干个数字，那么只要我们有足够的0可以补满这两个数字的空缺，这个数组实际上还是连续的。
举个例子，数组排序之后为0，1，3，4，5}，在1和3之间空缺了一个2，刚好我们有一个0，也就是我们可
以把它当成2去填补这个空缺。
于是我们需要做3件事情：首先把数组排序；其次统计数组中0的个数；最后统计排序之后的数组中相邻数字
之间的空缺总数。如果空缺的总数小于或者等于0的个数，那么这个数组就是连续的；反之则不连续。最后
我们还需要注意一点：如果数组中的非0数字重复出现，则该数组不是连续的。换成扑克牌的描述方式就是：
如果一副牌里含有对子，则不可能是顺子。
* */

import java.util.Arrays;

//为了方便起见,你可以认为大小王是0。
public class 扑克牌中的顺子 {
    public static boolean isContinuous(int[] numbers) {
        if (numbers == null || numbers.length == 0)
            return false;
        Arrays.sort(numbers);
        int zeros = 0;
        int index = 0;
        while (numbers[index] == 0) {
            zeros++;
            index++;
        }

        for (int i = index + 1; i < numbers.length; i++) {
            int diff = numbers[i] - numbers[i - 1];
            if (diff == 0) {
                return false;
            } else if (diff == 1) {
                continue;
            } else if (diff > 1) {
                while (diff != 1) {
                    diff--;
                    zeros--;
                    if (zeros < 0)
                        return false;
                }
            }
        }
        return true;
    }

    public static void main(String[] args) {
        int[] a = {0, 3, 2, 6, 4};
        isContinuous(a);
    }
}

/*
* 题目：0，1，n-1这n个数字排成一个圆圈，从数字0开始，每次从这个圆圈里删除第m个数字。求出这个圆圈里剩下的最后一个数字。
* */

/*首先我们定义一个关于n和m的方程（n，m），表示每次在n个数字0，
1，n-1中删除第m个数字最后剩下的数字。
在这n个数字中，第一个被删除的数字是(m-1)%n。为了简单起见，我们把(m-1)%n记为k，那么删除k之后剩下的n-1个数字为0，1…，
k-1，k+1…，n-1，并且下一次删除从数字k+1开始计数。相当于在剩下的序列中，k+1排在最前面，从而形成k+1，n-1，0，1…k-1。
该序列最后剩下的数字也应该是关于n和m的函数。由于这个序列的规律和前面最初的序列不一样（最初的序列是从0开始的连续序列），
因此该函数不同于前面的函数，记为f'(n-1，m)。最初序列最后剩下的数字f(n，m)一定是删除一个数字之后的序列最后剩下的数字，
即f(n，m)=f(n-l，m)。

接下来我们把剩下的这n-1个数字的序列k+1…，n-1，0，1…k-1进行映射，映射的结果是形成一个0~n-2的序列。
k+1→0
k+2→1
...
n-1→n-k-2
0→n-k-1
1→n-k
...
k-1→n-2
我们把映射定义为p，则p(x)-(x-k-1)%n。它表示如果映射前的数字是x，那么映射后的数字是(x-k-1)%n。该映射的逆映射是
q(x)=(x+k+1)%n。由于映射之后的序列和最初的序列具有同样的形式，即都是从0开始的连续序列，因此仍然可以用函数f来表示，
记为f(n-1,m)。根据我们的映射规则，映射之前的序列中最后剩下的数字f'(n-1，m)=q[(n-1，m)]=[f(n-1，m）+k+1]%n，
把k=(m-1)%n代入得到f(n，m)=f'(n-1，m)=[f(n-1，m)+m]%n。

经过上面复杂的分析，我们终于找到了一个递归公式。要得到n个数字的序列中最后剩下的数字，只需要得到n-1个数字的序列中最
后剩下的数字，并以此类推。当n=1时，也就是序列中开始只有一个数字0，那么很显然最后剩下的数字就是0。我们把这种关系表示为：
    f(n, m)= 0                    当n = 1时
    f(n,m) = [f(n-1，m)+m]%n      当n > 1时
*/
public class 圆圈中最后剩下的数字 {
    public int LastRemaining_Solution(int n, int m) {
        if(n<1||m<2)
            return -1;
        int last = 0;
        for(int i = 2; i<=n;i++)
            last = (last + m)%i;
        return last;
    }
}

/*题目描述
将一个字符串转换成一个整数(实现Integer.valueOf(string)的功能，但是string不符合数字要求时返回0)，
要求不能使用字符串转换整数的库函数。 数值为0或者字符串不是一个合法的数值则返回0。

输入描述:
输入一个字符串,包括数字字母符号,可以为空
输出描述:
如果是合法的数值表达则返回该数字，否则返回0
    示例1
    输入
    +2147483647
        1a33

    输出
    2147483647
        0*/

/**/
public class 把字符串转化为整数 {
    public static boolean flag;
    public static int StrToInt(String str) {
        //flag的作用时判断输入是否非法
        /*非法的情况分别有：
        * 1. 字符串为null或者为空
        * 2. 字符串中有除了数字0~9以及正负号以外的其他字符
        * 3. +、-号出现在第一位以外的其他位置
        * 4. 字符串表示的数字对int型来说产生了溢出*/

        /*为了区分是因为输入零返回值为0还是因为非法输入返回0，这里添加一个flag来作为非法输入的标识*/
        flag = false;
        //判断输入是否合法，先用str.trim()去除首尾的空格
        if (str == null || str.trim().equals("")) {
            flag = true;
            return 0;
        }
        // symbol=0,说明该数为正数;symbol=1，该数为负数;start用来区分第一位是否为符号位
        int symbol = 0;
        int start = 0;
        char[] chars = str.trim().toCharArray();
        if (chars[0] == '+') {
            start = 1;
        } else if (chars[0] == '-') {
            start = 1;
            symbol = 1;
        }
        int result = 0;
        for (int i = start; i < chars.length; i++) {
            if (chars[i] > '9' || chars[i] < '0') {
                flag = true;
                return 0;
            }
            int sum = result * 10 + (chars[i] - '0');

            //判断是否溢出，举个例子,3*10+5=35,如果(35-5)/10不等于3，那么就产生了溢出
            if ((sum - (chars[i] - '0')) / 10 != result) {
                flag = true;
                return 0;
            }

            result = result * 10 + (chars[i] - '0');
            /*
             * 当输入为value=2147483648时，在计算机内部的表示应该是-2147483648
             * 显然value>Integer.MAX_VALUE是不成立的
             */
        }
        // 注意：java中-1的n次方不能用：(-1)^n .'^'异或运算
        // 注意，当value=-2147483648时，value=-value
        result = (int) Math.pow(-1, symbol) * result;
        return result;
    }
}

/*
*题目一：找出数组中重复的数字。
在一个长度为n的数组里的所有数字都在0~n-1的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，
也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。例如，如果输入长度为7的数组（2，3，1，0，
2，5，3}，那么对应的输出是重复的数字2或者3。
* */


public class 数组中的重复数字 {
    // 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

    /*思路:
    用set来测试需要O(n)的空间复杂度
    下面的解法数字的范围利用都在0~n-1的范围内，且数组的长度为n，这样所有数字都可以映射到原数组的下标中
    * 现在让我们重排这个数组。从头到尾依次扫描这个数组中的每个数字。当扫描到下标为i的数字时，首先比较这个数字（用m表示）是不是等于i。
    * 如果是，则接着扫描下一个数字；如果不是，则再拿它和第m个数字进行比较。如果它和第m个数字相等，就找到了一个重复的数字（该数字在下
    * 标为i和m的位置都出现了）；如果它和第m个数字不相等，就把第i个数字和第m个数字交换，把m放到属于它的位置。接下来再重复这个比较、
    * 交换的过程，直到我们发现一个重复的数字。*/

    /*以数组{2，3，1，0，2，5，3}为例来分析找到重复数字的步骤。数组的第0个数字（从0开始计数，和数组的下标保持一致）是2，与它的下标
    不相等，于是把它和下标为2的数字1交换。交换之后的数组是{1，3，2，0，2，，5，3}。此时第0个数字是1，仍然与它的下标不相等，继续把
    它和下标为1的数字3交换，得到数组{3，1，2，0，2，5，3}。接下来继续交换第0个数字3和第3个数字0，得到数组{0，1，2，3，2，5，3}。
    此时第0个数字的数值为0，接着扫描下一个数字。在接下来的几个数字中，下标为1、2、3的3个数字分别为1、2、3，它们的下标和数值都分别
    相等，因此不需要执行任何操作。接下来扫描到下标为4的数字2。由于它的数值与它的下标不相等，再比较它和下标为2的数字。注意到此时数组
    中下标为2的数字也是2，也就是数字2在下标为2和下标为4的两个位置都出现了，因此找到一个重复的数字。*/

    public boolean duplicate(int numbers[],int length,int [] duplication) {
        int p = 0;
        while(p<length){
            if(numbers[p]!=p){
                if(numbers[numbers[p]] != numbers[p]){
                    swap(numbers,p,numbers[p]);
                }
                else{
                    duplication[0] = numbers[p];
                    return true;
                }
            }else {
                p++;
            }
        }
        return false;
    }

    void swap(int[] arr, int x1, int x2){
        int tmp = arr[x1];
        arr[x1] = arr[x2];
        arr[x2] = tmp;
    }

    /*扩展:
    * 题目二：不修改数组找出重复的数字。在一个长度为n+l的数组里的所有数字都在1～n的范围内，
    * 所以数组中至少有一个数字是重复的。请找出数组中任意一个重复的数字，但不能修改输入的数组。
    * 例如，如果输入长度为8的数组（2，3，5，4，3，2，6，7}，那么对应的输出是重复的数字2或者3。*/

    /*这一题看起来和上面的面试题类似。由于题目要求不能修改输入的数组，我们可以创建一个长度为n+1的辅助数组，
    然后逐一把原数组的每个数字复制到辅助数组。如果原数组中被复制的数字是m，则把它复制到辅助数组中下标为m的位置。
    这样很容易就能发现哪个数字是重复的。由于需要创建一个数组，该方案需要O（n）的辅助空间。

    接下来我们尝试避免使用O（n）的辅助空间。为什么数组中会有重复的数字？假如没有重复的数字，那么在从1～n的范围里
    只有n个数字。由于数组里包含超过n个数字，所以一定包含了重复的数字。看起来在某范围里数字的个数对解决这个问题很重要。
    我们把从1～n的数字从中间的数字m分为两部分，前面一半为1～m，后面一半为m+l～n。如果1～m的数字的数目超过m，那么这
    一半的区间里一定包含重复的数字；否则，另一半m+l～n的区间里一定包含重复的数字。我们可以继续把包含重复数字的区间一
    分为二，直到找到一个重复的数字。这个过程和二分查找算法很类似，只是多了一步统计区间里数字的数目。

    我们以长度为8的数组{2，3，5，4，3，2，6，7}为例分析查找的过程。根据题目要求，这个长度为8的所有数字都在1~7的范围内。中
    间的数字4把1~7的范围分为两段，一段是1~4，另一段是5~7。接下来我们统计1~4这4个数字在数组中出现的次数，它们一共出现了5次，
    因此这4个数字中一定有重复的数字。接下来我们再把1~4的范围一分为二，一段是1、2两个数字，另一段是3、4两个数字。数字1或者2
    在数组中一共出现了两次。我们再统计数字3或者4在数组中出现的次数，它们一共出现了三次。这意味着3、4两个数字中一定有一个重复
    了。我们再分别统计这两个数字在数组中出现的次数。接着我们发现数字3出现了两次，是一个重复的数字。*/

    /*上述代码按照二分查找的思路，如果输入长度为n的数组，那么函数countRange将被调用O（logn）次，每次需要O（n）的时间，
    因此总的时间复杂度是O（nlogn），空间复杂度为O（1）。和最前面提到的需要O（n）的辅助空间的算法相比，这种算法相当于以
    时间换空间。
    需要指出的是，这种算法不能保证找出所有重复的数字。例如，该算法不能找出数组2，3，5，4，3，2，6，7}中重复的数字2。
    这是因为在1~2的范围里有1和2两个数字，这个范围的数字也出现2次，此时我们用该算法不能确定是每个数字各出现一次还是某个数
    字出现了两次。*/
}

/*题目：给定一个数组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]。不能使用除法。*/

/*好在还有更高效的算法。可以把B[i]=A[0]×A[1]…×A[i-1]×A[i+1]…×A[n-1]看成
A[0]×A[1]x…×A[i-1]和A[i+1]…×A[n-2]×A[n-1]两部分的乘积。因此，数组B可以用一个矩阵来创建。*/

/*不妨定义C[i]=A[0]×A[1]…×A[i-1]，D[i]=A[i+1]…×A[n-2]×A[n-1]。
C[i]可以用自上而下的顺序计算出来，即C[i]=C[i-1]×A[i-1]。类似的，D[i]
也可以用自下而上的顺序计算出来，即D[i]=D[i+1]×A[i+1]。*/
public class 构建乘积数组 {
    public int[] multiply(int[] A) {
        int[] B = new int[A.length];
        if (A.length == 0)
            return B;
        int[] C = new int[A.length];
        C[0] = 1;
        int[] D = new int[A.length];
        D[D.length - 1] = 1;

        for (int i = 1; i < A.length; i++) {
            C[i] = C[i - 1] * A[i - 1];
        }
        for (int i = A.length - 2; i >= 0; i--) {
            D[i] = D[i + 1] * A[i + 1];
        }
        for (int i = 0; i < B.length; i++)
            B[i] = C[i] * D[i];
        return B;
    }
}

/*题目描述
请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。例如，字符串"+100","5e2","-123","3.1416"和"-1E-16"都表示数值。
但是"12e","1a3.14","1.2.3","+-5"和"12e+4.3"都不是。*/

import java.util.regex.Pattern;

public class 表示数值的字符串 {
    /*
    * ^ 和 美元符号框定正则表达式，它指引这个正则表达式对文本中的所有字符都进行匹配。如果省略这些标识，
    * 那么只要一个字符串中包含一个数字这个正则表达式就会进行匹配。如果仅包含 ^ ，它将匹配以一个数字开头
    * 的字符串。如果仅包含$ ，则匹配以一个数字结尾的字符串。

[-+]?
正负号后面的 ? 后缀表示这个负号是可选的,表示有0到1个负号或者正号

\d*
d的含义和[0-9]一样。它匹配一个数字。后缀 * 指引它可匹配零个或者多个数字。

(?:\.\d*)?
(?: …)?表示一个可选的非捕获型分组。* 指引这个分组会匹配后面跟随的0个或者多个数字的小数点。

(?:[eE][+\-]?d+)?
这是另外一个可选的非捕获型分组。它会匹配一个e(或E)、一个可选的正负号以及一个或多个数字。
    * */
    public static boolean isNumeric(char[] str) {
        String pattern = "^-?\d*(?:\.\d*)?(?:[eE][+\-]?\d+)?$";
        String s = new String(str);
        return Pattern.matches(pattern,s);
    }

    public static void main(String[] args) {
        char[] chars = {'1','.','0','2','E','-','2'};
        System.out.println(isNumeric(chars));
    }

    /*思路2：
    表示数值的字符串遵循模式A[[B]][e|EC]或者.B[e|EC]，其中A为数值的整数部分，B紧跟着小数点为数值的小数部分，
    C紧跟着'e'或者'E'为数值的指数部分。在小数里可能没有数值的整数部分。例如，小数.123等于0.123。因此A部分不是
    必需的。如果一个数没有整数部分，那么它的小数部分不能为空。
    上述A和C都是可能以'+'或者'-'一开头的0~9的数位串；B也是0～9的数位串，但前面不能有正负号。
    以表示数值的字符串“123.45e+6"为例，“123”是它的整数部分A，“45”是它的小数部分B，“+6”是它的指数部分C。
    判断一个字符串是否符合上述模式时，首先尽可能多地扫描0~9的数位（有可能在起始处有中或者’一），也就是前面模式中
    表示数值整数的A部分。如果遇到小数点，则开始扫描表示数值小数部分的B部分。如果遇到'e或者E’，则开始扫描表示数值
    指数的C部分。
    * */

    private int index = 0;

    public boolean isNumeric2(char[] str) {
        if (str.length < 1)
            return false;

        boolean flag = scanInteger(str);

        if (index < str.length && str[index] == '.') {
            index++;
            flag = scanUnsignedInteger(str) || flag;
        }

        if (index < str.length && (str[index] == 'E' || str[index] == 'e')) {
            index++;
            flag = flag && scanInteger(str);
        }

        return flag && index == str.length;

    }

    private boolean scanInteger(char[] str) {
        if (index < str.length && (str[index] == '+' || str[index] == '-') )
            index++;
        return scanUnsignedInteger(str);

    }

    private boolean scanUnsignedInteger(char[] str) {
        int start = index;
        while (index < str.length && str[index] >= '0' && str[index] <= '9')
            index++;
        return start < index; //是否存在整数
    }

}

/*题目描述
给定一棵二叉搜索树，请找出其中的第k小的结点。例如，（5，3，7，2，4，6，8）中，按结点数值大小顺序
第三小结点的值为4。*/

/*如果按照中序遍历的顺序遍历一棵二叉搜索树，则遍历序列的数值是递增排序的。
因此，只需要用中序遍历算法遍历一棵二叉搜索树，我们就很容易找出它的第k大节点。*/

import java.util.Stack;

public class 循环与递归_二叉搜索树的第k个节点 {
    //中序递归
    int count = 0; //计数器

    TreeNode KthNode(TreeNode root, int k) {
        //递归截至条件
        if(root == null)
            return null;
        //从左子树中找到非空节点并返回
        TreeNode node = KthNode(root.left,k);
        if(node != null)
            return node;
        //中序记录返回的节点的个数
        if(++count == k)
            return root;
        //在右子树中找到非空节点并返回
        node = KthNode(root.right,k);
        if(node != null)
            return node;
        return null;
    }


    //中序循环
    TreeNode KthNode2(TreeNode root, int k) {
        if (root == null || k == 0)
            return null;
        Stack<TreeNode> stack = new Stack<TreeNode>();
        int count = 0;
        TreeNode node = root;
        do {
            if (node != null) {
                stack.push(node);
                node = node.left;
            } else {
                node = stack.pop();
                count++;
                if (count == k)
                    return node;
                node = node.right;
            }
        } while (node != null || !stack.isEmpty());
        return null;
    }
}

/*
* 题目描述
请实现一个函数用来找出字符流中第一个只出现一次的字符。例如，当从字符流中只读出前两个字符"go"时，
第一个只出现一次的字符是"g"。当从该字符流中读出前六个字符“google"时，第一个只出现一次的字符是"l"。
输出描述:
如果当前字符流没有存在出现一次的字符，返回#字符
* */

/*
*字符只能一个接着一个从字符流中读出来。可以定义一个数据容器来保存字符在字符流中的位置。当一个字符
* 第一次从字符流中读出来时，把它在字符流中的位置保存到数据容器里。当这个字符再次从字符流中读出来时，
* 那么它就不是只出现一次的字符，也就可以被忽略了。这时把它在数据容器里保存的值更新成一个特殊的值（
* 如负数值）。
为了尽可能高效地解决这个问题，需要在O（1）时间内往数据容器里插入一个字符，以及更新一个字符对应的值。
受面试题50的启发，这个数据容器可以用哈希表来实现。用字符的ASCII码作为哈希表的键值，而把字符对应的
位置作为哈希表的值。
* */
public class 字符流中第一个不重复的数 {
    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 '#';
    }
}