剑指Offer系列之题21~题25

Posted 2020-11-27 lfz1211

目录

• 21.包含min函数的栈
• 22.栈的压入、弹出序列 ??
• 23.从上往下打印二叉树
• 24.二叉搜索树的后序遍历序列 ??
• 25.二叉树中和为某一值的路径 ??

21.包含min函数的栈

定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。

注意：保证测试中不会当栈为空的时候，对栈调用pop()或者min()或者top()方法。

利用辅助栈，存储元素。当最小元素出栈后，次小元素仍在辅助栈中。

---

辅助栈：

import java.util.Stack;

public class Solution {
    private Stack<Integer> stack1=new Stack<Integer>();
    private Stack<Integer> stack2=new Stack<Integer>();

    public void push(int node) {
        stack1.push(node);//元素入栈1
        if(stack2.size()==0){//若栈2空，则该元素也入栈2
            stack2.push(node);
        }else{//若入栈元素小于等于栈2的栈顶元素，则该元素也入栈2
            if(node <= stack2.peek()){
                stack2.push(node);
            }
        }
    }

    public void pop() {
        if(stack1.size()!=0){
            if(stack1.peek().equals(stack2.peek())){//若出栈元素等于栈2的栈顶元素，则栈2也出栈
                stack2.pop();
            }
            stack1.pop();
        }
    }

    public int top() {
        return stack1.peek();
    }

    public int min() {
        return stack2.peek();
    }
}

22.栈的压入、弹出序列 ??

输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4,5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的）

利用辅助栈，以此入栈，当栈顶等于出栈序列当前数，则出栈接着进行比较，直到栈空。

---

辅助栈：

import java.util.Stack;

public class Solution {
    public boolean IsPopOrder(int [] pushA,int [] popA) {
        if(pushA.length==0 || popA.length==0)
            return false;
        Stack<Integer> stack=new Stack<>();
        int p=0;
        for(int i=0;i<pushA.length;++i){
            stack.push(pushA[i]);
            while(!stack.empty() && stack.peek()==popA[p]){//当栈非空且栈顶等于出栈序列当前元素时
                stack.pop();
                p++;
            }
        }
        return stack.empty();
    }
}

23.从上往下打印二叉树

从上往下打印出二叉树的每个节点，同层节点从左至右打印。

利用辅助队列，先进先出。依次存储每一层的节点

---

辅助队列：

import java.util.ArrayList;
import java.util.Queue;
import java.util.LinkedList;
/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
public class Solution {
    public ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {
        //广度优先遍历
        ArrayList<Integer> result=new ArrayList<>();
        Queue<TreeNode> queue=new LinkedList<>();
        if(root==null)//当为空时，不要返回null，直接返回列表
            return result;
        //同一层先加左子树节点，后加右子树节点
        result.add(root.val);
        if(root.left!=null){
            queue.offer(root.left);
        }
        if(root.right!=null){
            queue.offer(root.right);
        }
        while(queue.size()!=0){
            TreeNode head=queue.peek();//查看队列头元素左右子树是否为空
            if(head.left!=null)
                queue.offer(head.left);
            if(head.right!=null)
                queue.offer(head.right);
            result.add(head.val);
            queue.poll();
        }
        return result;
    }

}

24.二叉搜索树的后序遍历序列 ??

输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。

根据二叉搜索树和后序遍历的特点。

---

1.递归：

public class Solution {
    public boolean VerifySquenceOfBST(int [] sequence) {
        //二叉搜索树：节点值大于左子树，小于右子树
        //后序遍历：左右根
        //查找左右子树中是否有大于（左）、小于（右）根节点值的情况，有则false；
        if(sequence.length==0)
            return false;
        if(sequence.length==1)
            return true;

        return judge(sequence,0,sequence.length-1);
    }

