剑指offer（1~5）

二维数组中的查找

题目描述

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

思路分析：

从二维数组的右上角开始查找，设置一个i,j表示所找当前位置，如果说array[i][j]>target的话，接着就往左边找，反之往下找。

为什么从右上角或者左下角开始查找呢？因为题目中每一行都是按照从左到右递增的顺序排序，每一列也是按照从上到下递增的顺序排序，从右上角开始，如果说要找的数比当前数小，往左移，比当前数大，往下移。同理，从左下角开始，目标数比当前数小，往上移，比当前数大，往右移即可。

算法实现：

public class Solution {
    public boolean Find(int target, int [][] array) {
        int row = 0;
        int col = array[0].length - 1;
        while(col >= 0 && row < array.length){
            if(target == array[row][col])
                return true;
            else if(target < array[row][col])
                col --;
            else
                row ++;
        }
        return false;
    }
}

替换空格

题目描述：

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

思路分析：

遍历字符串中的每一个字符，判断该字符是否是空格，如果是则追加“%20”，否则就追加当前字符即可。

算法实现：

public class Solution {
    public String replaceSpace(StringBuffer str) {
        StringBuffer stringBuffer = new StringBuffer();
    	for(int i = 0; i < str.length(); i ++){
            if(str.charAt(i) == ' ')
                stringBuffer.append("%20");
            else
                stringBuffer.append(str.charAt(i));
        }
        return stringBuffer.toString();
    }
}

从尾到头打印链表

题目描述：

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

思路分析：

使用栈的方法：

当链表不为空时，把链表中的值添加到栈中，直到把链表中的所有值都放入栈中后，在从栈中依次出栈，把栈中的所有元素都添加进一个新的链表中，最后返回这个链表即可。

使用递归：

要逆序打印链表 1->2->3（3,2,1)，可以先逆序打印链表2->3(3,2)，最后再打印第一个节点 1。而链表2->3可以看成一个新的链表，要逆序打印该链表可以继续使用求解函数，也就是在求解函数中调用自己，这就是递归函数。

算法实现：

使用栈的方法

public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> list = new ArrayList<>();
        Stack<Integer> stack = new Stack<>();
        while(listNode != null){
            stack.add(listNode.val);
            listNode = listNode.next;
        }
        while(!stack.isEmpty()){
            list.add(stack.pop());
        }
        return list;
    }
}

使用递归

public class Solution {
    private ArrayList<Integer> list = new ArrayList<>();
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        if(listNode != null){
            printListFromTailToHead(listNode.next);
            list.add(listNode.val);
        }
        return list;
    }
}

重建二叉树

题目描述：

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

思路分析：

利用递归的方法，每次先取前序遍历中的第一个元素，然后在中序遍历中找到此元素，该元素把中序遍历划分为左子树和右子树。
假设这个元素在中序遍历的下标为i，则：

• 中序遍历中左子树的下标为inStart ~ i-1，中序遍历中右子树的下标为i+1~inEnd；
• 前序遍历中左子树的下标为preStart+1 ~ preStart+i-inStart,前序遍历中右子树的下标为i+1 ~ preEnd；

得到的左子树和右子树又可以重复上述步骤，先取前序遍历中的第一个元素，然后在。。。。。

算法实现：

public class Solution {
    public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
        return reConstructBinaryTree(pre,0,pre.length-1,in,0,in.length-1);
    }
    private 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;
    }
}

用两个栈实现队列

题目描述：

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

思路分析：

• 栈A用来作入队列
• 栈B用来出队列，当栈B为空时，栈A全部出栈到栈B,栈B再出栈（即出队列），如果栈B不为空时直接出栈栈B的栈顶元素即可。

算法实现：

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();
    }
}