剑指offer刷题笔记

最新推荐文章于 2024-05-19 12:00:00 发布

lovelin07

最新推荐文章于 2024-05-19 12:00:00 发布

阅读量2k

点赞数

文章标签：数据结构

本文链接：https://blog.csdn.net/weixin_43278551/article/details/106246258

版权

1. 二维数组中的查找

题目描述：

在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

思路

先找到所在的行，再找到所在的列

代码实现

public static boolean Find(int target, int [][] array){
   //边界条件，当target<最小或target>最大时，直接返回false
   if(array == null || array.length == 0 || array[0].length == 0 || target < array[0][0] || target > array[array.length-1][array[0].length-1]){
       return false;
   }
   for (int i = 0; i < array.length-1; i++) {
       //找到对应的行
       if(array[i][0] <= target && array[i][array[0].length-1] >= target){
       	   //二分查找
           int left = 0;
           int right = array[0].length-1;
           int mid;
           //这里必须要有=，否则就需要判断left和right的值
           while (left <= right){
               mid = (left + right) / 2;
               if(array[i][mid] == target){
                   return true;
               }else if(array[i][mid] > target){
                   right = mid - 1;
               }else{
                   left = mid + 1;
               }
           }
       }
   }
   return false;
}

2. 空格替换

题目描述

请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。

思路

Java中的String类中有一个replace方法，传入要替换的字符串与替换的字符串
遍历StringBuilder，当不为空格时，放入新字符串，为空格时加入替换的字符串并将指针后移

代码实现

public static String replaceSpace(StringBuffer str){
	//1. 直接用API
	//return str.toString().replace(" ", "%20");
	//2. 使用遍历的方式
    char[] chars = str.toString().toCharArray();
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < chars.length; i++) {
        if(chars[i] != ' '){
            sb.append(chars[i]);
        }else{
            sb.append("%20");
        }
    }
    return sb.toString();
}

3. 从尾到头打印链表

题目描述

输入一个链表，按链表从尾到头的顺序返回一个ArrayList。

思路

使用栈，将所有元素入栈，然后出栈入ArrayList

代码实现

public static ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
    ArrayList<Integer> list = new ArrayList<>();
    Stack<Integer> stack = new Stack<>();
    ListNode temp = listNode;
    if(listNode == null) return list;
    //将所有元素入栈
    while (temp != null){
        stack.push(temp.val);
        temp = temp.next;
    }
    //出栈入队
    while (!stack.empty()){
        list.add(stack.pop());
    }
    return list;
}

4. 重构二叉树

题目描述

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

思路

前序遍历的第一位是根节点，这个节点会将中序遍历划分为两部分，分别为这个节点的左右子树，且分开的两部分的第一个节点是当前节点的左右子节点

代码实现

public static TreeNode reConstructBinaryTree(int [] pre, int [] in){
    if(pre == null || in == null || pre.length == 0 || in.length == 0){
        return null;
    }
    if(pre.length == 1 && in.length == 1) return new TreeNode(pre[0]);
    return reConstructBinaryTree(pre, 0, pre.length-1, in, 0, in.length-1);
}

private static TreeNode reConstructBinaryTree(int[] pre, int preStart, int preEnd, int[] in, int inStart, int inEnd) {
    TreeNode root = new TreeNode(pre[preStart]);
    if(preStart == preEnd){
        return root;
    }
    int i;
    for (i = 0; i < in.length; i++) {
        if(in[i] == pre[preStart]){
            break;
        }
    }
    if(i > inStart) {
        root.left = reConstructBinaryTree(pre, preStart+1, preStart+i-inStart, in, inStart, i-1);
    }
    if(i < inEnd) {
        root.right = reConstructBinaryTree(pre, preStart+i-inStart+1, preEnd, in, i+1, inEnd);
    }
    return root;
}

5. 两个栈实现队列

题目描述

用两个栈来实现一个队列，完成队列的Push和Pop操作。队列中的元素为int类型。

思路

一个辅助栈，当需要push时，先将栈的元素移到辅助栈，然后将需要入队的元素入栈，再将辅助栈的元素移到栈中，pop只需将栈顶元素移除即可，（pop和push反过来有也可以实现）

代码实现

public class Solution {
    Stack<Integer> stack1 = new Stack<Integer>();
    Stack<Integer> stack2 = new Stack<Integer>();
    
    public void push(int node) {
        while (!stack1.empty()){
            stack2.push(stack1.pop());
        }
        stack1.push(node);
        while (!stack2.empty()){
            stack1.push(stack2.pop());
        }
    }
    
    public int pop() {
        return stack1.pop();
    }
}

6. 旋转数组的最小数字

题目描述

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。
输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。
例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。
NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。

思路

类似于二分查找，分别设置左右指针，当中间的元素比头元素大时，说明中间的在前半部分的升序列中，最小值一定在后半部分，将左指针移动到中间位置，此时左指针仍然在前半部分的递增序列中；比头元素小，说明中间在后半部分的升序列中，最小值在前半部分，将右指针移动到中间位置，右指针仍然在后半部分的递增子序列中；最后会变成左指针在前半部分的最后一位，右指针在后半部分的第一位，即右指针指向的点就是最小的点

代码实现

public static int minNumberInRotateArray(int[] array){
	//若数组大小为0，返回0
    if(array==null || array.length==0) return 0;
    int left = 0;
    int right = array.length-1;
    int mid;
    while(array[left] >= array[right]){
        mid = (left+right)/2;
        //有重复数字
        if(array[left]==array[mid] && array[mid]==array[right]){
            for (int i = left+1; i <= right; i++) {
                if(array[left]-array[left-1] < 0){
                    return left;
                }
            }
        }
        if(array[mid] >= array[left]){
            left = mid;
        }else{
            right = mid;
        }
        if(right-left == 1){
            return array[right];
        }
    }
    return array[right];
}

7. 斐波那契数列

题目描述

大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0，第1项是1）。n<=39

思路

递归：f(n) = f(n-1) + f(n-2)
伪DP：dp[n] = dp[n-1] + dp[n-2]
辅助变量：使用两个辅助变量，每次a = a + b；b = a - b

代码实习

//递归
public static int F(int n){
    if(n == 1) return 1;
    if(n == 2) return 1;
    return F(n-1) + F(n-2);
}
//伪DP
private static int Fib(int n){
    int[] dp = new int[n+1];
    dp[0] = 0;
    dp[1] = 1;
    dp[2] = 1;
    int i = 3;
    while (i <= n){
        dp[i] = dp[i-1] + dp[i-2];
        i++;
    }
    return dp[n];
}
//辅助变量
public static int Fibonacci(int n) {
    if(n == 0) return 0;
    int a = 1;
    int b = 1;
    while (n > 2){
        a = a + b;
        b = a - b;
        n--;
    }
    return a;
}

8. 青蛙跳台阶

题目描述

一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。

思路

递归：第n阶就是n-1和n-2阶的和，实质上就是一个斐波那契数列
非递归：使用辅助变量

代码实现

//非递归（返回值时int，target最大只能到45）
public static int JumpFloor(int target) {
    if(target == 0) return 0;
    if(target == 1) return 1;
    int a = 1;
    int b = 2;
    while (target > 2){
        b = a + b;
        a = b - a;
        target--;
    }
    return b;
}
//递归
public static int JF(int target){
    if(target == 1) return 1;
    if(target == 2) return 2;
    return JF(target-1) + JF(target-2);
}

9. 跳台阶变态版

题目描述

一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

思路

由上一题可知，只能跳1和2时结果为f(n) = f(n-1) + f(n-2)；类推可知，当可以跳1到n时，
可知：f(n) = f(n-1) + f(n-2) + f(n-3) + f(n-4) + … + f(1)；
再有：f(n-1) = f(n-2) + f(n-3) + … +f(1);
相减：f(n) - f(n-1) = f(n-1) => f(n) = 2f(n-2)

代码实现

public static int JumpFloorII(int target) {
    if(target == 0) return 0;
    if(target == 1) return 1;
    int a = 1;
    while (target > 1){
        a = 2*a;
        target--;
    }
    return a;
}

public static int JFII(int target){
    if(target == 0) return 0;
    if(target == 1) return 1;
    return 2*JumpFloorII(target-1);
}

10. 矩形覆盖

题目描述

我们可以用21的小矩形横着或者竖着去覆盖更大的矩形。请问用n个21的小矩形无重叠地覆盖一个2n的大矩形，总共有多少种方法？比如n=3时，23的矩形块有3种覆盖方法

思路

当n=1时，只有1种；当n=2时，有2种
当n>2时，如果竖着放最后一列，则结果为n-1的结果；横着放就是n-2的结果；
所以最后的结果为f(n) = f(n-1) + f(n-2)；就是一个斐波那契数列

代码实现

public static int RectCover(int target) {
    if(target <= 0) return 0;
    if(target == 1) return 1;
    if(target == 2) return 2;
    int a = 1;
    int b = 2;
    while(target > 2){
        b = a + b;
        a = b - a;
        target--;
    }
    return b;
}

11. 二进制中1的个数

题目描述

输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。

思路

Java中有Integer.toString(int n, int radix)方法或者Integer.toBinaryString(n)，可以将对应的10进制转为2进制，然后去数转换后的1的字符的个数
根据位运算&，由n&(n-1)可以消除n的最后一个1可知，循环使用&直到结果为0

代码实现

public static int numOf1(int n){
    String string = Integer.toBinaryString(n);
    int count = 0;
    char[] chars = string.toCharArray();
    for (int i = 0; i < chars.length; i++) {
        if(chars[i] == '1'){
            count++;
        }
    }
    return count;
}

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

12. 求小数的次方

题目描述

给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。
保证base和exponent不同时为0

思路

当base=0时，0的任何次方都为0；当exponent为0时，任何数的0次方都为1
当exponent>0时，直接使用循环相乘
当exponent<0时，先将exponent变为正数，然后用1除以结果