    public boolean judge(int sequence[],int start,int end){
        if(start>=end)
            return true;
        int root=sequence[end];
        int i=start;
        for(;i<end;++i){//左子树
            if(sequence[i]>root){
                break;
            }
        }
        for(;i<end;i++){//判断右子树中是否存在小于根节点的情况
            if(sequence[i]<root)
                return false;
        }

        return judge(sequence,start,i-1) && judge(sequence,i,end-1);//分别判断左右子树
    }
}

2.非递归：

public class Solution {
    public boolean VerifySquenceOfBST(int [] sequence) {
        //二叉搜索树：节点值大于左子树，小于右子树
        //后序遍历：左右根
        //查找左右子树中是否有大于（左）、小于（右）根节点值的情况，有则false；
        if(sequence.length==0)
            return false;
        if(sequence.length==1)
            return true;

        int n=sequence.length-1;
        int i=0;
        while(i<n){
            while(sequence[i]<sequence[n])
                i++;
            while(sequence[i]>sequence[n])
                i++;
            if(i<n)
                return false;
            n--;
            i=0;
        }
        return true;
    }
}

3.利用栈的压入、弹出：

         4
       /        2    6
     /   /     1  3 5   7

对于以上二叉树。其中序序列：1234567，后序序列：1325764。

其后序序列一定是中序序列作为入栈数组的一种出栈结果。

该解法可以通过，但是个人认为不合理。存在属于中序序列入栈，但是不是后序序列的情况（eg：输入数组是 1235764 时）。此处列出该方法仅作草靠，解法较有新意。

import java.util.Stack;
import java.util.Arrays;

public class Solution {
    public boolean VerifySquenceOfBST(int [] seq) {
        int[] arr = seq.clone();
        Arrays.sort(arr);
        return IsPopOrder(arr,seq);

    }

//判断第二个序列是否可能为第一个序列的弹出顺序,引用的“栈的压入、弹出序列”题目的答案
public boolean IsPopOrder(int [] pushA,int [] popA) {
        if(pushA.length == 0 || popA.length == 0)
            return false;
        Stack<Integer> s = new Stack<Integer>();
        //用于标识弹出序列的位置
        int popIndex = 0;
        for(int i = 0; i< pushA.length;i++){
            s.push(pushA[i]);
            //如果栈不为空，且栈顶元素等于弹出序列
            while(!s.empty() &&s.peek() == popA[popIndex]){
                //出栈
                s.pop();
                //弹出序列向后一位
                popIndex++;
            }
        }
        return s.empty();
    }
}

参考牛客

如果把中序序列当做栈的压入序列，那么后序序列是该栈的一个弹出序列。

25.二叉树中和为某一值的路径 ??

输入一颗二叉树的根节点和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。(注意: 在返回值的list中，数组长度大的数组靠前)

递归。判断到叶节点时，是否和为目标值，是则加到列表。该条路径走完时，回退到父节点。

---

1.递归：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
public class Solution {
    ArrayList<ArrayList<Integer>> roads=new ArrayList<>();
    ArrayList<Integer> road=new ArrayList<>();
    public ArrayList<ArrayList<Integer>> FindPath(TreeNode root,int target) {
        helper(root,target);
        //排序
        Collections.sort(roads, new Comparator<ArrayList<Integer>>() {
            @Override
            public int compare(ArrayList<Integer> o1, ArrayList<Integer> o2) {
                if (o1.size()<o2.size()){
                    return 1;
                }else return -1;
            }
        });
        return roads;
    }

    public void helper(TreeNode root,int target){
        if(root==null)//到达叶节点，和不等于target
            return ;

        road.add(root.val);
        target-=root.val;
        if(target==0 && root.left==null && root.right==null){
            //到达叶节点，且和等于target
            roads.add(new ArrayList<Integer>(road));
        }
        FindPath(root.left,target);//对左子树遍历
        FindPath(root.right,target);//对右子树遍历

        road.remove(road.size()-1);//回退
    }
}

如有错误，欢迎指正