剑指Offer题目描述+答案(Java版)

leetcode全部Accept的

4二维数组的查找

题目描述：在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入一个二维数组和一个整数，判断数组中是否含有该整数。

该题leetcode地址：二维数组中的查找

示例：
1 2 8 9
2 4 9 12
4 7 10 13
6 8 11 15
查找整数7返回true，查找数字5返回false

/**
 *	暴力解时间复杂度O(mn)
 *	由于该数组从左上角到右下角递增
 *	从左上角或者右下角开始查询，每次都可以排除一列或这一行
 *	时间复杂度为O(m+n)，空间复杂度为O(1)
 */
public boolean findNumberIn2DArray(int[][] matrix, int target) {
   
    if(matrix.length==0 || matrix[0].length==0){
   
        return false;
    }
    int i=0,j=matrix[0].length-1;
    while(i<matrix.length && j>=0){
   
        if(matrix[i][j] == target){
   
            return true;
        }else if(matrix[i][j] > target){
   
            j--;
        }else{
   
            i++;
        }
    }
    return false;
}

5.字符串：替换空格

请实现一个函数，把字符串 s 中的每个空格替换成"%20"。

该题leetcode地址：替换空格

示例：

输入：s = “We are happy.”
输出：“We%20are%20happy.”

/**
 * 在原字符串上操作
 */
public String replaceSpace(StringBuffer str) {
   
    int index;
    while((index = str.indexOf(" "))!=-1){
   
        str.deleteCharAt(index);
        str.insert(index,"%20");
    }
    return str.toString();
}
/*
 *另开一个辅助的StringBuilder
 */
public String replaceSpace(String s) {
   
        if(s.length()==0){
   
            return "";
        }
        StringBuilder res = new StringBuilder();
        for(int i=0;i<s.length();i++){
   
            if(s.charAt(i) == ' '){
   
                res.append("%20");
        	}else{
   
            res.append(s.charAt(i));
        }
    }
    return res.toString();
}
/**
 *在原数组上操作，遇到空格后逐一插入%20
 */
public String replaceSpace1(StringBuffer str) {
   
    int spaceNum = 0;
    for(int i=0;i<str.length();i++){
   
        if(str.charAt(i)==' '){
   
            spaceNum++;
        }
    }
    int lengthOld = str.length();
    int lengthNew = lengthOld + spaceNum*2;
    str.setLength(lengthNew);
    int indexOld = lengthOld-1;
    int indexNew = lengthNew-1;
    while(indexNew!=indexOld&&indexNew>=0&&indexOld>=0){
   
        if(str.charAt(indexOld)==' '){
   
            str.setCharAt(indexNew--,'0');
            str.setCharAt(indexNew--,'2');
            str.setCharAt(indexNew--,'%');
        }else{
   
            str.setCharAt(indexNew--, str.charAt(indexOld));
        }
        indexOld--;
    }
    return str.toString();
}

6.链表：从尾到头打印链表

输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。

该题leetcode地址：从尾到头打印链表

示例：

输入：head = [1,3,2]
输出：[2,3,1]

/**
 * 首先想到用栈来实现，时间复杂度为O(n)，空间复杂度为O(n)
 */
public int[] reversePrint(ListNode head) {
   
    Deque<Integer> stack = new LinkedList<Integer>();
    while(head != null) {
   
        stack.addLast(head.val);
        head = head.next;
    }
    int[] res = new int[stack.size()];
    for(int i = 0; i < res.length; i++)
        res[i] = stack.removeLast();
    return res;
}
/*
 * 其次，也可以用递归，和栈的时间复杂都一样
 */
public int[] reversePrint(ListNode head) {
   
    if (head == null) {
   
        return new int[0];
    }
	//中间辅助数组res，将链表的逆序值暂存
    List<Integer> res = new ArrayList<>();
    //递归
    printListFromTailToHead(head, res);

    // 把 res中的值转到题目要求的int[]
    int size = res.size();
    int[] resArray = new int[size];
    for (int i = 0; i < size; i++) {
   
        resArray[i] = res.get(i);
    }
    return resArray;
}

