剑指offer 刷题第一天总结

摆出今日刷题成就：近期学习了java语言，想要重新从头锤炼下自己的思维，从0开始。

      

不得不说，现在自己对于处理问题的注意事项以及数据结构忘得一干二净，并且还伴有依赖答案的症状。

尽管如此，我仍然愿意一步步积累，量变才能有质变，思维学习要注重思考与灵活运用。

------------------------------------------------------------------------------------------------------------------------------------回归正题：（以下为今日总结）

1.   (用两个栈实现队列) 

     在最开始拿到这道题的时候，我是懂栈和队列的区别的（区别：队列是先进先出，栈是先进后出）。因此，我大致有了解题的思路，但是在将其用代码实现的路途中，出现了一些问题：

    例如：我一开始的push函数是边往stack1中压入元素，一边弹出给stack2，简单的以为自己将整体的顺序换了过来。出错代码如下：

import java.util.Stack;
 
public class Solution {
    //类似于ArrayList的声明方法：
    //ArrayList<Integer> array = new ArrayList<Integer>();
    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())
            System.out.println("没有可以弹出的元素！");
        while(!stack1.empty()){
            stack2.push(stack1.pop());
        }
        return stack2.pop();
    }
}

    果不其然在运行的时候就报了错，报错情况如下图：

     

    之后我重新画图检查，发现如果当我将stack1中的所有元素都pop给stack2，最后用户调用的pop命令小于stack2中现有的元素时，在下一次stack1 pop stack2就会出现问题，即用户再次调用pop命令的时候，stack1中元素会pop给stack2,并将stack2上一轮剩余的元素压到栈底，就破坏了题目要求的先进先出的原则。因此做出如下更正：

提交已过代码：

import java.util.Stack;
 
public class Solution {
    //类似于ArrayList的声明方法：
    //ArrayList<Integer> array = new ArrayList<Integer>();
    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())
           System.out.println("没有可以取出的元素！");
        if(stack2.empty()){
            while(!stack1.empty()){
                stack2.push(stack1.pop());
            }
        }
        return stack2.pop();
    }
}

2. 重建二叉树   

    二叉树的前序和中序遍历原理我也是了解的，并且我可以顺利的用手推出该二叉树，但是在用代码呈现出来的方面，就不行了。后来查阅了一些题解，了解到可以用递归的方法来解决此题。（希望自己后续能够加强一下递归专题的训练）

/**
 * 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 || in.length == 0)
            return null;
        TreeNode node = new TreeNode(pre[0]);
        for(int i = 0;i < in.length; i++){
            if(pre[0] == in[i]){
              //对于import java.util.Arrays中的Arrays.copyOfRange(pre,1,i+1)
                //生成的新数组的范围为：左闭右开
                node.left = reConstructBinaryTree(Arrays.copyOfRange(pre,1,i+1),Arrays.copyOfRange(in,0,i));
                node.right = reConstructBinaryTree(Arrays.copyOfRange(pre,i+1,pre.length),Arrays.copyOfRange(in,i+1,in.length));
            }
        }
        return node;
    }
}

3.  从尾到头打印链表  

  对于这个题目，我当时没有什么思路，貌似是把链表当成数组来考虑了，因此出现了很多问题。

  最终我总结下：1./*单链表中的节点应该具有两个属性：val 和 next。
                                         val 是当前节点的值
                                         next 是指向下一个节点的指针/引用*/

                   2.对于没有表头的单链表来说，一定一定要先判断其是否为空

                          3.递归的思想

/**
*    public class ListNode {
*        int val;
*        ListNode next = null;
*
*        ListNode(int val) {
*            this.val = val;
*        }
*    }
*
*/
import java.util.ArrayList;
public class Solution {
    /*单链表中的节点应该具有两个属性：val 和 next。
    val 是当前节点的值
    next 是指向下一个节点的指针/引用*/
    ArrayList<Integer> array = new ArrayList<Integer>();
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
       if(listNode != null){
           printListFromTailToHead(listNode.next);
           array.add(listNode.val);
       }
        return array;
    }
}

 

4.  替换空格   

    用到了java中的正则表达式，相对于其他题目来说，是比较容易的。

    需要注意的：1.String("We Are ......")与StringBuffer（append()）声明的区别

                          2.转换为String类型：toString()、toArrays()等

                          3.正则表达式配合replaceAll()一起使用

public class Solution {
    public static String replaceSpace(StringBuffer str) {
    	String s = str.toString().replaceAll("[ ]","%20");
        return s;
    }
    public static void main(String[] args){
        StringBuffer str = new StringBuffer();
        str.append("We Are Happy");
        String s = replaceSpace(str);
        System.out.println(s);
    }
}

5.  二维数组中的查找  

    此题很简单.

   一定一定要记得判断该二维数组长度是否为0

public class Solution {
    public static boolean Find(int target, int [][] array) {
        //右上角开始判断：array[row][column]
        //如果该数大于每一行的最后一个元素，就给行数加row++;
        //如果小于，就列数减column--;
        int n = array[0].length;
        if(n == 0)
            return false;
        for(int i = 0;i < n; i++){
            if(array[i][n - 1] == target)
                return true;
            for(int j = 0;j < array[i].length; j++){
                if(array[i][j] == target)
                    return true;
            }
        }
        return false;
    }
    public static void main(String[] args){
        int [][]array = {{1,4,8,9},{2,5,9,12},{6,9,14,16}};
        if(Find(14,array)){
            System.out.println("数组中存在该整数！");
        }
        else
            System.out.println("数组中不存在该整数！");
    }
}