[剑指offer]——Java题解(21~25)

目录

21 栈的压入、弹出序列

22 从上往下打印二叉树

23 二叉搜索树的后续遍历序列

24 二叉树中和为某一值的路径

25 复杂链表的复制

---

21 栈的压入、弹出序列

---

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

知识点： “栈”

分析：新建一个栈，将原数列依次压栈，把栈顶元素与所给出栈队列相比，如果相同则出栈，如果不同则继续压栈，直到原数列中所有数字压栈完毕。最后，检测栈中是否为空，若空，说明出栈队列可由原数列进行栈操作得到。否则，说明出栈队列不能由原数列进行栈操作得到。

/*Java  runtime = 14ms*/
import java.util.ArrayList;
import java.util.Stack;
public class Solution {
    public boolean IsPopOrder(int [] pushA,int [] popA) {
        //如果没有“两数列长度相等”条件，此处还要判断是否长度相等，不等直接返回false
        if (pushA == null || popA == null)  
            return false;
        Stack<Integer> stack = new Stack<Integer>();
        int index = 0;
        for(int i = 0;i < pushA.length;i++) {
            stack.push(pushA[i]);
            while(!stack.empty() && stack.peek() == popA[index]) {
                stack.pop();
                index++;
            }
        }
        return stack.empty();
    }
}

---

22 从上往下打印二叉树

---

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

知识点： “队列” “树”

分析：二叉树的层序遍历。借助队列就可以实现，先将根节点加入到队列中，再依次加入左右节点，不断遍历出队，同时加入到结果列表中。

/*Java  runtime = 20ms*/
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> list = new ArrayList<>();
        if (root == null) {
            return list;
        }
        //Queue接口不能直接实例化，可以实例化其实现类LinkedList
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root); //根节点入队
​
        while (!queue.isEmpty()) {
            TreeNode node = queue.poll();  //节点出队
            list.add(node.val);
            if (node.left != null) {
                queue.offer(node.left);
            }
            if (node.right != null) {
                queue.offer(node.right);
            }
        }
        return list;
    }
}

---

23 二叉搜索树的后续遍历序列

---

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

知识点： “栈” “树”

分析：二叉搜索树: 左子树<根<=右子树。对于后序遍历来说，序列数组的最后一个元素一定是根节点, 根据这个元素，将前面的数组分为左、右两个部分，左侧部分都比该元素小，右侧部分都比该元素大，如果右侧部分有比该根节点小的元素，那么就不是后序遍历，如此递归进行。

/*Java  runtime = 20ms*/
public class Solution {
    public boolean VerifySquenceOfBST(int [] sequence) {
        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 i = start;
        while(i < end && sequence[i] < sequence[end])
            i++;
        for(int j=i; j<end; j++){
            if(sequence[j]<sequence[end])
                return false;
        }
        return (judge(sequence, start, i-1)) && (judge(sequence, i, end-1));
    }
}

---

24 二叉树中和为某一值的路径

---

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

知识点： "树"

分析：先保存根节点，然后分别递归在左右子树中找目标值，若找到即到达叶子节点，打印路径中的值。

/*Java  runtime = 22ms*/
import java.util.ArrayList;
public class Solution {
    ArrayList<ArrayList<Integer> > resultList = new ArrayList<ArrayList<Integer>>();
    ArrayList<Integer> list = new ArrayList<Integer>();
    public ArrayList<ArrayList<Integer>> FindPath(TreeNode root,int target) {
        if(root == null)
            return resultList;
        list.add(root.val);
        target -= root.val;
​
        if(target == 0 && root.left == null && root.right == null){
            resultList.add(new ArrayList<>(list));
        }else {
            FindPath(root.left,target);
            FindPath(root.right,target);
        }
        //每返回上一层一次就要回退一个节点
        list.remove(list.size()-1);
        return resultList;
    }
}

---

25 复杂链表的复制

---

题目：输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的head。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）

知识点： "链表"

分析：先复制链表的next节点，将复制后的节点接在原节点后，然后复制其它的节点，最后取偶数位置的节点（复制后的节点）。

/*Java  runtime = 34ms*/
/*
public class RandomListNode {
    int label;
    RandomListNode next = null;
    RandomListNode random = null;
​
    RandomListNode(int label) {
        this.label = label;
    }
}
*/
public class Solution {
    public RandomListNode Clone(RandomListNode pHead) {
        if(pHead == null)
            return null;
        RandomListNode head = new RandomListNode(pHead.label) ;
        RandomListNode temp = head ;
​
        while(pHead.next != null) {
            temp.next = new RandomListNode(pHead.next.label) ;
            if(pHead.random != null) {
                temp.random = new RandomListNode(pHead.random.label) ;
            }
            pHead = pHead.next ;
            temp = temp.next ;
        }
        return head ;
    }
}