代码实现

public double Power(double base, int exponent) {
    if(exponent == 0) return 1;
    if(base == 0) return 0;
    double res = 1;
    for (int i = 0; i < Math.abs(exponent); i++) {
        res *= base;
    }
    if(exponent < 0){
        res = 1/res;
    }
    return res;
}

13. 调整数组顺序使奇数位于偶数前面

题目描述

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

思路

使用两个辅助List分别存放奇数和偶数，然后将List的数放入数组，使用了额外的空间
遍历数组，先找到偶数，然后以这个点开始往后找到第一个奇数，将偶数以后到奇数的数据全部后移，然后将奇数填到偶数的位置
例如：1，3，4，6，8，5，7，9，2；先找到第一个偶数4，然后找到4之后的第一个奇数5；将4，6，8分别后移一位，将5填在以前的4的位置，得到1，3，5，4，6，8，7，9，2；依次寻找交换，得到结果

代码实现

//1.使用额外空间
public static void reOrderArray1(int [] array){
    //基数
    ArrayList<Integer> odd = new ArrayList<>();
    //偶数
    ArrayList<Integer> even = new ArrayList<>();
    for (int i = 0; i < array.length; i++) {
        if(array[i] % 2 == 0){
            even.add(array[i]);
        }else{
            odd.add(array[i]);
        }
    }
    int i = 0;
    while (i < odd.size()){
        array[i] = odd.get(i);
        i++;
    }
    while (i < odd.size()+even.size()){
        array[i] = even.get(i-odd.size());
        i++;
    }
}
//2.不使用额外空间
public static void reOrderArray(int [] array){
    if(array == null || array.length == 0 || array.length == 1) return;
    for (int i = 0; i < array.length; i++) {
        //找到偶数
        if(array[i] % 2 == 0){
            //从偶数开始找到第一个奇数
            int j = i + 1;
            while (j < array.length){
                if(array[j] % 2 == 1){
                    break;
                }
                j++;
            }
            if(j == array.length) return;
            //将偶数后移
            int temp = array[j];
            for (int k = j; k > i; k--) {
                array[k] = array[k-1];
            }
            array[i] = temp;
        }
    }
}

14. 链表中倒数第k个结点

题目描述

输入一个链表，输出该链表中倒数第k个结点。

思路

先用一个指针指向头节点的后面第k个，然后同时移动头节点和第k个节点，当第k个节点到末尾时，头节点就是倒数第k个节点

代码实现

public static ListNode FindKthToTail(ListNode head, int k) {
    if(head == null) return null;
    if(k <= 0) return null;
    ListNode p = head;
    ListNode q = head;
    //这里是k>1而不是k>0
    while (k > 1){
        p = p.next;
        //如果p已经为null了仍有k>1，则说明链表没有k个数
        if(null == p) return null;
        k--;
    }
    //移动p直到链表末尾
    while(p.next != null){
        p = p.next;
        q = q.next;
    }
    return q;
}

15. 反转链表

题目描述

输入一个链表，反转链表后，输出新链表的表头

思路

使用三个指针，分别指向前一个节点pre，当前节点cur和下一个节点nxt
cur.next = pre
pre = cur
cur = nxt
nxt = nxt.next
最后还要将cur的next指向pre

代码实现

public static ListNode reverse(ListNode head){
    if(head == null || head.next == null){
        return head;
    }
    ListNode pre = head;
    ListNode cur = pre.next;
    ListNode nxt = cur.next;
    //先将pre与cur断开
    pre.next = null;
    while (nxt != null){
        cur.next = pre;
        pre = cur;
        cur = nxt;
        nxt = nxt.next;
    }
    //最后将cur的next指向pre
    cur.next = pre;
    return cur;
}
//递归实现
public static ListNode ReverseList(ListNode head) {
    if(head == null || head.next == null) return head;
    ListNode node = ReverseList(head.next);
    ListNode temp = head.next;
    temp.next = head;
    head.next = null;
    return node;
}

16. 合并两个有序链表

题目描述

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

思路

创建一个新链表，两个指针指向两个链表的头部，开始同时遍历两个链表，哪个小就将节点放到新的链表中，当前链表指针向后移，直到遍历完其中一条，然后将另一条放入新链表

代码实现

public static ListNode MergeList(ListNode list1, ListNode list2){
    if(list1 == null) return list2;
    if(list2 == null) return list1;
    ListNode head = list1.val <= list2.val ? list1 : list2;
    ListNode p1;
    ListNode p2;
    if(head == list1){
        p1 = list1.next;
        p2 = list2;
    }else{
        p1 = list1;
        p2 = list2.next;
    }
    ListNode temp = head;
    while (p1 != null && p2 != null){
        if(p1.val <= p2.val){
            temp.next = p1;
            p1 = p1.next;
        }else{
            temp.next = p2;
            p2 = p2.next;
        }
        temp = temp.next;
    }
    if(p1 == null){
        temp.next = p2;
    }
    if(p2 == null){
        temp.next = p1;
    }
    return head;
}

17. 树的子结构

题目描述

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

思路

根据遍历的结果，如果B树是A树的子结构，那么B树的前序遍历是A的前序遍历的一部分
先找到与根节点值相等的节点，再以此节点为根节点与对应的子树比较，如果都相等则返回true

代码实现

//前序遍历包含关系
public static boolean HasSubtree(TreeNode root1, TreeNode root2) {
    if(root1==null || root2==null) return false;
    List<Integer> list1 = preOrder(root1);
    List<Integer> list2 = preOrder(root2);
    /*System.out.println(list1);  //1245367
    System.out.println(list2);    //245*/
    //如果list1包含list2，则返回true
    return contain(list1,list2);
}
//前序遍历
private static List<Integer> preOrder(TreeNode root){
    ArrayList<Integer> list = new ArrayList<>();
    Stack<TreeNode> stack = new Stack<>();
    TreeNode p = root;
    while(p!=null || !stack.empty()){
        while(p!=null){
            list.add(p.val);
            stack.push(p);
            p = p.left;
        }
        TreeNode pop = stack.pop();
        p = pop.right;
    }
    return list;
}
//判断list1是否包含list2
private static boolean contain(List<Integer> list1, List<Integer> list2){
    if(list1 == null || list2 == null) return false;
    for (int i = 0; i < list1.size(); i++) {
        if(list1.get(i) == list2.get(0)){
            int j = 0;
            while(j < list2.size()){
                if(list1.get(j+i) == list2.get(j)){
                    if(j == list2.size() - 1){
                        return true;
                    }else {
                        j++;
                    }
                }else{
                    break;
                }
            }

        }
    }
    return false;
}

//递归实现
public static boolean HasSubtree1(TreeNode root1, TreeNode root2){
    boolean res = false;
    if (root1 != null && root2 != null){
        if(root1.val == root2.val){
        	//如果两个节点的值相等，开始比较
            res = subtree(root1, root2);
        }
        //比较不成立
        if(!res){
        	//从根节点的左节点找
            res = HasSubtree1(root1.left, root2);
        }
        if(!res){
        	//从根节点的右节点找
            res = HasSubtree1(root1.right, root2);
        }
    }
    return res;
}

private static boolean subtree(TreeNode root1, TreeNode root2) {
    if(root2 == null){
        return true;
    }
    if(root1 == null || root1.val != root2.val){
        return false;
    }
    return subtree(root1.left, root2.left) && subtree(root1.right, root2.right);
}

18. 二叉树的镜像

题目描述

操作给定的二叉树，将其变换为源二叉树的镜像。

思路

如果当前节点是空节点或叶子节点，直接返回，不是的话就将左右节点互换，递归将左右子树镜像翻转

代码实现

public static void Mirror(TreeNode root) {
    if(root == null || (root.left == null && root.right == null)) return;
    //将左右子节点互换
    TreeNode temp = root.left;
    root.left = root.right;
    root.right = temp;
    if(root.left != null){
        Mirror(root.left);
    }
    if(root.right != null){
        Mirror(root.right);
    }
}

19. 顺时针打印矩阵

题目描述

输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下4 X 4矩阵：
1__2__3__4
5__6__7__8
9__10_11_12
13_14_15_16
则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.

思路

一层一层打印1->5为第一层，6->10为第二层

代码实现

public static ArrayList<Integer> printMatrix(int [][] array) {
    ArrayList<Integer> result = new ArrayList<>();
    if(array.length == 0 || array[0].length ==0) return result;
    int n = array.length; //行
    int m = array[0].length; //列
    //一共多少圈
    int circle = ((Math.min(n, m)-1)/2) + 1;
    //按圈打印
    for (int i = 0; i < circle; i++) {
        //左至右
        for(int j = i; j < m-i; j++) result.add(array[i][j]);
        //右上至右下
        for(int j = i+1; j < n-i; j++) result.add(array[j][m-i-1]);
        //右至左
        for(int j = m-i-2; (j >= i) && (n-i-1 != i); j--) result.add(array[n-i-1][j]);
        //左下至左上
        for(int j = n-i-2; (j > i) && (m-i-1 != i); j--) result.add(array[j][i]); 
    }
    return result;
}

20. 包含min函数的栈

题目描述

定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。
注意：保证测试中不会当栈为空的时候，对栈调用pop()或者min()或者top()方法。

思路

一个操作栈，放每次存入的数据，另一个辅助栈，放当前最小的的元素；
当放入的数大于辅助栈的栈顶元素时，辅助栈放辅助栈的栈顶元素，否则放入当前元素；
保证了辅助栈的栈顶永远对应当前操作栈的最小元素

代码实现

public class MinStack {
    private Stack<Integer> stack = new Stack<>();
    private Stack<Integer> minStack = new Stack<>();