private void printListFromTailToHead(ListNode node, List<Integer> res) {
   
    if (node == null) {
   
        return;
    }
    // 如果有后继结点，就一直递归下去
    if (node.next != null) {
   
        printListFromTailToHead(node.next, res);
    }
    // 把当前结点的值添加到结果列表中
    res.add(node.val);
}
/*
 *  以上两种都在不改变原链表的情况下使用辅助空间完成
 *  若可以更改原链表，直接反转原链表则不需要额外的空间
 *  即空间复杂度为O(1)，时间复杂度为O(n)
 */
public int[] reversePrint(ListNode head) {
   
    //反转之后的头节点
    ListNode headRev;
    if(head==null || head.next==null){
   
        headRev = head;
    }
    int count = 1;
    ListNode pre = null, cur = head;
    while(cur!=null){
   
        ListNode next = cur.next;
        cur.next = pre;
        pre = cur;
        cur = next;
        count++;
    }
    headRev = pre;
 	//遍历反转之后的链表
    int[] res = new int[count-1];
    for(int i=0;i<count&&headRev!=null;i++){
   
        res[i] = headRev.val;
        headRev = headRev.next;
    }
    return res;
}

7.二叉树：重建二叉树

输入某二叉树的前序遍历和中序遍历的结果，请重建该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。

该题leetcode地址：重建二叉树

示例：

前序遍历 preorder = [3,9,20,15,7]
中序遍历 inorder = [9,3,15,20,7]

返回根节点。

/**
 * 根据前序遍历和中序遍历结果构建二叉树，返回根节点
 * 递归
 */
public TreeNode buildTree(int[] preorder, int[] inorder) {
   
    if(preorder.length==0 || inorder.length==0){
   
        return null;
    }
    return buildHelper(preorder,inorder,0,preorder.length-1,0,inorder.length-1);
}
public TreeNode buildHelper(int [] pre,int [] in,int startPre,int endPre, int startIn,int endIn){
   
    //以前序遍历集合的第一个节点为当前子树的根节点
    TreeNode cur = new TreeNode(pre[startPre]);
    //初始化当前子树的根节点
    cur.left = null;
    cur.right = null;
    //如果某一子树的中序遍历和前序遍历数组中只剩一个节点
    //那么这个唯一的节点就是该子树的根节点，并返回当前子树
    if(endIn==startIn && endPre==startPre){
   
        return cur;
    }
    int si = startIn;
    //找出cur在当前子树中序遍历数组中的位置
    while(si <= endIn){
   
        if(in[si] == pre[startPre]){
   
            break;
        }
        si++;
    }
    //计算出以cur为根节点的左子树的节点个数
    //分别截出该子树的中序遍历和前序遍历数组
    int leftLen = si - startIn;
    if(leftLen>0){
   
        cur.left = buildHelper(pre,in,startPre+1,startPre+leftLen,startIn,si-1);
    }
    //右子树节点个数
    int rightLen = endIn - si;
    if(rightLen>0){
   
        cur.right = buildHelper(pre,in,startPre+1+leftLen,endPre,si+1,endIn);
    }
    return cur;
}

8.二叉树：二叉树的下一节点

找出二叉树中序遍历的后续结点，有父指针

根据中序遍历的特点，某一结点中序遍历的后续节点只有以下几种可能
(1)当该节点为有右孩子时
中序遍历后续节点为 该节点右孩子的最左子孙节点
(2)当该节点没有右孩子且又是其父节点的左孩子时
中序遍历后续节点为 该节点的父节点
(3)当该节点没有右孩子且又是其父节点的右孩子时
找到该节点的最近祖宗节点（该祖宗节点是某一几点的左孩子），若向上遍历到的根节点，则该节点没有中序遍历后续节点。

TreeNode getNext(TreeNode pNode){
   
    if(pNode == null){
   
        return null;
    }
    TreeNode pNext = null;
    if(pNode.right != null){
   
        TreeNode pRight = pNode.right;
        while(pRight.left != null){
     //寻找右孩子最左下的子孙节点
            pRight = pRight.left;
        }
        pNext = pRight;
    }else if(pNode.parent!=null){
   
        TreeNode pParent = pNode.parent;
        TreeNode pCurrent = pNode;
        //跳出循环的条件，要么找到一个最近的为左孩子的祖宗节点
        //或者遍历到根节点，把根节点的父节点即null赋值给pNext
        while(pParent != null && pCurrent == pParent.right){
   //当该节点是其父节点的右孩子时进入循环
            pCurrent = pParent;             
            pParent = pParent.parent;         
        }
        pNext = pParent;
    }
    return pNext;
}