剑指offer

2018-2-25

面试题7：重建二叉树

根据前序遍历和中序遍历重建二叉树。

思路：根据前序遍历第一个作为根节点，在中序遍历中划分为左子树和右子树。递归处理。

边界判断需要小心。

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
        if (pre == null || in == null || pre.length != in.length) {
            return null;
        }
        TreeNode res = reConstr(pre, 0, pre.length - 1, in, 0, in.length - 1);
        return res;
    }
    private TreeNode reConstr(int[] pre,int startPre, int endPre, int[] in, int startIn,int endIn) {
        if ((startPre > endPre) || (startIn > endIn)) {
            return null;
        }
        int node = pre[startPre];
        int pos = startIn;
        for (int i = startIn; i <= endIn; i++) {
            if (in[i] == node) {
                pos = i;
                break;
            }
        }
        TreeNode res = new TreeNode(pre[startPre]);
        int countLeft = pos - startIn;
        res.left = reConstr(pre, startPre + 1, startPre + countLeft,in, startIn, pos - 1);
        res.right = reConstr(pre,startPre + countLeft + 1, endPre,in,pos + 1, endIn);
        return res;
    }
}

面试题8：二叉树的下一个节点

给定二叉树和其中一个节点，找出中序遍历的下一个节点。（有指向父节点的指针）

思路：思路要清晰

中序遍历：左-中-右

①判空

②如果该节点存在右子树，则返回右子树

③不存在右子树，则往上找，直到找到一个点，是其父节点的左节点，返回该父节点。

④找到根节点都不存在这样的父节点，则说明该点是最后一个点，返回空。

/*
public class TreeLinkNode {
    int val;
    TreeLinkNode left = null;
    TreeLinkNode right = null;
    TreeLinkNode next = null;

    TreeLinkNode(int val) {
        this.val = val;
    }
}
*/
public class Solution {
    public TreeLinkNode GetNext(TreeLinkNode pNode)
    {
        if (pNode == null) {
            return null;
        }
        if (pNode.right != null) {
            TreeLinkNode temp = pNode.right;
            while (temp != null && temp.left != null) {
                temp = temp.left;
            }
            return temp;
        }
        if (pNode.next != null && pNode.next.left == pNode) {
            return pNode.next;
        }
        while (pNode.next != null && pNode.next.right == pNode) {
            pNode = pNode.next;
        }
        if (pNode.next == null) {
            return null;
        }
        return pNode.next;
        
    }
}

我的写法，太复杂，而且会出现空指针异常，因为比如 if (pNode.next != null && pNode.next.left == pNode)

需要先判断pNode.next是否为空，才能判断pNode.next.left

答案写法：

链接：https://www.nowcoder.net/questionTerminal/9023a0c988684a53960365b889ceaf5e
来源：牛客网

public class Solution {
    TreeLinkNode GetNext(TreeLinkNode node)
    {
        if(node==null) return null;
        if(node.right!=null){    //如果有右子树，则找右子树的最左节点
            node = node.right;
            while(node.left!=null) node = node.left;
            return node;
        }
        while(node.next!=null){ //没右子树，则找第一个当前节点是父节点左孩子的节点
            if(node.next.left==node) return node.next;
            node = node.next;
        }
        return null;   //退到了根节点仍没找到，则返回null
    }
}

 面试题9：用两个栈实现队列

思路：不需要每次都倒腾过去。

push进stack1，pop可以pop到stack2中，从stack2取。

但是只要stack2不空，就可以一直从stack2取，push进去放入stack1。

2018-2-6

面试题10：斐波那契数列

①递归做法：n的指数上升。

②动态规划：T: O(n)　　S:O(1)

f[0] = 0　　f[1] = 1　　f[n] = f[n-1]+f[n-2]

public class Solution {
    public int Fibonacci(int n) {
        if (n <= 1) {
            return n;
        }
        int[] f = new int[n];
        f[0] = 0;
        f[1] = 1;
        for (int i = 2; i < n; i++) {
            f[i] = f[i - 1] + f[i - 2];
        }
        return f[n - 1] + f[n - 2];
    }
}

虽然是用动态规划做，但是不需要新建那么大的数组空间int[] f = new int[n];仅需要fn-2 fn-1两个变量即可。

public class Solution {
    public int Fibonacci(int n) {
        if (n < 2) {
            return n;
        }
        int fnMinus1 = 1;
        int fnMinus2 = 0;
        int fn = 1;
        for (int i = 2; i <= n; i++) {
            fn = fnMinus1 + fnMinus2;
            fnMinus2 = fnMinus1; //先改fnMinus2！
            fnMinus1 = fn;
        }
        return fn;
    }
}