    public void push(int node) {
        stack.push(node);
        if(minStack.empty() || node < minStack.peek()){
            minStack.push(node);
        }else{
            minStack.push(minStack.peek());
        }
    }

    public void pop() {
        stack.pop();
        minStack.pop();
    }

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

    public boolean empty(){
        return stack.empty();
    }

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

21. 栈的压入、弹出序列

题目描述

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

思路

先判断两个数组长度是否相等，不相等一定不是；创建一个栈，两个指针分别指向两个数组的首位
先处理入栈数组，比较入栈指针的值与出栈指针的值，相同两个指针都+1；不同则入栈+1并将元素入栈，出栈不变，直到入栈序列遍历完毕
再处理出栈序列，从入栈完毕后的出栈指针对应的位置开始，如果出栈指针对应的值等于栈顶元素，则出栈，不等则向后移动指针，直到遍历完毕
最后判断栈是否为空

代码实现

public static boolean IsPopOrder(int[] pushA, int[] popA){
    if(pushA.length != popA.length) return false;
    Stack<Integer> stack = new Stack<>();
    int i = 0;
    int j = 0;
    //先处理入栈序列
    while (i < pushA.length){
        if(pushA[i] != popA[j]){
            stack.push(pushA[i]);
            i++;
        }else{
            i++;
            j++;
        }
    }
    //再处理出栈序列
    while (j < popA.length){
        if(popA[j] == stack.peek()){
            j++;
            stack.pop();
        }else{
            j++;
        }
    }
    return stack.empty();
}

22. 从上往下打印二叉树

题目描述

从上往下打印出二叉树的每个节点，同层节点从左至右打印。
层次遍历

思路

使用队列，将根节点入队，然后根节点出队，根节点的左右节点入队；循环直到节点的左右子树都为空

代码实现

public static ArrayList<Integer> PrintFromTopToBottom(TreeNode root){
    ArrayList<Integer> list = new ArrayList<>();
    if(root == null){
        return list;
    }
    ArrayDeque<TreeNode> deque = new ArrayDeque<>();
    deque.add(root);
    while (!deque.isEmpty()){
        TreeNode node = deque.poll();
        list.add(node.val);
        if(node.left != null) {
            deque.add(node.left);
        }
        if(node.right != null) {
            deque.add(node.right);
        }
    }
    return list;
}

23. 二叉搜索树的后序遍历序列

题目描述

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

思路

二叉搜索数：若节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值；若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；它的左、右子树也分别为二叉排序树。
后续遍历：左-右-根；由于对某个根节点来说，左子树的值比根节点的值都要小，右子树的值比根节点的值都要大；

代码实现

public static boolean VerifySquenceOfBST(int[] sequence) {
    if(sequence.length == 0) return false;
    if(sequence.length == 1) return true;
    return judge(sequence, 0, sequence.length-1);
}

//right代表当前子树的根节点
private static boolean judge(int[] sequence, int left, int right){
    if(left >= right){
        return true;
    }
    int i = 0;
    //找到比最后一位（根节点）大的第一个数
    while (sequence[i] < sequence[right]){
        i++;
    }
    //保证后面的数都比根节点的大
    for (int j = i; j < right; j++) {
        if(sequence[j] < sequence[right]){
            return false;
        }
    }
    return judge(sequence, left, i-1) && judge(sequence, i, right-1);
}

24. 二叉树中和为某一值的路径

题目描述

输入一颗二叉树的根节点和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。

思路

利用回溯的思想；题目说的是从根节点到叶子节点的路径，利用回溯遍历所有路径，看结果是否符合要求

代码实现

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

public ArrayList<ArrayList<Integer>> FindPath(TreeNode root, int target){
    if(root == null) return res;
    list.add(root.val);
    target -= root.val;
    if(target==0 && root.left==null && root.right==null){
        res.add(new ArrayList<>(list));
    }
    FindPath(root.left, target);
    FindPath(root.right, target);
    //回溯
    list.remove(list.size()-1);
    return res;
}

25. 复杂链表的复制

题目描述

输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针random指向一个随机节点），请对此链表进行深拷贝，并返回拷贝后的头结点。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）

思路

先在每一个节点的后面复制该节点，然后再对每一个复制的节点的随机指针赋值，最后拆分表

代码实现

public class CloneRandomList {
    public static RandomListNode Clone(RandomListNode pHead){
        if(pHead == null){
            return null;
        }
        //将每一个节点都复制一份放在该节点的后面
        RandomListNode temp = pHead;
        while (temp != null ){
            RandomListNode cur = new RandomListNode(temp.label);
            cur.next = temp.next;
            temp.next = cur;
            temp = temp.next.next;
        }
        //再处理每一个复制节点的随机节点
        temp = pHead;
        while (temp != null){
            temp.next.random = (temp.random==null?null:temp.random.next);
            temp = temp.next.next;
        }
        //拆分表
        temp = pHead;
        RandomListNode clone = pHead.next;
        while (temp != null){
            RandomListNode node = temp.next;
            temp.next = node.next;
            node.next = (node.next == null ? null : node.next.next);
            temp = temp.next;
        }
        return clone;
    }
}

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

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

    public static void show(RandomListNode node){
        while (node!= null){
            System.out.print(node.label + "(" + (node.random==null?null:node.random.label) + ")" + " ");
            node = node.next;
        }
        System.out.println();
    }
}

26. 二叉搜索树与双向链表

题目描述

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

思路

中序遍历是排好序的，找到中序遍历的前一个节点，将当前节点的左节点指向前一个节点，前一个节点的右子树指向当前节点

代码实现

public static TreeNode ConvertBSTToBiList(TreeNode root) {
    //如果传入的节点为空，直接返回
    if(root==null) return null;
    //创建一个栈，用于存放中序遍历
    Stack<TreeNode> stack = new Stack<TreeNode>();
    //当前节点
    TreeNode p = root;
    //当前节点的中序遍历中的前一个节点
    TreeNode pre = null;
    //是否是头节点
    boolean isFirst = true;
    //中序遍历
    while(p!=null||!stack.isEmpty()){
        //将p的左节点依次入栈
        while(p!=null){
            stack.push(p);
            p = p.left;
        }
        //最左的叶子节点出栈
        p = stack.pop();
        if(isFirst){
            //将中序遍历序列中的第一个节点记为root
            root = p;
            pre = root;
            isFirst = false;
        }else{
            pre.right = p;
            p.left = pre;
            pre = p;
        }
        p = p.right;
    }
    return root;
}

//递归写法
public TreeNode Convert(TreeNode root) {
    if(root==null)
        return null;
    if(root.left==null&&root.right==null)
        return root;
    // 1.将左子树构造成双链表，并返回链表头节点
    TreeNode left = Convert(root.left);
    TreeNode p = left;
    // 2.定位至左子树双链表最后一个节点
    while(p!=null&&p.right!=null){
        p = p.right;
    }
    // 3.如果左子树链表不为空的话，将当前root追加到左子树链表
    if(left!=null){
        p.right = root;
        root.left = p;
    }
    // 4.将右子树构造成双链表，并返回链表头节点
    TreeNode right = Convert(root.right);
    // 5.如果右子树链表不为空的话，将该链表追加到root节点之后
    if(right!=null){
        right.left = root;
        root.right = right;
    }
    return left!=null?left:root;       
}

27. 字符串的排列

题目描述

输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。

思路

将每一位的字符与后面的交换；交换完成后需要回溯到交换之前的样子

代码实现

public ArrayList<String> Permutation(String str){
    ArrayList<String> list = new ArrayList<>();
    if(str!=null && str.length()>0){
        PermutationHelper(str.toCharArray(),0,list);
        Collections.sort(list);
    }
    return list;
}

//i表示当前生成的第几位
private void PermutationHelper(char[] chars,int i,ArrayList<String> list){
	//当i==length时，表示已经生成完一个，将结果加入集合	
    if(i == chars.length-1){
        list.add(String.valueOf(chars));
    }else{
        Set<Character> charSet = new HashSet<Character>();
        for(int j=i;j<chars.length;j++){
            if(j==i || !charSet.contains(chars[j])){
                charSet.add(chars[j]);
                swap(chars,i,j);
                PermutationHelper(chars,i+1,list);
                //回溯，回到交换前的状态为了下一次交换
                swap(chars,j,i);
            }
        }
    }
}

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

28. 数组中出现次数超过一半的数字

题目描述

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

思路

使用哈希表，记录每一个数字出现的次数，遇到超过一半就返回结果（如果限定了数字的范围可以用辅助数组）
使用两个辅助遍历，一个记录数字，一个记录次数；从第一个开始遍历，如果前后两个数字相同，次数+1；否则次数-1，当次数变为0时重新指定数字为当前数字，当遍历到最后一位后，数字的内容就可能是结果，最后还需要对结果进行验证

代码实现

public static int MoreThanHalfNum_Solution(int[] array) {
    HashMap<Integer, Integer> map = new HashMap<>();
    if(array.length == 1) return array[0];
    for (int i = 0; i < array.length; i++) {
        if(!map.containsKey(array[i])){
            map.put(array[i], 1);
        }else{
            Integer count = map.get(array[i]);
            if(count+1 > array.length/2){
                return array[i];
            }else{
                map.put(array[i], count+1);
            }
        }
    }
    return 0;
}

public static int MoreThanHalfNum(int[] arr){
    if(arr == null || arr.length == 0) return 0;
    if(arr.length == 1) return arr[0];
    int count = 1;
    int curNum = arr[0];
    for (int i = 1; i < arr.length; i++) {
    	//相同则count++；不同则count--
        if(arr[i] == arr[i-1]){
            count++;
        }else{
            count--;

        }
        //count=0则重新指定curNum
        if(count == 0){
            count = 1;
            curNum = arr[i];
        }
    }
    //验证
    count = 0;
    for (int i = 0; i < arr.length; i++) {
        if(arr[i] == curNum){
            count++;
        }
    }
    return count > arr.length/2 ? curNum : 0;
}

