JZ21:栈的压入弹出序列
题目描述：输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列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) {
if(pushA.length==0||popA.length==0){//判断输入是否为空
return false;
}
Stack<Integer> stack = new Stack<Integer>();
int j=0;
for(int i=0;i<popA.length;i++){
stack.push(pushA[i]);
while(j<popA.length&&stack.peek()==popA[j]){//相等就弹出
stack.pop();
j++;
}
}
return stack.empty()?true:false;
}
}
JZ22:从上往下打印二叉树
题目描述：从上往下打印出二叉树的每个节点，同层节点从左至右打印。
解题思路：借助队列来实现，用队列存储相应的TreeNode
public class Solution {
public ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {
ArrayList<Integer> list = new ArrayList<>();//放值
ArrayList<TreeNode> queue = new ArrayList<>()//放树的节点
if (root == null) {
return list;
}
queue.add(root);
while (queue.size() != 0) {//队列有空间才能循环
TreeNode temp = queue.remove(0);
if (temp.left != null){
queue.add(temp.left);
}
if (temp.right != null) {
queue.add(temp.right);
}
list.add(temp.val);
}
return list;
}
}
JZ23:二叉搜索树的后序遍历序列
题目描述：输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。
解题思路：首先知道，后序是左右根，二叉搜索树的中序是有序的，中序序列和后序序列满足栈的压入弹出序列关系。如果把中序序列当做栈的压入序列，那么后序序列是该栈的一个弹出序列。
import java.util.Stack;
import java.util.Arrays;
public class Solution {
public boolean VerifySquenceOfBST(int [] seq) {
int[] mid = seq.clone();
Arrays.sort(mid);//排个序当中序序列传进去
return get(mid,seq);
}
//判断后序是不是中序的一个弹出序列
public boolean get(int [] pushA,int [] popA) {
if(pushA.length == 0 || popA.length == 0){
return false;
}
Stack<Integer> stack= new Stack<Integer>();
int index= 0;
for(int i = 0; i< pushA.length;i++){
stack.push(pushA[i]);//用push把它加进去
//如果栈不为空，且栈顶元素等于弹出序列
while(!stack.empty() &&stack.peek() == popA[index]){
stack.pop();//出栈
index++;
}
}
return stack.empty();
}
}
JZ24:二叉树中和为某一值的路径
题目描述:输入一颗二叉树的根节点和一个整数，按字典序打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。
解题思路：这个题就是树的深度优先遍历，给一个节点和给定的和，先用和减去节点，得到的值作为新结点，依次递归。
import java.util.ArrayList;
public class Solution {
public ArrayList<ArrayList<Integer>> listAll = new ArrayList<ArrayList<Integer>>();
public 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=target-root.val;
if(target == 0 && root.left == null && root.right == null){
listAll.add(new ArrayList<Integer>(list));//不这样添加，后面操作会更改list
}
FindPath(root.left, target);
FindPath(root.right, target);
list.remove(list.size()-1);//递归到叶子节点如果还没有找到路径，就要回退到父节点继续
return listAll;
}
}
JZ25:复杂链表的复制
题目描述：输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针random指向一个随机节点），请对此链表进行深拷贝，并返回拷贝后的头结点。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）
解题思路：这里借用牛客网一张思路图，我觉得很清晰。首先遍历链表，复制每个结点得到它的兄弟节点插在其后，然后重新遍历链表，复制老结点的随机指针给新结点，如A1.random = A.random.next;在拆分链表，将链表拆分为原链表和复制后的链表
public class Solution {
RandomListNode Clone(RandomListNode pHead)
{
if(pHead==null){
return null;
}
RandomListNode node=pHead;
while(node!=null){//把链表复制一份
RandomListNode a=new RandomListNode(node.label);
a.random=null;
a.next=node.next;
node.next=a;
node=a.next;
}
//算random
RandomListNode pre1=pHead;
while(pre1!=null){
RandomListNode pre2=pre1.next;
if(pre1.random!=null){
pre2.random=pre1.random.next;
}
pre1=pre2.next;
}
pre1=pHead;//拆分成新旧两个链表
RandomListNode result=pHead.next;
while(pre1!=null){
RandomListNode p=pre1.next;
pre1.next=p.next;
if(p.next!=null){
p.next=p.next.next;
}
pre1=pre1.next;
}
return result;
}
}
JZ26:二叉搜索树与双向链表
题目描述：输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。
解题思路：直接用中序遍历，改变它之间的指向关系，就得到了一个链表
public class Solution {
TreeNode head = null;
TreeNode realHead = null;
public TreeNode Convert(TreeNode pRootOfTree) {
ConvertSub(pRootOfTree);
return realHead;
}
private void ConvertSub(TreeNode pRootOfTree) {
if(pRootOfTree==null) return;
ConvertSub(pRootOfTree.left);
if (head == null) {
head = pRootOfTree;
realHead = pRootOfTree;
} else {
head.right = pRootOfTree;
pRootOfTree.left = head;
head = pRootOfTree;
}
ConvertSub(pRootOfTree.right);
}
}
JZ27:字符串的排列
题目描述：输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。
解题思路：首先找出哪些字符可以出现在第一个位置，固定第一个字符，求剩余字符的排列；求剩余字符的排列时跟原问题一样
import java.util.*;
public class Solution{
public static ArrayList<String> Permutation(String str) {
ArrayList<String> list = new ArrayList<>();
if (str != null && str.length() != 0) {
Helper(str.toCharArray(), 0, list);
Collections.sort(list);//对所得的list集合进行排序
}
return list;
}
private static void Helper(char[] chars, int i, ArrayList<String> list){
if (i == chars.length - 1) {//递归出口：遍历到数组最后一个字符了
String val = String.valueOf(chars);//将字符数组变成字符串
if (!list.contains(val)) {//如果list集合中不包含这个字符串，则添加（避免重复）
list.add(val);
}
}else{
for (int j = i; j < chars.length; j++) {
swap(chars, i, j);//交换数组第i个字符和第j个字符
Helper(chars, i + 1, list);
swap(chars, i, j);//再次交换数组第i个字符和第j个字符，
//保证回到此次for循环前字符数组的状态，不影响字符数组进行下一次for循环
}
}
}
private static void swap(char[] chars, int i, int j) {
char tmp = chars[i];
chars[i] = chars[j];
chars[j] = tmp;
}
}
JZ28:数组中出现次数超过一半的数字
题目描述：数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。
解题思路：先给数组排个序，去判断每个元素和array.length/2位置的数是否相等，相等就加1，如果COUNT比array.length/2大，就返回中间位置这个数，
import java.util.Arrays;
public class Solution {
public int MoreThanHalfNum_Solution(int [] array) {
if(array.length<1){
return 0;
}
Arrays.sort(array);
int count=0;
for(int i=0;i<array.length;i++){
if(array[i]==array[array.length/2]){
count++;
}
}
if(count>array.length/2){
return array[array.length/2];
}
return 0;
}
}
JZ29:最小的前k个数
题目描述：输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4,。
解题思路：直接排个序，把前k个输出
import java.util.Arrays;
import java.util.ArrayList;
public class Solution {
public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
ArrayList<Integer> arr=new ArrayList<Integer>();
int len=input.length;
if(k>len){//如果要输出的个数比数组长度还大，直接return
return arr;
}
Arrays.sort(input);//
for(int i=0;i<k;i++){
arr.add(input[i]);
}
return arr;
}
}
JZ30：连续子数组的最大和
题目描述：{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。给一个数组，返回它的最大连续子序列的和，你会不会被他忽悠住？(子向量的长度至少是1)
解题思路：
public class Solution {
public int FindGreatestSumOfSubArray(int[] array) {
int result=array[0];//保留当前最大值
int max=array[0];//包含array[i]的连续数组最大值
for(int i=1;i<array.length;i++){
max=Math.max(max+array[i],array[i]);
result=Math.max(max,result);
}
return result;
}
}