③数学公式　　T：O(logn)

 2018-2-8

面试题11：旋转数组的最小数字

面试题12：矩阵中的路径

答案的dfs做法

public class Solution {
    public boolean hasPath(char[] matrix, int rows, int cols, char[] str)
    {
        if(matrix == null || matrix.length < rows * cols || str.length > matrix.length) {
            return false;
        }
        boolean visited[] = new boolean[rows * cols];
        //初始化
        for (int i = 0; i < rows * cols; i++) {
            visited[i] = false;
        }
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                if (hasPoint(matrix, visited, rows, cols, i, j, str, 0)){
                    return true;
                }
            }
        }
        return false;
    }
    private boolean hasPoint(char[] matrix, boolean[] visited, int rows, int cols, int r, int c, char[] str, int index) {

        if ((r >= 0 )&& (c >= 0) &&( r < rows) && (c < cols) &&
            (visited[r * cols + c] == false) && 
            (matrix[r * cols + c] == str[index])) {
            if (index == (str.length - 1)) {
                return true;
            }
            visited[r * cols + c] = true;
            
            boolean hasPath = false;
            index++;
            hasPath = hasPoint(matrix, visited, rows, cols, r + 1, c, str, index) ||
                      hasPoint(matrix, visited, rows, cols, r - 1, c, str, index) ||
                      hasPoint(matrix, visited, rows, cols, r, c + 1, str, index) ||
                      hasPoint(matrix, visited, rows, cols, r, c - 1, str, index);
            if (hasPath) {
                return true;
            } else {
                visited[r * cols + c] = false;
            }
        }
        return false;
    }


}

面试题13：机器人的运动范围

我的bfs做法

import java.util.*;
public class Solution {
    class Point{
        int x;
        int y;
        public Point(int a, int b) {
            x = a;
            y = b;
        }
    }
    public int movingCount(int threshold, int rows, int cols)
    {
        int count = 0;
        if (rows <= 0 || cols <= 0) {
            return 0;
        }
        boolean visited[][] = new boolean[rows][cols];//!!!忘记，默认初始false
        int[] deltaX ={0, 0, 1, -1};
        int[] deltaY ={1, -1, 0, 0};
        Queue<Point> queue = new LinkedList<>();
        Point p = new Point(0, 0);
        if (threshold >= 0) {
            queue.add(p);
            visited[0][0] = true;//!!!忘记，时刻记着queue.add和visited一起做出改动
        }
            
        
        while (!queue.isEmpty()) {
            Point temp = queue.poll();//not pop
            count++;
            for (int i = 0; i < 4; i++) {
                Point nextPoint = new Point(temp.x + deltaX[i], temp.y + deltaY[i]);
                if (isValid(nextPoint, rows, cols, threshold, visited)) {
                    queue.add(nextPoint);
                    visited[nextPoint.x][nextPoint.y] = true;
                    
                }
            }
        }
        return count;
        
        
    }
    private boolean isValid(Point point, int rows, int cols, int threshold, boolean[][] visited) {
        if (point.x >= 0 && point.x < rows 
            && point.y >=0 && point.y < cols 
            && (visited[point.x][point.y] == false)
            && (countSum(point) <= threshold)) {
            return true;
        }else {
            return false;
        }
    }
    private int countSum(Point p) {
        int count = 0;
        int x = p.x;
        int y = p.y;
        while (x != 0) {
            count += x % 10;
            x = x / 10;
        }
        while (y != 0) {
            count += y % 10;
            y = y / 10;
        }
        return count;
    }
}

回溯法（答案dfs）

public class Solution {
    public int movingCount(int threshold, int rows, int cols)
    {
        if (threshold < 0 || rows < 0 || cols < 0) {
            return 0;
        }
        boolean[][] visited = new boolean[rows][cols];
        return dfs(threshold, rows, cols, 0, 0, visited);
        
    }
    private int dfs(int threshold, int rows, int cols, int r, int c, boolean[][] visited) {
        int sum = 0;
        if (r >= 0 && c >= 0 && r < rows && c < cols && visited[r][c] == false && (count(r) + count(c)) <= threshold) {
            visited[r][c] = true;
            sum = dfs(threshold, rows, cols, r + 1, c, visited) +
                dfs(threshold, rows, cols, r - 1, c, visited) +
                dfs(threshold, rows, cols, r , c + 1, visited) +
                dfs(threshold, rows, cols, r , c - 1, visited) + 1;
        }
        return sum;
    }
    private int count(int x) {
        int c = 0;
        while (x != 0) {
            c += x % 10;
            x = x / 10;
        }
        return c;
    }
}

 面试题15：二进制中1的个数

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

 面试题16：数值的整数次方->时间复杂度O(logn)

