剑指Offer 刷题笔记（30/66）——JAVA

21.栈的压入、弹出序列

题目：输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4,5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的）(链接)
解析：
利用栈的先入后出这个性质，我们来模拟元素进栈就可以解决这个问题，具体做法如下：

• 根据进栈序列依次进栈；
• 进栈的过程中，判断栈顶元素时候和出栈序列相同，如果相同，那么就出栈，重复这个过程，直到不相同为止；
• 当所有元素都入栈后，判断栈是否为空，如果为空，那么出栈序列就是合法的。

import java.util.ArrayList;
import java.util.Stack;

public class Solution {
    public boolean IsPopOrder(int [] pushA,int [] popA) {
        Stack<Integer> stack = new Stack<Integer>();
        for(int i=0,j=0;i<pushA.length;i++){
            stack.push(pushA[i]);
            while(j<popA.length && stack.peek() == popA[j]){
                stack.pop();
                j++;
            }
        }
        return stack.empty();
    }
}

22.从上往下打印二叉树

题目：从上往下打印出二叉树的每个节点，同层节点从左至右打印。(链接)
解析：二叉树的层序遍历，BFS（Breadth-First-Search），广度优先搜索。借助一个队列。

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<Integer>();
        if(root==null) 
            return list;
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer(root);
        while(!queue.isEmpty()){
            TreeNode node = queue.poll();
            if(node.left != null)
                queue.offer(node.left);
            if(node.right != null)
                queue.offer(node.right);
            list.add(node.val);
        }
        return list;
    }
}

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

题目：输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。(链接)
解析：排序二叉树的性质：左子树所有结点的值都小于根节点，右子树所有结点的值都大于根节点。

public class Solution {
    public boolean VerifySquenceOfBST(int [] sequence) {
        if(sequence.length==0)
            return false;
        return judge(sequence,0,sequence.length -1);
    }
    
    public boolean judge(int [] sequence,int left, int right){
        if(left>=right)
            return true;
        int i=right;
        while(i>left && sequence[i-1]>sequence[right])
            i--;
        int j=left;
        while(j<i && sequence[j]<sequence[right])
            j++;
        if(i!=j)
            return false;
        return judge(sequence,left,i-1) && judge(sequence,i,right-1);
    }
}

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

题目：输入一颗二叉树的跟节点和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。(注意: 在返回值的list中，数组长度大的数组靠前)(链接)
解析：DFS（Depth First Search），深度优先搜索。

import java.util.ArrayList;
/**
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>> listAll = new ArrayList<ArrayList<Integer>>();
    ArrayList<Integer>list = new ArrayList<Integer>();
    public ArrayList<ArrayList<Integer>> FindPath(TreeNode root,int target) {
        if(root==null)
            return listAll;
        list.add(root.val);
        target-=root.val;
        if(target==0 && root.left == null & root.right == null)
            listAll.add(new ArrayList(list));
        FindPath(root.left,target);
        FindPath(root.right,target);
        list.remove(list.size()-1);
        return listAll;
    }
}

25.复杂链表的复制

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

/*
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;
         //1、复制每个结点，如复制结点A得到A1，将结点A1插到结点A后面；
        RandomListNode currentNode = pHead;
        while(currentNode!=null){
            RandomListNode cloneNode = new RandomListNode(currentNode.label);
            cloneNode.next = currentNode.next;
            currentNode.next = cloneNode;
            currentNode = cloneNode.next;
        }
        //2、重新遍历链表，复制老结点的随机指针给新结点，如A1.random = A.random.next;
        currentNode = pHead;
        while(currentNode!=null){
            currentNode.next.random = currentNode.random == null ? null:currentNode.random.next;
            currentNode = currentNode.next.next;
        }
        //3、拆分链表，将链表拆分为原链表和复制后的链表
        currentNode = pHead;
        RandomListNode cloneHead = pHead.next;
        RandomListNode tmp;
        while(currentNode.next!=null){
            tmp = currentNode.next;
            currentNode.next = tmp.next;
            currentNode = tmp;
        }
        return cloneHead;
    }
}

26.二叉搜索树与双向链表

题目：输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。(链接)
解析：
创建一个全局变量记录左子树的最后一节点（链表中最大的一个数）。
然后递归函数中返回的是子树最左一节点（链表中最小的一个数）。

/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

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

}
*/
public class Solution {
    public TreeNode pre;
    public TreeNode Convert(TreeNode cur) {
        if(cur == null)
            return null;
        if(cur.left == null & cur.right ==null){
            pre = cur;
            return cur;
        }
        TreeNode left = Convert(cur.left);
        if(left!=null){
            pre.right = cur;
            cur.left = pre;
        }
        pre = cur;
        TreeNode right = Convert(cur.right);
        if(right != null){
            cur.right = right;
            right.left = cur;
        }
        return left==null?cur:left;
    }
}

27.字符串的排列

题目：输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。
输入一个字符串,长度不超过9(可能有字符重复),字符只包括大小写字母。(链接)
解析：回溯法思想

import java.util.ArrayList;
import java.util.List;
import java.util.Collections;

public class Solution {
    List<String> list = new ArrayList<String>();
    public ArrayList<String> Permutation(String str) {
        char[] cs =str.toCharArray();
        PermutationHelp(cs,0);
        Collections.sort(list);    //把所有结果进行排序
        return (ArrayList)list;
    }
    
    public void PermutationHelp(char[] cs, int k){
        if(k==(cs.length-1)){
            String str = String.valueOf(cs);
            if(!list.contains(str)){
                list.add(str);
                return;
            }
        }
        for(int i=k;i<cs.length;i++){
            swap(cs,k,i);
            PermutationHelp(cs,k+1);
            swap(cs,k,i);
        }
    }
    
    void swap(char[] cs, int i, int j){
        char tmp = cs[i];
        cs[i] = cs[j];
        cs[j] = tmp;
    }
}

28.数组中出现次数超过一半的数字

题目：数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。(链接)
解析：

29.

题目：(链接)
解析：

30.

题目：(链接)
解析：