《剑指Offer》笔记2.3

数据结构

• 4 二维数组中的查找
• 5 替换空格
• 6 从尾到头打印链表
• 7 重建二叉树
• 8 二叉树的下一个节点
• 9 用两个栈实现队列

---

4：二位数组中的查找

题目：

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

 

思路：

首先选取数组中右上角（左下角）的数字。如果该数字等于要查找的数字，则查找过程结束；如果该数字大于要从查找的数字，则剔除这个数字所在的列；如果该数字小于要查找的数字，则剔除这个数字所在的行。直到找到要查找的数字，或者查找范围为空。

public class Solution {
    public boolean Find(int target, int [][] array) {
        int row = 0;
        int col = array[0].length-1;
        while  (row <= array.length-1 && col >= 0){
            if (array[row][col] == target)
                return true;
            else if (array[row][col] > target) // 剔除这个数字所在的列
                col--;
            else // 剔除这个数字所在的行
                row++;
        }
        return false;
    }
}

5：替换空格

题目：

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

 

思路：

1. 从头到尾扫描字符串，每次碰到空格字符的时候进行替换。由于是把1个字符替换成3个字符，我们必须要把空格后面所有的字符都后移2字节，否则就有两个字符被覆盖了。假设字符串的长度是n。对每个空格字符，需要移动后面O(n)个字符，因此对于含有O(n)个空格字符的字符串而言，总的时间效率是O(n2)。
2. 先遍历一次字符串，这样就能统计出字符串中空格的总数并可以由此计算出替换之后的字符串的总长度。每替换一个空格，长度增加2，因此替换以后字符串的长度等于原来的长度加上2乘以空格数目。然后从字符串的后面开始复制和替换。首先准备两个指针：P1和P2（P1指向原始字符串的末尾，而P2指向替换之后的字符串的末尾）。接下来向前移动指针P1，逐个把它指向的字符复制到P2指向的位置，如果碰到空格，逐个添加指定内容，然后继续操作。所有的字符都只复制（移动）一次，因此这个算法的时间效率是O(n)，比第一个思路要快。

public class Solution {
    public String replaceSpace(StringBuffer str) {
        int spaceNum = 0;
        for(int i=0;i<str.length();i++) {
            if(str.charAt(i) == ' ')
                spaceNum++;
        }
        int indexOld = str.length() - 1; // P1 指针
        int newLength = str.length() + spaceNum*2;
        int indexNew = newLength-1; // P2 指针
        str.setLength(newLength);
        // 倒序复制
        while(indexOld>=0 && indexOld < newLength) {
            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：从尾到头打印链表

题目：

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

 

思路：

这是一个典型的“后进先出”，可以用栈实现这个顺序。每经过一个节点的时候，把该节点放到一个栈中。当便利完整个链表后，再从栈顶开始逐个输出节点的值。

/**
*    public class ListNode {
*        int val;
*        ListNode next = null;
*
*        ListNode(int val) {
*            this.val = val;
*        }
*    }
*
*/
import java.util.ArrayList;
import java.util.Stack;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> ans = new ArrayList<>();
        Stack<Integer> s = new Stack<>();
        ListNode node = listNode;
        while (node !=null ) {
            s.push(node.val);
            node = node.next;
        }
        while(!s.isEmpty()) {
            ans.add(s.pop());
        }
        return ans;
    }
}


// java 递归超简洁版本
public class Solution {
    ArrayList<Integer> arrayList=new ArrayList<Integer>();
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        if(listNode!=null){
            this.printListFromTailToHead(listNode.next);
            arrayList.add(listNode.val);
        }
        return arrayList;
    }
}

7：重建二叉树

题目：

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

 

思路：

前序遍历序列的第一个数字1就是根节点的值。扫描中序遍历序列，就能确定根节点的值的位置。根据中序遍历的特点，在根节点的值1前面的3个数字都是左子树节点的值，位于1后面的4个数字都是右子树节点的值。同样，在前序遍历序列中，根节点后面的3个数字就是3个左子树节点的值，再后面的所有数字都是右子树节点的值。

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
import java.util.Arrays;
public class Solution {
    public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
        if(pre.length == 0)
            return null;
        
        TreeNode root = new TreeNode(pre[0]);
        if(pre.length == 1)
            return root;
        
        // 确定前序和中序中左子树和右子树序列的范围
        int rootIdx = 0;
        for(;rootIdx<in.length;rootIdx++){
            if(in[rootIdx] == pre[0])
                break;
        }
        
        root.left = reConstructBinaryTree(Arrays.copyOfRange(pre, 1, rootIdx+1),
                                         Arrays.copyOfRange(in, 0, rootIdx));
        root.right = reConstructBinaryTree(Arrays.copyOfRange(pre, rootIdx+1, pre.length),
                                          Arrays.copyOfRange(in, rootIdx+1, pre.length));
        return root;
    }
}

8：二叉树的下一个节点

题目：

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

 

思路：

1. 节点是否有右子树

1. 有，那么它的下一个节点就是它的右子树中最左子节点。
2. 无，考虑节点是否为它父节点的左子节点。
   1. 是，下一个节点就是父节点
   2. 否，沿着指向父节点的指针一直向上遍历，直到找到一个是它父节点的左子节点的节点。如果这样的节点存在，那么这个节点的父节点就是我们要找的下一个节点。

/**
 * 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;
        // 情况 1-1
        if(pNode.right != null) {
            pNode = pNode.right;
            while(pNode.left != null)
                pNode = pNode.left;
            return pNode;
        }
        // 情况 1-2-1,2
        while(pNode.next != null) {
            if(pNode.next.left == pNode)
                return pNode.next;
            pNode = pNode.next;
        }
        return null;
    }
}

9：用两个栈实现队列

题目：

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

思路：

pop时只从stack2中取值，如果stack2取完，再从stack1中补充

import java.util.Stack;

public class Solution {
    Stack<Integer> stack1 = new Stack<Integer>();
    Stack<Integer> stack2 = new Stack<Integer>();
    
    public void push(int node) {
        stack1.push(node);
    }
    
    public int pop() {
        if(stack1.empty()&&stack2.empty()){
            throw new RuntimeException("Queue is empty!");
        }
        if(stack2.isEmpty()) {
            while(!stack1.isEmpty()) {
                stack2.push(stack1.pop());
            }
        }
        return stack2.pop();
    }
}