　　思路：

　　①判断边界，判断底数base是否为0，double类型不可直接==.

　　　　当底数为0且指数<0时

　　　　会出现对0求倒数的情况，需进行错误处理，设置一个全局变量

　　　　　　0的0次幂和0的负次幂在数学是都是没有定义的

　　②幂正负分情况

　　③快速幂 

　　　　　　aⁿ = a^n/2 * a^n/2    n是偶数

　　　　　　aⁿ = a^n/2 * a^n/2 * a   n是奇数

　　④exponent >>1 除2写法

　　⑤判断奇偶：(exponent &0x1 == 1)

public class Solution {
    public double Power(double base, int exponent) {
        if (equal(base, 0.0)&&exponent < 0) {
            return 0.0;//无意义，可讨论
        }
        if (exponent == 0) {
            return 1;
        }
        int n = Math.abs(exponent);
        double res = Power(base, n >> 1);
        if ((n & 0x1) == 1) {
            if (exponent > 0) {
                return res * res * base;
            } else {
                return 1 / (res * res * base);
            }
        } else {
            if (exponent > 0) {
                return res * res;
            } else {
                return 1 / (res * res);
            }
        }

  }
    private boolean equal(double a, double b) {
        if (Math.abs(a - b) < 0.001) {
            return true;
        }
        return false;
    }
}

稍显复杂

public class Solution {
    public double Power(double base, int exponent) {
        if (equal(base, 0.0)&&exponent < 0) {
            return 0.0;//无意义，可讨论
        }
        if (exponent < 0) {
            exponent = exponent * (-1);
            return 1 / help(base, exponent);
        }
        return help(base, exponent);
  }
    private double help(double base, int exponent) {
        if (exponent == 1) {
            return base;
        }
        if (exponent == 0) {
            return 1;
        }
        double res = help(base, exponent >> 1);
        res = res * res;
        if ((exponent & 0x1) == 1) {
            return res * base;
        } else {
            return res;
        }
    }
    private boolean equal(double a, double b) {
        if (Math.abs(a - b) < 0.001) {
            return true;
        }
        return false;
    }
}

分出来写比较好

double浮点数判断相等

①
final double epsilon = 0.001;
if(Math.abs(double_x - 0) < epsilon)
{
    return true;
}
②
if(Double.doubleToLongBits(double_x) == Double.doubleToLongBits(double_y))

面试题18：删除链表的节点

/*
 public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}
*/
public class Solution {
    public ListNode deleteDuplication(ListNode pHead)
    {
        if (pHead == null) {
            return null;
        } 
        ListNode dummy = new ListNode(0);
        dummy.next = pHead;
        ListNode pre = dummy;
        ListNode cur = pHead;
        ListNode next = cur.next;
        while (next != null) {
            while (next!= null && next.val == cur.val) {
                cur = next;
                next = next.next;
                pre.next = cur;
            }
            if (next != null) {
                pre = cur;
                cur = next;
                next = next.next;
            } else {
                return dummy.next;
            }
            
        }
        return dummy.next;

    }
}

错误的解法，懒得看了。重写

面试题21：调整数组顺序使奇数位于偶数前面

public class Solution {
    public void reOrderArray(int [] array) {
        if (array == null || array.length == 0) {
            return;
        }
        int left = 0;
        int right = 0;
        while (left < array.length) {
            if (array[left] % 2 == 0) {
                right = left + 1;
                while (right < array.length && array[right] % 2 == 0) {
                    right++;
                }
                int temp = array[left];
                array[left] = array[right];
                array[right] = temp;
                left = right;
            } else {
                left++;
            }
        }
    }
}

错误写法。

面试题19：正则表达式匹配