29. 最小的K个数

题目描述

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

思路

使用任意一种排序即可，若是很大的数据，则应该用堆排序
这题使用选择或冒泡，只需比较K轮

代码实现

public static ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
    ArrayList<Integer> list = new ArrayList<>();
    if(k <= 0 || k > input.length) return list;
    for (int i = 0; i < k; i++) {
        int min = input[i];
        for (int j = i; j < input.length; j++) {
            if(input[j] < min){
                min = input[j];
                input[i] = input[i] ^ input[j];
                input[j] = input[i] ^ input[j];
                input[i] = input[i] ^ input[j];
            }
        }
        list.add(min);
    }
    return list;
}

30. 连续子数组的最大和

题目描述

给一个数组，返回它的最大连续子序列的和

思路

使用一个辅助数组，记录包含某一位时的最大和；如果当前数组的第i位的值与辅助数组第i-1位的值相加大于0；则将和赋给辅助数组的第i位；辅助数组最大的值就是最后的结果

代码实现

//这个解法可以通过牛客的，但leetcode那题无法通过
public static int FindGreatestSumOfSubArray(int[] array) {
    int[] dp = new int[array.length];
    dp[0] = array[0];
    int max = dp[0];
    for (int i = 1; i < array.length; i++) {
        if(array[i] + dp[i-1] > 0){
            dp[i] = array[i] + dp[i-1];
            if(dp[i] > max){
                max = dp[i];
            }
        }else{
            //dp[i]>=0，如果到这里来了，array[i]绝对是<0的，防止数组元素全为负数的情况
            if(array[i] > max){
                max = array[i];
            }
            dp[i] = 0;
        }
    }
    return max;
}

//都可以通过的解法
/*
状态转移方程
dp[i-1] > 0 -> dp[i] = dp[i-1] + nums[i];
dp[i-1] < 0 -> dp[i] = nums[i];
*/
public static int maxSubArray(int[] nums) {
    int res = nums[0];
    for(int i = 1; i < nums.length; i++) {
        nums[i] += Math.max(nums[i - 1], 0);
        res = Math.max(res, nums[i]);
    }
    return res;
}

31. 从1到n中1出现的次数

题目描述

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

思路

使用一个辅助数组help[n+1]，记录当前1的个数，help[0] = 0；help[i] = help[i+1] + i中1的个数，最后的help[n]即结果
将每一位都化为字符数组，数里面1的个数

代码实现

//解法1
public static int NumberOf1Between1AndN_Solution(int n){
    int[] help = new int[n+1];
    help[0] = 0;
    for (int i = 1; i <= n; i++) {
        help[i] = help[i-1];
        int cur = i;
        while (cur > 0){
            if(cur%10 == 1){
                help[i] = help[i] + 1;
            }
            cur = cur / 10;
        }
    }
    return help[n];
}
//解法2
public static int NumberOf1Between1AndN_Solution2(int n){
    int count=0;
    while(n>0){
        String str=String.valueOf(n);
        char [] chars=str.toCharArray();
        for(int i=0;i<chars.length;i++){
            if(chars[i]=='1')
                count++;
        }
        n--;
    }
    return count;
}
//解法3
public static int NumberOf1Between1AndN_Solution3(int n) {
	int ones = 0;
	for (int m = 1; m <= n; m *= 10) {
	    ones += (n / m + 8) / 10 * m + (n / m % 10 == 1 ? n / m % 10 : 0) * (n % m + 1);
	}
	return ones;
}

32. 把数组排成最小的数

题目描述

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

思路

写一个排序算法，将这些整数排序，将两个比较的数字转为字符串，分别为前后相加，再比较
如：3与32相比，变为332与323相比，由于323比332小，所以32比3小，应该放在前面

代码实现

public static String PrintMinNumber(int[] numbers) {
    ArrayList<Integer> list = sort(numbers);
    StringBuilder sb = new StringBuilder();
    for (Integer integer : list) {
        sb.append(integer);
    }
    return sb.toString();
}
//排序算法
private static ArrayList<Integer> sort(int[] numbers){
    ArrayList<Integer> list = new ArrayList<>();
    for (int i = 0; i < numbers.length; i++) {
        list.add(numbers[i]);
    }
    list.sort((o1, o2) -> {
                String s1 = o1 + "" + o2;
                String s2 = o2 + "" + o1;
                //return Integer.parseInt(s1) - Integer.parseInt(s2);
                return s1.compareTo(s2);
            }
        );
    return list;
}

33. 丑数

题目描述

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

思路

如果p是丑数，那么p=2^x * 3^y * 5^z；将x，y，z依次递增

代码实现

public static int GetUglyNumber_Solution(int index) {
    if(index <7 ) return index;
    int[] ret = new int[index];
    ret[0]=1;
    int t2=0,t3=0,t5=0;
    for(int i=1;i<index;i++) {
        ret[i] = Math.min(Math.min(ret[t2]*2,ret[t3]*3),ret[t5]*5);
        if(ret[i] == ret[t2]*2) t2++;
        if(ret[i] == ret[t3]*3) t3++;
        if(ret[i] == ret[t5]*5) t5++;
    }
    return ret[index-1];
}

34. 第一个只出现一次的字符

题目描述

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

思路

使用辅助数组help[26]，遍历字符串的每一位字符，记录每一个字符的个数，再重新遍历数组，查看对应字符出现的次数，找出第一个出现一次的次数
使用String类中的split方法，如果只出现一次，那么整个字符串只会被分割成2部分

代码实现

//解法1
public static int FirstNotRepeatingChar1(String str){
    char[] chars = str.toCharArray();
    int[] help = new int[128];
    for (int i = 0; i < chars.length; i++) {
        help[chars[i]]++;
    }
    for (int i = 0; i < chars.length; i++) {
        if(help[chars[i]] == 1){
            return i;
        }
    }
    return -1;
}
//解法2
public static int FirstNotRepeatingChar(String str) {
    if(str == null || str.length() == 0) return -1;
    if(str.length() == 1) return 0;
    str = "0" + str + "0";
    for (int i = 1; i < str.length(); i++) {
        char c = str.charAt(i);
        String[] split = str.split(c + "");
        if(split.length == 2){
            return i-1;
        }
    }
    return -1;
}

35. 数组中的逆序对

题目描述

在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。即输出P%1000000007

思路

暴力求解
归并排序

代码实现

//解法1
public int InversePairs1(int[] array){
    if(array == null || array.length == 0 || array.length == 1){
        return 0;
    }
    int count = 0;
    for (int i = 0; i < array.length - 1; i++) {
        for (int j = i + 1; j < array.length; j++) {
            if(array[j] < array[i]){
                count++;
            }
        }
    }
    return count;
}
//解法2
public static int reversePairs(int[] nums) {
    if (nums.length < 2) {
        return 0;
    }
    int[] copy = Arrays.copyOf(nums, nums.length);
    int[] temp = new int[nums.length];
    return reversePairs(copy, 0, nums.length - 1, temp);
}

private static int reversePairs(int[] nums, int left, int right, int[] temp) {
    if (left == right) {
        return 0;
    }
    int mid = left + (right - left) / 2;
    int leftPairs = reversePairs(nums, left, mid, temp);
    int rightPairs = reversePairs(nums, mid + 1, right, temp);
    if (nums[mid] <= nums[mid + 1]) {
        return leftPairs + rightPairs;
    }
    int crossPairs = mergeAndCount(nums, left, mid, right, temp);
    return leftPairs + rightPairs + crossPairs;
}

private static int mergeAndCount(int[] nums, int left, int mid, int right, int[] temp) {
    for (int i = left; i <= right; i++) {
        temp[i] = nums[i];
    }
    int i = left;
    int j = mid + 1;
    int count = 0;
    for (int k = left; k <= right; k++) {
        if (i == mid + 1) {
            nums[k] = temp[j];
            j++;
        } else if (j == right + 1) {
            nums[k] = temp[i];
            i++;
        } else if (temp[i] <= temp[j]) {
            nums[k] = temp[i];
            i++;
        } else {
            nums[k] = temp[j];
            j++;
            count += (mid - i + 1);
        }
    }
    return count;
}

36. 两个链表的第一个公共结点

题目描述

输入两个链表，找出它们的第一个公共结点。（注意因为传入数据是链表，所以错误测试数据的提示是用其他方式显示的，保证传入数据是正确的）

思路

如果两条链表有交点，则一定呈Y型，让两个指针分别指向两个链表的头部，开始同时遍历链表，如果指针1走到了尾则指针1指向表2的头继续遍历；同理指针2走到尾则指向表1的头继续遍历；同一时刻他们会相较于第一个公共节点
1 -> 2 -> 3 -> 5 -> 6；指针1会遍历1 -> 2 -> 3 -> 5 -> 6 -> 4 -> 5
4 -> 5 -> 6；指针2会遍历4 -> 5 -> 6 -> 1 -> 2 -> 3 -> 5
他们会在第7步的时候相交

代码实现

public static ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2){
    if(pHead1 == null || pHead2 == null) return null;
    ListNode node1 = pHead1;
    ListNode node2 = pHead2;
    while (node1 != node2){
        if(node1.next != null){
            node1 = node1.next;
        }else{
            node1 = pHead2;
        }
        if(node2.next != null){
            node2 = node2.next;
        }else{
            node2 = pHead1;
        }
        if(node1 == pHead2 && node2 == pHead1){
            return null;
        }
    }
    return node1;
}

37. 数字在排序数组中出现的次数

题目描述

统计一个数字在排序数组中出现的次数。

思路

排序数组，想到二分查找法；找到数字以后左右寻找相同数字的个数

代码实现

