剑指Offer行榜【牛客网】练习（一）

1、二维数组的查找

题目描述：
在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
思路：
为了避免遍历数组，找出第一行中lineIndex，比目标小，且lineIndex+1的数字比目标大；找出第一列的columnIndex，比目标小，且columnIndex+1的数字比目标大。目标存在的范围即可确定。
出错点：
1、考虑数组边界的问题，即第一行末尾和第一列末尾的单独处理。
2、考虑给出的数组没有数字的特殊情况。
代码：

public class Solution {
    public boolean Find(int target, int [][] array) {
        if(array[0].length==0){
            return false;
        }
        if(target<array[0][0]){
            return false;
        }else if(target>array[array.length-1][array[0].length-1]){
            return false;
        }
        int lineIndex = 0;
        for(int i=0;i<array[0].length;i++){
            if(array[0][i]==target){
                return true;
            }else if(array[0][i]<target&&(i==array[0].length-1||array[0][i+1]>target)){
                lineIndex = i;
                break;
            }
        }
        int columnIndex = 0;
        for(int i=0;i<array.length;i++){
            if(array[i][0]==target){
                return true;
            }else if(array[i][0]<target&&(i==array.length-1||array[i+1][0]>target)){
                columnIndex = i;
            }
        }
        for(int i=0;i<=columnIndex;i++){
            for(int j=0;j<=lineIndex;j++){
                if(array[i][j]==target){
                    return true;
                }
            }
        }
        return false;
    }
}

2、替换空格

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

public class Solution {
    public String replaceSpace(StringBuffer str) {
    	String mystr = String.valueOf(str);
        return mystr.replaceAll(" ","%20");
    }
}
//or
public class Solution {
    public String replaceSpace(StringBuffer str) {
    	String mystr = "";
        for(int i=0;i<str.length();i++){
            if(str.charAt(i)==' '){
                mystr+="%20";
            }else{
                mystr+=str.charAt(i);
            }
        }
        return mystr;
    }
}

3、从头到尾打印链表

题目描述：
输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。

//翻转所得ArrayList
import java.util.ArrayList;
import java.util.Collections;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> result = new ArrayList<>();
        while(listNode!=null){
            result.add(listNode.val);
            listNode = listNode.next;
        }
        Collections.reverse(result);
        return result;
    }
}
//递归，直接从尾到头得到数据
import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> result = new ArrayList<>();
        if(listNode==null){
            return result;
        }
        getRest(result, listNode);
        return result;
    }
    public static void getRest(ArrayList<Integer> list, ListNode listNode){
        if(listNode.next==null){
            list.add(listNode.val);
            return;
        }else{
            Integer nodeVal = listNode.val;
            getRest(list,listNode.next);
            list.add(nodeVal);
            return;
        }
    }
}

4、重建二叉树

题目描述：
输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。
思路：
先序遍历的第一个肯定是根节点，然后根据中序遍历序列，可以把树分为左部分、根、右部分。依次类推上述过程，即可还原二叉树。使用递归方法。

/**
 * 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.length==0){
            return null;
        }
        TreeNode root = new TreeNode(pre[0]);
        int rootIndex = 0;
        for(int i=0;i<in.length;i++){
            if(pre[0]==in[i]){
                rootIndex = i;
                break;
            }
        }
        int[] leftpre = new int[rootIndex];
        int[] leftin = new int[rootIndex];
        int[] rightpre = new int[in.length-rootIndex-1];
        int[] rightin = new int[in.length-rootIndex-1];
        for(int i=0;i<rootIndex;i++){
            leftpre[i] = pre[i+1];
            leftin[i] = in[i];
        }
        for(int i=0;i<in.length-rootIndex-1;i++){
            rightpre[i] = pre[i+rootIndex+1];
            rightin[i] = in[i+rootIndex+1];
        }
        root.left = reConstructBinaryTree(leftpre,leftin);
        root.right = reConstructBinaryTree(rightpre,rightin);
        
        return root;
    }
}

5、用两个栈实现队列

题目描述：
用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。
思路：
队列是在末尾push插入，在头部pop元素。队列先进先出，栈是先进后出，所以栈pop时，只要从stack1导入stack2最后再导入stack1即可。

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() {
        int result = 0;
        while(!stack1.empty()){
            result = stack1.pop();
            stack2.push(result);
        }
        stack2.pop();
        while(!stack2.empty()){
            stack1.push(stack2.pop());
        }
        
        return result;
    }
}
//这个方法虽然实现了效果，但是没有get到精髓……
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() {
        int result = stack1.get(0);
        stack1.remove(0);
        return result;
    }
}

重建二叉树借鉴 https://www.cnblogs.com/letgo/p/5715758.html
用两个栈实现队列借鉴 https://blog.csdn.net/veaxen/article/details/61196397