public class Solution {
    public boolean match(char[] str, char[] pattern)
    {
        if(str == null && pattern == null) {
            return true;
        } 
        if (str.length == 0 && pattern.length == 0) {
            return true;
        }
        if (pattern.length == 2 && pattern[0] == '.' && pattern[1] == '*') {
            return true;
        }
        if (str.length == 0 && pattern.length == 2 && pattern[1] == '*') {
            return true;
        }
        if (str == null || pattern == null || str.length == 0 || pattern.length == 0) {
            return false;
        }

        int i = 0;
        int j = 0;
        while (i < str.length && j < pattern.length) {
            if (pattern[j] == '.' || (str[i] == pattern[j])) {
                i++;
                j++;
            } else if(str[i] != pattern[j] && (j + 1) < pattern.length && pattern[j + 1] == '*') {
                //i++; 不用 分析清楚
                j = j + 2;
            } else if (pattern[j] == '*' && str[i] == pattern[j - 1]) {
                i++;
            } else if (pattern[j] == '*' && (j + 1) < pattern.length && str[i] == pattern[j + 1]) {
                j++;
            }
            // bbbba      .*a*b        ‘.*’是个大麻烦
            else if (str[i] != pattern[j] && pattern[j] == '.' && pattern[j + 1] == '*') {
                
            } else {
                return false;
            }
        }
        if (i == str.length) {
            if (j == pattern.length || (j < pattern.length && pattern[j] == '*') || (j == (pattern.length - 2) && pattern[j + 1] == '*')) {
                 return true;
            }
           
        }
        return false;
    }
}

乱写的一堆。

2018-2-14

面试题19：表示数值的字符串

面试题20：正则表达式

面试题27：对称的二叉树

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

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

    }

}
*/
public class Solution {
    boolean isSymmetrical(TreeNode pRoot)
    {
        if (pRoot == null) {
            return true;
        }
        return isSym(pRoot.left, pRoot.right);
    }
    private boolean isSym(TreeNode left, TreeNode right) {
        if (left == null && right == null) {
            return true;
        }
        if (left == null) {
            return false;
        }
        if (right == null) {
            return false;
        }
        if (left.val == right.val) {
            return isSym(left.left, right.right) && isSym(left.right, right.left);
        }
        return false;
    }
}

还是有点糊里糊涂。

面试题30：包含main函数的栈

import java.util.Stack;

public class Solution {

    Stack<Integer> stack = new Stack<>();
    Stack<Integer> minStack = new Stack<>();
    public void push(int node) {
        if (stack.isEmpty()) {
            stack.push(node);
            minStack.push(node);
        } else {
            stack.push(node);
            if (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 int min() {
        return minStack.peek();
    }
}

不用每个都加一次

import java.util.Stack;

public class Solution {

    Stack<Integer> stack = new Stack<>();
    Stack<Integer> minStack = new Stack<>();
    public void push(int node) {
        if (stack.isEmpty()) {
            stack.push(node);
            minStack.push(node);
        } else {
            stack.push(node);
            if (node < minStack.peek()) {
                minStack.push(node);
            } 
        }
    }
    
    public void pop() {
        int node = stack.pop();
        if (node <= minStack.peek()) {
            if (stack.peek() > minStack.peek()) {
                minStack.pop();
            }
        }
    }
    
    public int top() {
        return stack.peek();
    }
    
    public int min() {
        return minStack.peek();
    }
}

面试题34：二叉树中和为某一值的路径

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

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

    }

}
*/
public class Solution {
    public ArrayList<ArrayList<Integer>> FindPath(TreeNode root, int target) {
        ArrayList<ArrayList<Integer>> paths = new ArrayList<>();
        if (root == null) {
            return paths;
        }
        
        ArrayList<Integer> path = new ArrayList<>();
        help(root, target, paths, path);
        return paths;
    }
    private void help(TreeNode root, int target, ArrayList<ArrayList<Integer>> paths, ArrayList<Integer> path) {
        //这样写有问题，叶子的 左null 右null会放入两次
        //测试用例:{10,5,12,4,7},22
        //对应输出应该为:[[10,5,7],[10,12]]
        //你的输出为:[[10,5,7],[10,5,7],[10,12],[10,12]]
        //if (target == 0 && root == null) { //从根到叶不能断
        //    paths.add(new ArrayList<Integer>(path));
        //    return;
        //}
        if (target < 0 || root == null) {
            return;
        }
        if (target == root.val && root.left == null && root.right == null) {
            path.add(root.val);
            paths.add(new ArrayList<Integer>(path));
            path.remove(path.size() - 1);
            return;
        }
        path.add(root.val);
        help(root.left, target - root.val, paths, path);
        help(root.right, target - root.val, paths, path);
        path.remove(path.size() - 1);
    }
}

面试题35：复杂链表的复制

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

    RandomListNode(int label) {
        this.label = label;
    }
}
*/
public class Solution {
    public RandomListNode Clone(RandomListNode pHead)
    {
        if (pHead == null) {
            return null;
        }
        RandomListNode cur = pHead;
        while (cur != null) {
            RandomListNode temp = new RandomListNode(cur.label);
            temp.next = cur.next;
            cur.next = temp;
            cur = temp.next;
        }
        cur = pHead;
        while (cur != null) {
            if (cur.random != null) {
                cur.next.random = cur.random.next;
            }
            cur = cur.next.next;
        }
        RandomListNode copyHead = pHead.next;
        cur = pHead;
        RandomListNode copyCur = copyHead;
        while (copyCur.next != null) { //这个判断条件就这么简单，要好好想想
            cur.next = cur.next.next;
            copyCur.next = copyCur.next.next;
            cur = cur.next;
            copyCur = copyCur.next;
        }
        cur.next = null; //最后一个的判断要注意
        return copyHead;
    }
}

