剑指Offer（1） 1-5题

第一题 ：二维数组中的查找

题目描述：
在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
思路：
由于这是一个有规律的数组，可以从数组的右上角（cur）开始查找。
如果target>cur，说明target只可能在cur的下方，对应的row++。
如果target

public class Solution {
    public boolean Find(int target, int [][] array) {
        if(array==null||array.length==0||(array.length==1&&array[0].length==0)){
            return false;
        }else{
            int x = 0;
            int y = array[0].length - 1;
            int cur = array[x][y];
            boolean flag = false;
            while(x <= array.length - 1 && y >= 0 ) {
                if(target < cur) {
                    y--;
                    if(y < 0) {
                        break;
                    }
                    cur = array[x][y];
                }
                if(target > cur) {
                    x++;
                    if(x > array.length - 1) {
                        break;
                    }
                    cur = array[x][y];
                }
                if(target == cur) {
                    flag = true;
                    break;
                }
            }
            return flag;
        }
     }
}

第二题：替换空格

题目描述：
请实现一个函数，将一个字符串中的空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。
思路：
先遍历一个字符串，计算一下一共有多少个空格。假设一共有n个空格，将字符串的长度增加2*n(因为将“ ” 替换成了“ %20”，每替换一次会多2个字符)。这个时候设2个下标，oldIndex和newIndex。从后往前扫描，遇到空格则写入“%20”，否则直接复制。

public class Solution {
public String replaceSpace(StringBuffer str) {
        int spacenum = 0;//spacenum为计算空格数
        for(int i=0;i<str.length();i++){
            if(str.charAt(i)==' ')
                spacenum++;
        }
        int indexold = str.length()-1; //indexold为为替换前的str下标
        int newlength = str.length() + spacenum*2;//计算空格转换成%20之后的str长度
        int indexnew = newlength-1;//indexold为为把空格替换为%20后的str下标
        str.setLength(newlength);//使str的长度扩大到转换成%20之后的长度,防止下标越界
        for(;indexold>=0 && indexold<newlength;--indexold){ 
                if(str.charAt(indexold) == ' '){  //
                str.setCharAt(indexnew--, '0');
                str.setCharAt(indexnew--, '2');
                str.setCharAt(indexnew--, '%');
                }else{
                    str.setCharAt(indexnew--, str.charAt(indexold));
                }
        }
        return str.toString();
    }
}

其实可以直接使用Java中String类的replacAll函数来实现。而且运行时间和上面的方法几乎一样。

public String replaceSpace(StringBuffer str) {
    String cur = new String(str);
    String res = cur.replaceAll(" ", "%20");
    return res;
}

第三题：从尾到头打印链表

题目描述：
输入一个链表，从尾到头打印链表每个节点的值。
思路：
遍历链表，每遍历到一个节点的时候，将值push到一个stack里。遍历完毕之后，再依次pop出stack里保存的所有元素。

/**
*    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) {
        Stack<Integer> stack = new Stack<Integer>();

        while(listNode != null) {
            stack.push(listNode.val);
            listNode = listNode.next;

        }

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

        while(!stack.isEmpty()) {
            list.add(stack.pop());
        }

        return list;
    }
}

第四题：重建二叉树

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

思路：
对于二叉树的前序遍历，第一个元素一定是头结点root，后面的元素有一部分是左子树，剩下的另一部分是右子树。对于中序遍历，先从头遍历这个数组，找到与前序的第一个元素相等的元素，那么这个元素就是头结点。在中序遍历中，这个元素左边的就都是左子树，它右边的就都是右子树。这样确定下来后，就可以递归解决了。

/**
 * 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) {
        TreeNode root = reConstructBinaryTree(pre, 0, pre.length - 1, in, 0, in.length - 1);
        return root;
    }

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

对于左子树递归的部分，前序遍历左边的边界是preStart + 1 很好确定，那么对于右边界preStart + i - inStart是这样确定的。显然，在前序遍历和中序遍历中，左子树的长度肯定都是一样。对于中序遍历，左子树的长度就是i - inStart。那么，先假设前序遍历右边的边界为X。因为长度相等，所以可以列出 X - preStart + 1 = i - inStart,解方程得X = preStart + i - inStart。
有了这个边界值，在写右子树遍历的遍历时，只要+1就够了。

第五题：用两个栈实现队列

题目描述：
用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。
思路：
栈是先进后出的，队列是先进先出的。可以先将所有的元素push到第一个stack1中，再讲pop出的元素依次push到stack2中。这样两次push，顺序就变回先进先出了。

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(stack2.isEmpty()) {
            while(!stack1.isEmpty()) {
                stack2.push(stack1.pop());
            }
        }
        return stack2.pop();
    }
}

在第一个stack1往stack2里倒元素的时候，一定要一次性倒完，不然元素的逻辑顺序就会出问题。