public static int GetNumberOfK(int [] array , int k) {
    int left = 0;
    int right = array.length-1;
    while (left <= right){
        int mid = (left + right) / 2;
        if(array[mid] == k){
            int count = 1;
            left = mid-1;
            right = mid+1;
            while (left >= 0 && array[left] == k){
                count++;
                left--;
            }
            while (right <= array.length-1 && array[right] == k){
                count++;
                right++;
            }
            return count;
        }
        if(array[mid] > k){
            right = mid - 1;
        }else{
            left = mid + 1;
        }
    }
    return 0;
}

38. 二叉树的深度

题目描述

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

思路

当前树的高度为左子树高度与右子树高度大者+1；如果当前节点为空，则高度为0

代码实现

public static int TreeDepth(TreeNode root) {
	//当前节点为空，则高度为0
    if(root == null) return 0;
    //左子树高度与右子树高度大者+1
    return Math.max(TreeDepth(root.left), TreeDepth(root.right))+1;
}

39. 平衡二叉树

题目描述

输入一棵二叉树，判断该二叉树是否是平衡二叉树。在这里，我们只需要考虑其平衡性，不需要考虑其是不是排序二叉树

思路

平衡二叉树的左右子树仍然是平衡二叉树；平衡二叉树的左右子树高度差不大于1

代码实现

public static boolean IsBalanced_Solution(TreeNode root) {
    if(root == null) return true;
    if(IsBalanced_Solution(root.left) && IsBalanced_Solution(root.right) && Math.abs(TreeDepth(root.right)-TreeDepth(root.left)) <= 1){
        return true;
    }else{
        return false;
    }
}

private static int TreeDepth(TreeNode root) {
    if(root == null) return 0;
    return Math.max(TreeDepth(root.left), TreeDepth(root.right))+1;
}

40. 数组中只出现一次的数字

题目描述

一个整型数组里除了两个数字之外，其他的数字都出现了两次。请写程序找出这两个只出现一次的数字。
num1,num2分别为长度为1的数组。传出参数；将num1[0],num2[0]设置为返回结果

思路

使用HashSet去重，Set中没有这个值则添加，有则移除，最后Set中只剩下2个数即结果
使用异或，根据异或的性质，相同的数异或为0，任何数与0异或就是其本身；所以，将上述所有的数异或，得到的结果就是只出现一次的两个数的异或结果，异或的结果为相同为0，不同为1，所以处理得到的两个数异或的结果，取二进制中某一位为1的位，根据这一位是否位1，可以将数组分为2部分，一组的数字该位为1，另一组该为不为1；且结果的两个数分别在两个数组中，再次异或两个数组，得到两个数组的结果即最终的结果

代码实现

//解法1
public static void FindNumsAppearOnce(int[] array,int num1[] , int num2[]) {
    HashSet<Integer> set = new HashSet<>();
    for (int i = 0; i < array.length; i++) {
        if(!set.contains(array[i])){
            set.add(array[i]);
        }else{
            set.remove(array[i]);
        }
    }
    Integer next = set.iterator().next();
    num1[0] = next;
    set.remove(next);
    num2[0] = set.iterator().next();
}
//解法2
public static void FindNumsAppearOnce(int[] array,int num1[] , int num2[]){
    int[] help1 = new int[array.length];
    int[] help2 = new int[array.length];
    //先将所有的数异或
    int sum = 0;
    for (int i = 0; i < array.length; i++) {
        sum = sum ^ array[i];
    }
    //找到sum某一位为1的位
    int i = 0;
    while ((sum & (1 << i)) == 0){
        i++;
    }
    int k = 0;
    int l = 0;
    for (int j = 0; j < array.length; j++) {
        if((array[j] & (1 << i)) == 0){
            help1[k++] = array[j];
        }else{
            help2[l++] = array[j];
        }
    }
    int ans1 = 0;
    int ans2 = 0;
    for (int j = 0; j < help1.length; j++) {
        ans1 ^= help1[j];
    }
    for (int j = 0; j < help2.length; j++) {
        ans2 ^= help2[j];
    }
    num1[0] = ans1;
    num2[0] = ans2;
}

41. 和为S的连续正数序列

题目描述

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

思路

创建一个辅助数组help[]，记录每一位对应的0到该位的和，只需要记录到sum的一半+1处，后面的2个数加起来一定会大于sum；然后从第i位往后找，找到第j位使得help[j]-help[i]=sum，将i到j的值加入list中

代码实现

public static ArrayList<ArrayList<Integer>> FindContinuousSequence(int sum){
    int[] help = new int[sum / 2 + 2];
    help[0] = 0;
    for (int i = 1; i < sum / 2 + 2; i++) {
        help[i] = help[i-1] + i;
    }
    ArrayList<ArrayList<Integer>> res = new ArrayList<>();
    for (int i = 0; i < sum / 2 + 1; i++) {
        for (int j = i+2; j < sum / 2 + 2; j++) {
            if(help[j] - help[i] == sum){
                ArrayList<Integer> list = new ArrayList<>();
                for (int k = i+1; k <= j; k++) {
                    list.add(k);
                }
                res.add(list);
            }
        }
    }
    return res;
}

/*
如果有两个连续的数之和等于target，那么相差为1， (target - 1) % 2 == 0，
且数组一定是从 (target - 1) / 2开始的，数组的元素就是2个；
如果是3个连续的数组，那么三个数之间相差为1、2，(target - 1 - 2) % 3 == 0，
且数组一定是从 (target - 1 - 2) / 3开始的，数组元素是3个，
依次类推，但是注意target必须是大于0的数，且res需要倒序。
* */
public static int[][] findContinuousSequence(int target) {
    List<int[]> result = new ArrayList<>();
    int i = 1;
    while(target > 0) {
        target -= i++;
        if(target > 0 && target % i == 0) {
            int[] array = new int[i];
            for(int k = target/i, j = 0; k < target/i+i; k++,j++) {
                array[j] = k;
            }
            result.add(array);
        }
    }
    Collections.reverse(result);
    return result.toArray(new int[0][]);
}

42. 和为S的两个数字

题目描述

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

思路

和相同，两个数中小的数更小的则乘积更小（2+8=10；3+7=10，4+6=10；2 * 8 < 3 * 7 < 4 * 6）
由于数组是有序的，只需使用两个指针，分别指向头和尾，开始比较和与目标的大小，和比目标小，移动前面的指针，比目标大，移动后面的指针，遇到第一个相同的则直接输出

代码实现

public static ArrayList<Integer> FindNumbersWithSum(int[] array, int sum) {
    ArrayList<Integer> list = new ArrayList<>();
    int left = 0;
    int right = array.length-1;
    while (left <= right){
        if(array[left] + array[right] == sum){
            list.add(array[left]);
            list.add(array[right]);
            return list;
        }else if(array[left] + array[right] < sum){
            left++;
        }else {
            right--;
        }
    }
    return list;
}

43. 左旋转字符串

题目描述

汇编语言中有一种移位指令叫做循环左移（ROL），现在有个简单的任务，就是用字符串模拟这个指令的运算结果。对于一个给定的字符序列S，请你把其循环左移K位后的序列输出。例如，字符序列S=”abcXYZdef”,要求输出循环左移3位后的结果，即“XYZdefabc”。是不是很简单？OK，搞定它！

思路

左移n位的n大于了S的长度，则左移的位数等价于n=n%S.length；将S复制一份加到原S的后面，然后从第n位开始截取S.length的长度

代码实现

public static String LeftRotateString(String str,int n){
	if(str == null || str.length()== 0) {
        return str;
    }
    int length = str.length();
    if(n > str.length()){
        n = n % str.length();
    }
    str = str + str;
    //return str.substring(n, n+length);
    StringBuilder sb = new StringBuilder();
    char[] chars = str.toCharArray();
    for (int i = 0; i < length; i++) {
        sb.append(chars[i+n]);
    }
    return sb.toString();   
}

44. 翻转单词顺序列

题目描述

牛客最近来了一个新员工Fish，每天早晨总是会拿着一本英文杂志，写些句子在本子上。同事Cat对Fish写的内容颇感兴趣，有一天他向Fish借来翻看，但却读不懂它的意思。例如，“student. a am I”。后来才意识到，这家伙原来把句子单词的顺序翻转了，正确的句子应该是“I am a student.”。Cat对一一的翻转这些单词顺序可不在行，你能帮助他么？

思路

将字符串依据空格分为字符串数组，然后将字符串数组反转，按要求输出结果

代码实现

public static String ReverseSentence(String str) {
    if(str.trim().equals("")) return str;
    StringBuilder sb = new StringBuilder();
    String[] s = str.split(" ");
    int left = 0;
    int right = s.length-1;
    while (left < right){
        String temp = s[left];
        s[left] = s[right];
        s[right] = temp;
        left++;
        right--;
    }
    for (int i = 0; i < s.length - 1; i++) {
        sb.append(s[i] + " ");
    }
    sb.append(s[s.length-1]);
    return sb.toString();
}

45. 扑克牌顺子

题目描述

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

思路

所有牌的序号为0到13，创建一个大小为14的int数组help，记录抽出的牌中每一张牌的个数，如果记录到某个大于0的数的个数大于1，则说明不可能是顺子了；然后找到help第一位以后的数组中中第一个1与最后一个1的位置，相减，如果长度比抽取的牌的张数大则不能构成，小或等于则可以构成

代码实现

public static boolean isContinuous(int[] numbers){
    if(numbers == null || numbers.length == 0){
        return false;
    }
    if(numbers.length == 1){
        return true;
    }
    int[] help = new int[14];
    for (int i = 0; i < numbers.length; i++) {
        help[numbers[i]]++;
        //某张不为大小王的牌有2张，不能构成顺子
        if(numbers[i] != 0 && help[numbers[i]] > 1){
            return false;
        }
    }
    //left和right分别代表最效地牌和最大的牌
    int left = 1;
    int right = help.length - 1;
    while (help[left] == 0){
        left++;
    }
    while (help[right] == 0){
        right--;
    }
    System.out.println(left + "  " + right);
    //抽到的牌的跨度与牌的张数相比较
    if(right - left + 1 <= numbers.length){
        return true;
    }else{
        return false;
    }
}