1->1'->2->2'->null

因为cur = 1, copyCur = 1',

cur = cur.next.next;　　cur.next一定存在

但是copyCur.next可能为null，所以while条件是copyCur.next != null

出来时cur=2， copycur = 2',所以要把cur.next = null

面试题37：序列化二叉树

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

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

    }

}
*/
import java.util.*;
public class Solution {
    String Serialize(TreeNode root) {
        if (root == null) {
            return "{}";
        }
        Queue<TreeNode>  queue = new LinkedList<>();
        queue.add(root);
        StringBuffer sb = new StringBuffer();
        sb.append("{");
        while (!queue.isEmpty()) {
            TreeNode temp = queue.poll();
            if (temp != null) {
                sb.append(temp.val);
                sb.append(",");
                queue.add(temp.left);
                queue.add(temp.right);
            } else {
                sb.append("#,");
            }
        }
        sb.deleteCharAt(sb.length() - 1);
        sb.append("}");
        return sb.toString();
  }
    TreeNode Deserialize(String str) {
       if (str == null || str.length() == 0 || str.equals("{}")) {
           return null;
       }
        str = str.substring(1, str.length() - 1);
       String[] array = str.split(",");
       TreeNode root = new TreeNode(Integer.parseInt(array[0]));
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
       int i = 1;
       while (!queue.isEmpty()) {
           TreeNode temp = queue.poll();
           if ("#".equals(array[i])) {
               temp.left = null;
           } else {
               TreeNode leftNode = new TreeNode(Integer.parseInt(array[i]));
               temp.left = leftNode;
               queue.add(leftNode);
           }
           i++;
           if ("#".equals(array[i])) {
               temp.right = null;
           } else {
               TreeNode rightNode = new TreeNode(Integer.parseInt(array[i]));
               temp.right = rightNode;
               queue.add(rightNode);
           }
           i++;
       }
        return root;
  }
}

str = str.substring(1, str.length() - 1);
String：[] array = str.split(",");

 连续子数组的最大和

public class Solution {
    public int FindGreatestSumOfSubArray(int[] array) {
        if (array == null || array.length == 0) {
            return 0;
        }
        int max = Integer.MIN_VALUE;
        int sum = 0;
        for (int i = 0; i < array.length; i++) {
            if (sum < 0) {
                sum = 0;
            }
            sum = sum + array[i];                       
            if (sum > max) {
                max = sum;
            }
        }
        return max;
    }
}

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

import java.util.*;
public class Solution {
    public int MoreThanHalfNum_Solution(int [] array) {
        if (array == null || array.length == 0) {
             return 0;
        }
        if (array.length == 1) {
            return array[0];
        }
        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
        int length = array.length / 2;
        for (int i = 0; i < array.length; i++) {
            if (map.containsKey(array[i])) {

                map.put(array[i], map.get(array[i]) + 1);
                if (map.get(array[i]) > length) {
                    return array[i];
                }
            } else {
                map.put(array[i], 1);
            }
        }
        return 0;
    }
}

最小的k个数

import java.util.*;
public class Solution {
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        ArrayList<Integer> res = new ArrayList<>();
        if (input == null || input.length < k) {
            return res;
        }
        PriorityQueue<Integer> minPq = new PriorityQueue<>();
        for (int i = 0; i < input.length; i++) {
            minPq.offer(input[i]);
        }
        for (int i = 0; i < k; i++){
            res.add(minPq.poll());
        }
        return res;
    }
}

答案

public class Solution {
    public int MoreThanHalfNum_Solution(int [] array) {
        if (array == null || array.length == 0) {
            return 0;
        }
        int res = array[0];
        int count = 1;
        for (int i = 1; i < array.length; i++) {
            if (array[i] != array[i - 1]) {
                count--;
            } else {
                count++;
            }
            if (count == 0) {
                count  = 1;
                res = array[i];
            }
        }
            //check
        int doubleCount = 0;
        for (int i = 0; i < array.length; i++) {
            if (array[i] == res) {
                doubleCount++;
            }
         }
         if (doubleCount > array.length / 2) {
             return res;
         } 
         return 0;
    }
}