46. 孩子们的游戏(圆圈中最后剩下的数)

题目描述

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

思路

循环队列每m位出队找到最后一个数；n代表初始队列的大小，m表示每m个数出队一次

每一次出队的下标为（start + m - 1）% n；队列只有一个数字时就时结果
递归 (LastRemaining_Solution1(n-1,m) + m) % n

代码实现

//解法1，使用循环链表
public static int LastRemaining_Solution(int n, int m) {
    if(n==0) return -1;
    LinkedList<Integer> list = new LinkedList<>();
    //n个数字入队
    for (int i = 0; i < n; i ++) {
        list.add(i);
    }
    //从最开头开始
    int start = 0;
    while (list.size() != 1) {
        start = (start + m - 1) % list.size();
        list.remove(start);
    }
    return list.get(0);
}
//解法2，使用递归
public static int LastRemaining_Solution1(int n, int m) {
    if(n==0){
        return -1;
    }
    if(n==1){
        return 0;
    }else{
    	//（上一个的结果+m）% n
        return (LastRemaining_Solution1(n-1,m) + m) % n;
    }
}

//反推
public int lastRemaining(int n, int m) {
    if(n == 1) return 0;
    int ans = 0;
    // 最后一轮剩下2个人，所以从2开始反推
    for (int i = 2; i <= n; i++) {
        ans = (ans + m) % i;
    }
    return ans;
}

47. 求1+2+3+…+n

题目描述

求1+2+3+…+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A ? B : C）

思路

1+2+3+…+n = (n*(n+1)) / 2 = (n^2 + n) / 2 == (Math.pow(n,2) + n) >> 1

代码实现

public static int Sum_Solution(int n) {
    return (int) (Math.pow(n, 2) + n) >> 1;
}

public static int sumNums(int n) {
    boolean flag = (n > 0) && ((n += sumNums(n-1)) > 0);
    return n;
}

48. 不用加减乘除做加法

题目描述

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

思路

两个数异或，相当于不进位加法；与0异或还是本身
两个数相与，相当于找到那些相同位都为1的数，左移一位相当于进位

代码实现

public static int Add(int num1,int num2) {
    while( num2!=0 ){
        //两个数异或，相当于不进位加法
        int sum = num1 ^ num2;
        //两个数相与，相当于找到那些相同位都为1的数，左移一位相当于进位
        int carray = (num1 & num2) << 1;
        num1 = sum;
        num2 = carray;
    }
    return num1;
}

49. 把字符串转换成整数

题目描述

将一个字符串转换成一个整数，要求不能使用字符串转换整数的库函数。数值为0或者字符串不是一个合法的数值则返回0
输入描述：输入一个字符串,包括数字字母符号,可以为空
输出描述：如果是合法的数值表达则返回该数字，否则返回0

思路

首先要判断第一位是不是数字或者正负号，不是则直接返回0
然后从第一位数字开始，每一位的结果等于上一位*10 + 这一位；如果中间有某一位不是数字，则返回0

代码实现

public static int StrToInt(String str) {
    if(str==null || str.length()==0){
        return 0;
    }
    //防止计算时越界，使用long型
    long res = 0;
    char start = str.charAt(0);
    boolean flag = true;
    //判断第一位的符号
    if(start == '-' || start == '+'){
        str = str.substring(1);
        if(start == '-'){
            flag = false;
        }
    }
    for (int i = 0; i < str.length(); i++) {
        if(str.charAt(i) > '9' || str.charAt(i) < '0'){
            return 0;
        }
        res = res*10 + (str.charAt(i)-'0');
    }
    if(!flag) {
        return -res<Integer.MIN_VALUE ? 0: (int)-res;
    }else{
        return res>Integer.MAX_VALUE ? 0: (int)res;
    }
}

50. 数组中重复的数字

题目描述

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

思路

能使用数组建议不要使用HashMap；当知道数的范围是确定时，使用辅助数组
创建一个大小为n的辅助数组；记录每一个数出现的次数，当某一个数次数为2时，直接返回

代码实现

/*
numbers[]：输入数组
length：传入数组的长度
duplication：大小为1的数组，记录第一个重复的数字
返回值为boolean，有数据重复则返回true
*/
public static boolean duplicate(int numbers[],int length,int[] duplication) {
    int[] dp = new int[length];
    for (int i = 0; i < length; i++) {
        if(dp[numbers[i]] == 1){
            duplication[0] = numbers[i];
            return true;
        }else{
            dp[numbers[i]] = 1;
        }
    }
    return false;
}

51. 构建乘积数组

题目描述

给定一个数组A[0,1,…,n-1],请构建一个数组B[0,1,…,n-1],其中B中的元素B[i]=A[0] * A[1] *… * A[i-1] * A[i+1] * … * A[n-1]。不能使用除法。（注意：规定B[0] = A[1] * A[2] * … * A[n-1]，B[n-1] = A[0] * A[1] * … * A[n-2];）

思路

使用两个辅助数组

代码实现

public static int[] multiply(int[] A) {
    int[] B = new int[A.length];
    int[] left = new int[A.length];
    int[] right = new int[A.length];
    left[0] = A[0];
    for (int i = 1; i < A.length; i++) {
        left[i] = left[i-1] * A[i];
    }
    right[A.length-1] = A[A.length-1];
    for (int i = A.length-2; i >= 0; i--) {
        right[i] = right[i+1] * A[i];
    }
    for (int i = 0; i < B.length; i++) {
        if (i == 0) {
            B[i] = right[1];
        } else if (i == B.length - 1) {
            B[i] = left[B.length - 2];
        } else {
            B[i] = left[i - 1] * right[i + 1];
        }
    }
    return B;
}

52. 正则表达式匹配

题目描述

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

思路

当模式中的第二个字符不是“ * ”时：
1、如果字符串第一个字符和模式中的第一个字符相匹配，那么字符串和模式都后移一个字符，然后匹配剩余的。
2、如果字符串第一个字符和模式中的第一个字符相不匹配，直接返回false。
而当模式中的第二个字符是“ * ”时：
如果字符串第一个字符跟模式第一个字符不匹配，则模式后移2个字符，继续匹配。如果字符串第一个字符跟模式第一个字符匹配，可以有3种匹配方式：
1、模式后移2字符，相当于x被忽略；
2、字符串后移1字符，模式后移2字符；
3、字符串后移1字符，模式不变，即继续匹配字符下一位，因为可以匹配多位；

代码实现

//str：要匹配的字符串；pattern：模式串
public static boolean match(char[] str, char[] pattern) {
    if (str == null || pattern == null) {
        return false;
    }
    int strIndex = 0;
    int patternIndex = 0;
    return matchCore(str, strIndex, pattern, patternIndex);
}

public static boolean matchCore(char[] str, int strIndex, char[] pattern, int patternIndex) {
    //有效性检验：str到尾，pattern到尾，匹配成功
    if (strIndex == str.length && patternIndex == pattern.length) {
        return true;
    }
    //pattern先到尾，匹配失败
    if (strIndex != str.length && patternIndex == pattern.length) {
        return false;
    }
    //模式第2个是*，且字符串第1个跟模式第1个匹配,分3种匹配模式；如不匹配，模式后移2位
    if (patternIndex + 1 < pattern.length && pattern[patternIndex + 1] == '*') {
        if ((strIndex != str.length && pattern[patternIndex] == str[strIndex]) || (pattern[patternIndex] == '.' && strIndex != str.length)) {
            return matchCore(str, strIndex, pattern, patternIndex + 2)//模式后移2，视为x*匹配0个字符
                    || matchCore(str, strIndex + 1, pattern, patternIndex + 2)//视为模式匹配1个字符
                    || matchCore(str, strIndex + 1, pattern, patternIndex);//*匹配1个，再匹配str中的下一个
        } else {
            return matchCore(str, strIndex, pattern, patternIndex + 2);
        }
    }
    //模式第2个不是*，且字符串第1个跟模式第1个匹配，则都后移1位，否则直接返回false
    if ((strIndex != str.length && pattern[patternIndex] == str[strIndex]) || (pattern[patternIndex] == '.' && strIndex != str.length)) {
        return matchCore(str, strIndex + 1, pattern, patternIndex + 1);
    }
    return false;
}

53. 表示数值的字符串

题目描述

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

思路

字符串中只能包含正负号、数字、E/e和.
其中+/-只能存在于第一位或者E/e后的一位
E/e必须在数字的后面；E/e后面不能有.
.不能为第一位
在正则表达式中

d代表数字
*代表匹配前面的子表达式任意次
\代表转义
?前面的表达式表示匹配1次或0次
[xyz]代表匹配xyz中的任意一个字符
+代表匹配前面的子表达式至少一次

代码实现

public static boolean isNumeric(char[] str) {
    String string = String.valueOf(str);
    /*
		[\\+\\-]?代表匹配+/-号中任意一个1次或0次
		\\d*代表匹配任意个数字
		(\\.\\d+)?代表匹配.，但是前面必须有数字
		[eE]代表匹配e或E1次或0次；外面的大括号有？，如果？匹配一次，则必须有E或e，所以[eE]没有？
		\\e/E后面d+必须至少有一个数字
	*/
    return string.matches("[\\+\\-]?\\d*(\\.\\d+)?([eE][\\+\\-]?\\d+)?");
}

54. 字符流中第一个不重复的字符

题目描述

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

思路

使用一个128位的辅助数组，对应ASCII集，统计每个字符出现的次数
然后取原字符串开始找到第一个只出现一次的字符

代码实现

public static char FirstAppearingOnce(String s) {
    int[] help = new int[128];
    for (int i = 0; i < s.length(); i++) {
        if(help[s.charAt(i)] == 0){
            help[s.charAt(i)] = 1;
        }else{
            help[s.charAt(i)]++;
        }
    }
    //System.out.println(Arrays.toString(help));
    for (int i = 0; i < s.length(); i++) {
        if(help[s.charAt(i)]==1){
            return s.charAt(i);
        }
    }
    return '#';
}

55. 链表中环的入口结点

题目描述

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

思路

快慢指针，一个移动一格，一个移动两格，相遇则说明有环
一个指针指向头，另一个指向相遇的地方；开始移动，相遇的地方即是环的入口

代码实现

public static ListNode EntryNodeOfLoop(ListNode pHead){
    if(pHead == null || pHead.next == null) return null;
    ListNode fast = pHead;
    ListNode slow = pHead;
    //判断是否有环
    while(fast != null && fast.next !=null){
        fast = fast.next.next;
        slow = slow.next;
        if(fast == slow)
            break;
    }
    if(fast == null || fast.next == null) {
        return null;
    }
    fast = pHead;
    while(fast != slow){
        fast = fast.next;
        slow = slow.next;
    }
    return fast;
}

56. 删除链表中重复的结点

题目描述

在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。例如，链表1->2->3->3->4->4->5 处理后为 1->2->5

思路

找到每一个节点的下一个不同数值的节点

代码实现

public static ListNode deleteDuplication(ListNode pHead) {
    if (pHead == null || pHead.next == null) {
        return pHead;
    }
    ListNode Head = new ListNode(0);
    Head.next = pHead;
    ListNode pre = Head;
    ListNode last = Head.next;
    while (last != null) {
        if (last.next != null && last.val == last.next.val) {
            // 找到最后的一个相同节点
            while (last.next != null && last.val == last.next.val) {
                last = last.next;
            }
            pre.next = last.next;
            last = last.next;
        } else {
            pre = pre.next;
            last = last.next;
        }
    }
    return Head.next;
}

57. 二叉树的下一个结点

题目描述

给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。

思路

分析二叉树的下一个节点，一共有以下情况：
1.二叉树为空，则返回空；
2.节点右孩子存在，则设置一个指针从该节点的右孩子出发，一直沿着指向左子结点的指针找到的叶子节点即为下一个节点；
3.节点不是根节点。如果该节点是其父节点的左孩子，则返回父节点；否则继续向上遍历其父节点的父节点，重复之前的判断，返回结果。

代码实现

class TreeLinkNode {
    int val;
    TreeLinkNode(int val) {
        this.val = val;
    }
    TreeLinkNode left = null;
    TreeLinkNode right = null;
    TreeLinkNode next = null;
}

public TreeLinkNode GetNext(TreeLinkNode pNode) {
	//二叉树为空，则返回空；
    if(pNode==null)
        return null;
    //节点右孩子存在
    if(pNode.right!=null){
        pNode=pNode.right;
        while(pNode.left!=null)
            pNode=pNode.left;
        return pNode;
    }
    while(pNode.next!=null){
        TreeLinkNode proot=pNode.next;
        if(proot.left==pNode)
            return proot;
        pNode=pNode.next;
    }
    return null;
}

58. 对称的二叉树

题目描述

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

思路

递归：需要满足节点的左左等于右右，左右等于右左
DFS：使用栈，成对插入和删除左右节点

代码实现

//思路1
public static boolean isSymmetrical(TreeNode pRoot) {
    if(pRoot == null){
        return true;
    }
    return isSymmetrical(pRoot.left, pRoot.right);
}
private static boolean isSymmetrical(TreeNode left, TreeNode right) {
    if(left == null && right == null) return true;
    //判断这一条说明上一条不成立，说明两个节点至少有一个不是null，下面判断的是其中是否有null
    if(left == null || right == null) return false;
    //要满足：1.值相等；2.左左等于右右；3.左右等于右左
    return (left.val == right.val) &&
            isSymmetrical(left.left, right.right) &&
            isSymmetrical(left.right, right.left);
}
//思路2
public static boolean isSymmetrical1(TreeNode pRoot){
    if (pRoot == null) return true;
    //辅助栈
    Stack<TreeNode> stack = new Stack<>();
    //成对入栈
    stack.push(pRoot.left);
    stack.push(pRoot.right);
    while (!stack.empty()){
        //成对出栈
        TreeNode left = stack.pop();
        TreeNode right = stack.pop();
        //判断left和right
        if(left == null && right == null) continue;
        if(left == null || right == null) return false;
        if(left.val != right.val) return false;
        //成对插入
        stack.push(left.left);
        stack.push(right.right);
        //成对插入
        stack.push(left.right);
        stack.push(right.left);
    }
    return true;
}

59. 按之字形顺序打印二叉树

题目描述

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

思路

使用两个辅助栈，按行分为奇数栈和偶数栈
然后处理每一行，奇数行的子节点压入偶数栈，先左后右；偶数行的子节点压入奇数栈，先右后左

代码实现

public static ArrayList<ArrayList<Integer>> Print(TreeNode pRoot) {
    //判断奇偶行
    int line = 1;
    //两个栈，分别存奇偶行的数据
    Stack<TreeNode> odd = new Stack<>();
    Stack<TreeNode> even = new Stack<>();
    //先将根节点放到奇数行栈
    odd.push(pRoot);
    //结果集
    ArrayList<ArrayList<Integer>> res = new ArrayList<>();
    //入栈操作
    while (!odd.empty() || !even.empty()){
        ArrayList<Integer> list;
        if(line % 2 != 0){ //奇数行
            list = new ArrayList<>();
            while (!odd.empty()){
                TreeNode node = odd.pop();
                if(node != null){
                    list.add(node.val);
                    //奇数行的子节点加入偶数行，先左后右
                    even.push(node.left);
                    even.push(node.right);
                }
            }
            if(!list.isEmpty()){
                res.add(list);
                line++;
            }
        }else{//偶数行
            list = new ArrayList<>();
            while (!even.empty()){
                TreeNode node = even.pop();
                if(node != null){
                    list.add(node.val);
                    //偶数行的子节点加入奇数行，先右后左
                    odd.push(node.right);
                    odd.push(node.left);
                }
            }
            if (!list.isEmpty()){
                res.add(list);
                line++;
            }
        }
    }
    return res;
}

60. 把二叉树打印成多行

题目描述

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

思路

与上题相识，使用两个队列

代码实现

public static ArrayList<ArrayList<Integer>> Print(TreeNode pRoot) {
    ArrayList<ArrayList<Integer>> res = new ArrayList<>();
    int line = 1;
    //两个队列
    ArrayDeque<TreeNode> odd = new ArrayDeque<>();
    ArrayDeque<TreeNode> even = new ArrayDeque<>();
    if(pRoot == null) return res;
    odd.add(pRoot);
    while (!odd.isEmpty() || !even.isEmpty()){
        ArrayList<Integer> list;
        if(line % 2 != 0){
            list = new ArrayList<>();
            while (!odd.isEmpty()) {
                TreeNode node = odd.poll();
                if (node != null) {
                    list.add(node.val);
                    if(node.left != null){
                        even.add(node.left);
                    }
                    if(node.right != null){
                        even.add(node.right);
                    }
                }
            }
            if(!list.isEmpty()){
                res.add(list);
                line++;
            }
        }else{
            list = new ArrayList<>();
            while (!even.isEmpty()) {
                TreeNode node = even.poll();
                if (node != null) {
                    list.add(node.val);
                    if(node.left != null){
                        odd.add(node.left);
                    }
                    if(node.right != null){
                        odd.add(node.right);
                    }
                }
            }
            if(!list.isEmpty()){
                res.add(list);
                line++;
            }
        }
    }
    return res;
}

61. 序列化二叉树

题目描述

请实现两个函数，分别用来序列化和反序列化二叉树
二叉树的序列化是指：把一棵二叉树按照某种遍历方式的结果以某种格式保存为字符串，从而使得内存中建立起来的二叉树可以持久保存。序列化可以基于先序、中序、后序、层序的二叉树遍历方式来进行修改，序列化的结果是一个字符串，序列化时通过某种符号表示空节点（#），以！表示一个结点值的结束（value!）。
二叉树的反序列化是指：根据某种遍历顺序得到的序列化字符串结果str，重构二叉树。
例如，我们可以把一个只有根节点为1的二叉树序列化为"1,"，然后通过自己的函数来解析回这个二叉树

思路

用先序遍历保存节点

代码实现

public static String Serialize(TreeNode root) {
    StringBuffer sb = new StringBuffer();
    if(root == null){
        sb.append("#,");
        return sb.toString();
    }
    //先序遍历保存
    sb.append(root.val + ",");
    sb.append(Serialize(root.left));
    sb.append(Serialize(root.right));
    return sb.toString();
}

public static int index = -1;
public static TreeNode Deserialize(String str) {
    index++;
    int len = str.length();
    if(index >= len){
        return null;
    }
    String[] strr = str.split(",");
    TreeNode node = null;
    if(!strr[index].equals("#")){
        node = new TreeNode(Integer.valueOf(strr[index]));
        node.left = Deserialize(str);
        node.right = Deserialize(str);
    }

    return node;
}

62. 二叉搜索树的第k个结点

题目描述

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

思路

二叉搜索树的中序遍历是排好序的，所以用非递归遍历的方式找到第k个数就行

代码实现

public static TreeNode KthNode(TreeNode pRoot, int k) {
    int cnt = 1;
    if(pRoot==null) return null;
    Stack<TreeNode> stack = new Stack<>();
    TreeNode p = pRoot;
    while (p !=null || !stack.empty()){
        while(p != null){
            stack.push(p);
            p = p.left;
        }
        TreeNode pop = stack.pop();
        if(cnt == k){
            return pop;
        }
        cnt++;
        p = pop.right;
    }
    return null;
}

63. 数据流中的中位数

题目描述

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

思路

使用Java中的PriorityQueue来设置一个大顶堆和一个小顶堆；大顶堆用来存较小的数，从大到小排；小顶堆存较大的数，从小到大顺序排列；显然中位数就是大顶堆的根节点与小顶堆的根节点的和的平均数。
保证：

小顶堆中的元素都大于等于大顶堆中的元素，所以每次塞值，并不是直接塞进去，而是从另一个堆中poll出一个最大（最小）的塞值
当数目为偶数的时候，将这个值插入大顶堆中，再将大顶堆中根节点（即最大值）插入到小顶堆中；
当数目为奇数的时候，将这个值插入小顶堆中，再讲小顶堆中根节点（即最小值）插入到大顶堆中；
取中位数的时候，如果当前个数为偶数，显然是取小顶堆和大顶堆根结点的平均值；如果当前个数为奇数，显然是取小顶堆的根节点

代码实现

//小顶堆
private static PriorityQueue<Integer> minHeap = new PriorityQueue<>();

//大顶堆
private static PriorityQueue<Integer> maxHeap = new PriorityQueue<>(15, (o1, o2) -> o2 - o1);

//记录偶数个还是奇数个
static int count = 0;

//每次插入小顶堆的是当前大顶堆中最大的数
//每次插入大顶堆的是当前小顶堆中最小的数
//这样保证小顶堆中的数永远大于等于大顶堆中的数
//中位数就可以方便地从两者的根结点中获取了
public static void Insert(Integer num) {
    //个数为偶数的话，则先插入到大顶堆，然后将大顶堆中最大的数插入小顶堆中
    if(count % 2 == 0){
        maxHeap.offer(num);
        int max = maxHeap.poll();
        minHeap.offer(max);
    }else{
        //个数为奇数的话，则先插入到小顶堆，然后将小顶堆中最小的数插入大顶堆中
        minHeap.offer(num);
        int min = minHeap.poll();
        maxHeap.offer(min);
    }
    count++;
}

public static Double GetMedian() {
    //当前为偶数个，则取小顶堆和大顶堆的堆顶元素求平均
    if(count % 2 == 0){
        return new Double(minHeap.peek() + maxHeap.peek())/2;
    }else{
        //当前为奇数个，则直接从小顶堆中取元素即可
        return new Double(minHeap.peek());
    }
}

64. 滑动窗口的最大值

题目描述

给定一个数组和滑动窗口的大小，找出所有滑动窗口里数值的最大值。例如，如果输入数组{2,3,4,2,6,2,5,1}及滑动窗口的大小3，那么一共存在6个滑动窗口，他们的最大值分别为{4,4,6,6,6,5}；针对数组{2,3,4,2,6,2,5,1}的滑动窗口有以下6个： {[2,3,4],2,6,2,5,1}， {2,[3,4,2],6,2,5,1}， {2,3,[4,2,6],2,5,1}， {2,3,4,[2,6,2],5,1}， {2,3,4,2,[6,2,5],1}， {2,3,4,2,6,[2,5,1]}。

思路

用一个双端队列，队列第一个位置保存当前窗口的最大值，当窗口滑动一次
1.判断当前最大值是否过期
2.新增加的值从队尾开始比较，把所有比他小的值丢掉

代码实现

public static ArrayList<Integer> maxInWindows1(int[] num, int size){
    ArrayList<Integer> res = new ArrayList<>();
    if(num == null || num.length == 0 || size == 0 || size > num.length) return res;
    //创建一个双端队列,队列第一个位置保存当前窗口的最大值
    ArrayDeque<Integer> deque = new ArrayDeque<>();
    //begin是用于保存当前窗口的第一个值在原始数组中的下标
    int begin;
    //窗口滑动
    for(int i = 0; i < num.length; i++){
        begin = i - size + 1;
        if(deque.isEmpty()) {
            deque.add(i);
        } else if(begin > deque.peekFirst()) { //判断当前最大值是否过期
            deque.pollFirst();
        }
        //新增加的值从队尾开始比较，把所有比他小的值丢掉
        while((!deque.isEmpty()) && num[deque.peekLast()] <= num[i]) {
            deque.pollLast();
        }
        deque.add(i);
        if(begin >= 0) {
            res.add(num[deque.peekFirst()]);
        }
    }
    return res;
}

65. 矩阵中的路径

题目描述

请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一个格子开始，每一步可以在矩阵中向左，向右，向上，向下移动一个格子。如果一条路径经过了矩阵中的某一个格子，则该路径不能再进入该格子。

思路

回溯
基本思想：
0.根据给定数组，初始化一个标志位数组，初始化为false，表示未走过，true表示已经走过，不能走第二次
1.根据行数和列数，遍历数组，先找到一个与str字符串的第一个元素相匹配的矩阵元素，进入judge
2.根据i和j先确定一维数组的位置，因为给定的matrix是一个一维数组
3.确定递归终止条件：越界，当前找到的矩阵值不等于数组对应位置的值，已经走过的，这三类情况，都直接false，说明这条路不通
4.若k，就是待判定的字符串str的索引已经判断到了最后一位，此时说明是匹配成功的
5.下面就是本题的精髓，递归不断地寻找周围四个格子是否符合条件，只要有一个格子符合条件，就继续再找这个符合条件的格子的四周是否存在符合条件的格子，直到k到达末尾或者不满足递归条件就停止。
6.走到这一步，说明本次是不成功的，我们要还原一下标志位数组index处的标志位，进入下一轮的判断。

代码实现

public boolean hasPath(char[] matrix, int rows, int cols, char[] str){
    //标志位，用来标记当前位是否已经走过
    boolean[] flag = new boolean[matrix.length];
    //遍历数组，找到第一个匹配的位置
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            if(judge(matrix, rows, cols, i, j, str, flag, 0)){
                return true;
            }
        }
    }
    return false;
}

//judge(判断矩阵， 行， 列， 当前行， 当前列， 匹配字符数组， 标志数组， 当前匹配的字符数)
private boolean judge(char[] matrix, int rows, int cols, int i, int j, char[] str, boolean[] flag, int k) {
    //计算当前i，j在matrix中的位置
    int index = i*cols + j;
    //没找到
    if(i < 0 || j < 0 || i >= rows || j >= cols || matrix[index] != str[k] || flag[index] == true){
        return false;
    }
    //找到了
    if(k == str.length - 1){
        return true;
    }
    //将该位标记
    flag[index] = true;
    //判断下一步往哪走
    if(judge(matrix, rows, cols, i+1, j, str, flag, k+1) ||
       judge(matrix, rows, cols, i-1, j, str, flag, k+1) ||
       judge(matrix, rows, cols, i, j-1, str, flag, k+1) ||
       judge(matrix, rows, cols, i, j+1, str, flag, k+1)){
        return true;
    }
    //没有找到；回溯
    flag[index] = false;
    return false;
}

66. 机器人的运动范围

题目描述

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

思路

使用一个二维数组，记录每一位是否可以走；可以就将二维数组的该位置为1；然后结果等于四个方向各自可以走的个数+当前位置(1)

代码实现

public int movingCount(int threshold, int rows, int cols) {
    //记录每一格是否已经走过
    int[][] flag = new int[rows][cols];
    //从0，0开始走
    return jugde(threshold, rows, cols, 0, 0, flag);
}

private int jugde(int threshold, int rows, int cols, int i, int j, int[][] flag) {
    //不满足条件
    if(i < 0 || i >= rows || j < 0 || j >= cols || flag[i][j] == 1 || sum(i) + sum(j) > threshold){
        return 0;
    }
    flag[i][j] = 1;
    //每一步向不同方向可以走的格子数+当前的格子(1)
    return jugde(threshold, rows, cols, i+1, j, flag) +
            jugde(threshold, rows, cols, i-1, j, flag) +
            jugde(threshold, rows, cols, i, j-1, flag) +
            jugde(threshold, rows, cols, i, j+1, flag) + 1;
}

private int sum(int num){
    int res = 0;
    while (num / 10 > 0){
        res += num % 10;
        num = num / 10;
    }
    res += num;
    return res;
}

67. 剪绳子

题目描述

给你一根长度为n的绳子，请把绳子剪成整数长的m段（m、n都是整数，n>1并且m>1），每段绳子的长度记为k[0],k[1],…,k[m]。请问k[0]xk[1]x…xk[m]可能的最大乘积是多少？例如，当绳子的长度是8时，我们把它剪成长度分别为2、3、3的三段，此时得到的最大乘积是18。（2 <= n <= 60）

思路

最终会将绳子分为若干个3和0/1/2个2；3尽可能多；考虑以下情况

n % 3 == 0；可以全部分成3，这是最大的
n % 3 == 1；相当于n==4，此时分为22>13，所所以分为2*2
n % 3 == 2；相当于n==2，此时直接不分
但是当n ==2或n ==3时，必须分为，所以2和3是两个特例

代码实现

public int cutRope(int target) {
	//target==2或3时只有一种剪法
    if(target == 2) return 1;
    if(target == 3) return 2;
    int x = target / 3;
    int y = target % 3;
    if(y == 0){//target>3并且可以全部分为3
        return (int) Math.pow(3, x);
    }else if(y == 1){//y == 1说明target最后剩余4；2 * 2 > 1 * 3
        return 2 * 2 * (int) Math.pow(3, x - 1);
    }else{//y == 1说明target最后剩余2；2 > 1 * 1
        return 2 * (int) Math.pow(3, x);
    }
}

lovelin07

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
2
评论
剑指offer刷题笔记

1. 二维数组中的查找题目描述：在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。思路先找到所在的行，再找到所在的列代码实现public static boolean Find(int target, int [][] array){ //边界条件，当target<最小或target>最大时，直接返回false
复制链接

扫一扫