文章目录
- 1、数组的查找
- 2、替换空格
- 3、从尾到头打印链表
- 4、重建二叉树
- 5、用两个栈实现队列
- 6、旋转数组最小的数字
- 7、斐波那契数列
- 8、跳台阶
- 9、变态跳台阶
- 10、矩形覆盖
- 11、二进制种1的个数
- 12、数值的整数次方
- 13、调整数组顺序使奇数位于偶数前面
- 14、链表中倒数第k个结点
- 15、反转链表
- 16、合并两个排序得链表
- 17、树的子结构
- 18、二叉树的镜像
- 19、顺时针打印矩阵
- 20、包含min的函数栈
- 21、栈的压入、弹出序列
- 22、从上往下打印二叉树
- 23、二叉搜索树的后序遍历序列
- 24、二叉树中和为某一值得路径
- 25、复杂链表的复制
- 26、二叉搜索树与双向链表
- 27、字符串的排列
- 28、数组中出现次数超过一半的数字
- 29、最小的K个数
- 30、连续子数组的最大和
1、数组的查找
题目描述
在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
思路：
//遍历每一行，对每一行使用二分法查找
for(每一行){
//使用二分法查找
int start = 0;
int end = num[0].length;
while(start<=end){
if(等于){
}else if(大于){
}else if(小于){
}
}
}
public class Solution {
public boolean Find(int target, int [][] array) {
//分出行和列
int hang=array.length;
int lie=array[0].length;
//如果行或列为零的话，肯定不存在
if(hang==0 || lie==0){
return false;
}
//对每一行的数据进行比对，使用二分法查找
for(int i=0;i<hang;i++) {
//注意一下边界的关系
int start=0;
int end=lie-1;
while(start<=end) {
int mid=(start+end)/2;
if(array[i][mid]==target) {
return true;
}else if(array[i][mid]>target) {
end=mid-1;
}else if(array[i][mid]<target) {
start=mid+1;
}
}
}
//如果都找遍了，但是还没有结果，说明不存在
return false;
}
}
2、替换空格
请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。
public class Solution {
public String replaceSpace(StringBuffer str) {
int len=str.length();
for(int i=0;i<len;) {
char c=str.charAt(i);
if(c==' ') {
str.deleteCharAt(i);
str.insert(i, "%20");
len=str.length();
i+=3;
}else {
i+=1;
}
}
return str.toString();
}
}
3、从尾到头打印链表
输入一个链表，按链表从尾到头的顺序返回一个ArrayList。
方法一：使用栈作为中间存储
/**
* public class ListNode {
* int val;
* ListNode next = null;
*
* ListNode(int val) {
* this.val = val;
* }
* }
*
*/
import java.util.ArrayList;
import java.util.Stack;
public class Solution {
public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
if(listNode==null || listNode.next==null){
return new ArrayList<Integer>();
}
Stack<Integer> stack=new Stack<Integer>();
while(listNode.next!=null) {
stack.push(listNode.val);
listNode=listNode.next;
}
stack.push(listNode.val);
ArrayList<Integer> list=new ArrayList<Integer>();
while(!stack.isEmpty()) {
list.add(stack.pop());
}
return list;
}
}
方法二：使用dfs反转链表
/**
* public class ListNode {
* int val;
* ListNode next = null;
*
* ListNode(int val) {
* this.val = val;
* }
* }
*
*/
import java.util.ArrayList;
public class Solution {
public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
if(listNode==null || listNode.next==null){
return new ArrayList<Integer>();
}
ArrayList<Integer> list = new ArrayList<>();
listNode = reverse(listNode);
while(listNode!=null){
list.add(listNode.val);
listNode = listNode.next;
}
return list;
}
//反转整个链表
public ListNode reverse(ListNode head) {
if(head.next == null) {
return head;
}
ListNode last = reverse(head.next);
head.next.next = head;
head.next = null;
return last;
}
}
反转链表参考这位大佬的，从反转全部链表到部分反转链表，讲的很透彻：题解
4、重建二叉树
输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。
字节跳动笔试考到了，给出先序遍历和中序遍历，问叶子结点有多少个？
- 我先把二叉树重构再遍历树，计算叶子节点
/**
* Definition for binary tree
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
public class Solution {
public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
if(pre==null || in==null) {
return null;
}
return rebuildBinaryTreeCore(pre,0,pre.length-1,in,0,in.length-1);
}
public TreeNode rebuildBinaryTreeCore(int preorder[], int startPreorder,
int endPreorder, int inorder[], int startInorder, int endInorder) {
if (startPreorder > endPreorder || startInorder > endInorder) { //停止递归的条件
return null;
}
TreeNode root = new TreeNode(preorder[startPreorder]);
for (int i = startInorder; i <= endInorder; i++) {
if (preorder[startPreorder] == inorder[i]) {
// 其中（i - startInorder）为中序排序中左子树结点的个数
//左子树
root.left = rebuildBinaryTreeCore(preorder, startPreorder + 1,
startPreorder + (i - startInorder), inorder,
startInorder, i - 1);
//右子树
root.right = rebuildBinaryTreeCore(preorder, (i - startInorder)
+ startPreorder + 1, endPreorder, inorder, i + 1,
endInorder);
}
}
return root;
}
}
leetcode上也有相关类似的题目：
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
class Solution {
public TreeNode buildTree(int[] preorder, int[] inorder) {
if(preorder == null && inorder == null) {
return null;
}
//划分中点，划分两边
return buildTree(preorder, 0, preorder.length-1, inorder, 0, inorder.length-1);
}
public TreeNode buildTree(int[] preorder,int pStart, int pEnd, int[] inorder,int iStart,int iEnd) {
if(pStart>pEnd || iStart>iEnd) {
return null;
}
TreeNode treeNode = new TreeNode(preorder[pStart]);
for(int i=iStart; i<=iEnd; i++) {
if(preorder[pStart] == inorder[i]) {
treeNode.left = buildTree(preorder, pStart+1, pStart+1+i-iStart, inorder, iStart, i-1);
treeNode.right = buildTree(preorder, (i-iStart)+pStart+1, pEnd, inorder, i+1, iEnd);
}
}
return treeNode;
}
}
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
class Solution {
public TreeNode buildTree(int[] inorder, int[] postorder) {
if(postorder == null && inorder == null) {
return null;
}
//划分中点，划分两边
return buildTree( inorder, 0, inorder.length-1,postorder, 0, postorder.length-1);
}
public TreeNode buildTree(int[] inorder,int iStart,int iEnd,int[] postorder,int pStart, int pEnd ) {
if(pStart>pEnd || iStart>iEnd) {
return null;
}
TreeNode treeNode = new TreeNode(postorder[pEnd]);
for(int i=iStart; i<=iEnd; i++) {
if(postorder[pEnd] == inorder[i]) {
treeNode.left = buildTree(inorder, iStart, i-1,postorder, pStart, pStart+(i-1-iStart));
treeNode.right = buildTree(inorder, i+1, iEnd,postorder, pEnd-1-(iEnd-i-1), pEnd-1);
}
}
return treeNode;
}
}
5、用两个栈实现队列
用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。
思路：
.
使用一个栈作为入队的栈1，一个栈作为出队的栈2。当入栈的时候，直接往栈1里面入栈，出栈的时候，从栈2出栈。特别注意的是，当出栈的时候，栈2如果不是空的话，把栈2里面的先排空，如果栈2是空的话，把栈1里面的数据全部往栈2里面倒，再出栈，这样就能保持进栈出栈的顺序了
import java.util.Stack;
public class Solution {
Stack<Integer> stack1 = new Stack<Integer>();
Stack<Integer> stack2 = new Stack<Integer>();
public void push(int node) {
stack1.push(node);
}
public int pop() {
//首先要判断stack2里面是否为空栈，如果不是的话，先把stack里面的栈先空出来
if(!stack2.isEmpty()) {
return stack2.pop();
}else {
while(!stack1.isEmpty()) {
stack2.push(stack1.pop());
}
return stack2.pop();
}
}
}
6、旋转数组最小的数字
把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。
输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。
例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。
NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。
思路：
.
也是通过二分法做出来。首先将数组分为两个部分。例如{1,2,3,4,5}旋转成为{3,4,5,1,2}，再分为两个部分{3，4}和{5，1，2}，对比两个数组，如果start<end的话，那么说明旋转的点不在这部分上，即该部分为升序数组，如{3，4}。否则的话，说明旋转点在该部分上，继续划分该部分。如{5，1，2}，继续划分成{5}和{1，2}
import java.util.ArrayList;
import java.util.Arrays;
public class Solution {
public int minNumberInRotateArray(int [] array) {
if(array.length == 0) {
return 0;
}
int min = array[0];
int left=0, right=array.length-1;
while(left<=right) {
int mid = (left+right)/2;
min = Math.min(array[mid], min);
if(array[left]==array[mid]) {
min = Math.min(array[left], min);
left+=1;
}else if(array[left]<array[mid]) {
//说明左边有序
min = Math.min(array[left], min);
left = mid+1;
}else {
//说明右边有序
min = Math.min(array[mid+1], min);
right = mid-1;
}
}
return min;
}
}
7、斐波那契数列
大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0，第1项是1）。
n<=39
思路：最经典的深度搜索转动态规划的题目
//dfs
public class Solution {
public int Fibonacci(int n) {
if(n==0){
return 0;
}
if(n<=2){
return 1;
}
return Fibonacci(i-2)+Fibonacci(i-1);
}
}
//动态规划
public class Solution {
public int Fibonacci(int n) {
if(n==0){
return 0;
}
if(n<=2){
return 1;
}
int[] num=new int[n+1];
num[0]=0;
num[1]=1;
num[2]=1;
for(int i=3;i<=n;i++){
num[i]=num[i-2]+num[i-1];
}
return num[n];
}
}
8、跳台阶
一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。
思路，其实这个也是和斐波那契数列是一样的，在第N个台阶可以从N-1的地方上去，也可以从N-2的地方上去，由此可以看出dfs的写法
.
优化：我们上面的dfs是从自顶向下的思路写的，将一个大问题变成小问题去解决，那么我们也可以从小问题开始解决，小问题解决了大问题也就解决了。也就是使用动态规划的写法，使用一个长度为N的数组来记录跳上这一台阶有几种方法
首先base是，
当台阶为1的时候，只有1种跳法，
当台阶为2的时候，有2种跳法，
台阶为3的时候，其实只有两种跳法，
-------也就是从台阶1跳上去，和台阶2跳上去，而台阶2有两种跳法，所以台阶3有3种跳法
.
继续优化：
某一个台阶只和前面两个台阶相关，于是我们可以将空间复杂度压缩到（O1）
//方法一
public class Solution {
public int JumpFloor(int target) {
if(target==1) {
return 1;
}
if(target==2) {
return 2;
}
return JumpFloor(target-1)+JumpFloor(target-2);
}
}
//方法二
public class Solution {
public int JumpFloor(int target) {
if(target==1) {
return 1;
}
if(target==2) {
return 2;
}
int[] num = new int[target+1];
num[1] = 1;
num[2] = 2;
for(int i=3;i<target+1;i++){
num[i] = num[i-1] + num[i-2];
}
return num[target];
}
}
//方法三
public class Solution {
public int JumpFloor(int target) {
if(target==1) {
return 1;
}
if(target==2) {
return 2;
}
int[] num = new int[2];
num[0] = 1;
num[1] = 2;
for(int i=3;i<target+1;i++){
int temp = num[0] + num[1];
num[0] = num[1];
num[1] = temp;
}
return num[1];
}
}
9、变态跳台阶
一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法
思路：这道题和上面一道题的不同点在于，这个青蛙是变态的，可以从任意台接往上跳，
所以：
台阶1，有1种
台阶2，有2种
台阶3，有4种
台阶4，有8种，也就是说，某一台阶为上一台阶的两倍
public class Solution {
public int JumpFloorII(int target) {
if(target==1) {
return 1;
}
if(target==2) {
return 2;
}
int[] num=new int[target+1];
num[1]=1;
num[2]=2;
for(int i=3;i<=target;i++) {
num[i]=num[i-1]*2;
}
return num[target];
}
}
10、矩形覆盖
我们可以用21的小矩形横着或者竖着去覆盖更大的矩形。请问用n个21的小矩形无重叠地覆盖一个2n的大矩形，总共有多少种方法？
.
比如n=3时，23的矩形块有3种覆盖方法：
.
思路：也是找规律，列出上面几项，找到规律写出来
public class Solution {
public int RectCover(int target) {
if(target<=2) {
return target;
}
int[] num=new int[target+1];
num[1]=1;
num[2]=2;
for(int i=3;i<=target;i++) {
num[i]=num[i-2]+num[i-1];
}
return num[target];
}
}
11、二进制种1的个数
输入一个整数，输出该数32位二进制表示中1的个数。其中负数用补码表示。
public class Solution {
public int NumberOf1(int n) {
String binaryString = Integer.toBinaryString(n);
//System.out.println(binaryString);
int count=0;
for(char c:binaryString.toCharArray()) {
if(c=='1') {
count++;
}
}
return count;
}
}
12、数值的整数次方
给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。
.
保证base和exponent不同时为0
public class Solution {
public double Power(double base, int exponent) {
if(exponent<0) {
base=1/base;
exponent=-exponent;
}
return fastPow(base, exponent);
}
private double fastPow(double x, long n) {
if (n == 0) {
return 1.0;
}
double half = fastPow(x, n / 2);
if (n % 2 == 0) {
return half * half;
} else {
return half * half * x;
}
}
}
13、调整数组顺序使奇数位于偶数前面
输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。
public class Solution {
int [] array;
public void reOrderArray(int [] array) {
int len=array.length;
int i=0;
this.array=array;
while(i<len) {
int swap=-1;
if(array[i]%2==0) {
for(int j=i+1;j<len;j++) {
if(array[j]%2!=0) {
swap=j;
break;
}
}
if(swap!=-1) {
swap(i,swap);
swap=-1;
}else {
break;
}
}
i++;
}
}
void swap(int start,int end) {
int temp=array[end];
for(int i=end-1;i>=start;i--) {
array[i+1]=array[i];
if(i==start) {
array[i]=temp;
}
}
}
}
14、链表中倒数第k个结点
输入一个链表，输出该链表中倒数第k个结点。
思路：双指针解法：右指针先走K步，之后左右指针一起走，直到右指针为空得时候，左指针就是倒是第K个结点
/*
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}*/
import java.util.Stack;
public class Solution {
public ListNode FindKthToTail(ListNode head,int k) {
ListNode p=head;
ListNode q=head;
int i=0;
for(;p!=null;i++) {
if(i>=k) {
q=q.next;
}
p=p.next;
}
return i<k?null:q;
}
}
15、反转链表
输入一个链表，反转链表后，输出新链表的表头。
/*
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}*/
//递归
public class Solution {
public ListNode ReverseList(ListNode head) {
ListNode newHead=null;
ListNode node;
while (head != null) {
//1. 对之前的链表做头删
node = head;
head = head.next;
//2. 对新链表做头插
node.next = newHead;
newHead = node;
}
return newHead;
}
}
/*
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}*/
//dfs
public class Solution {
public ListNode ReverseList(ListNode head) {
if(head == null){
return null;
}
if(head.next == null){
return head;
}
ListNode last = ReverseList(head.next);
head.next.next = head;
head.next = null;
return last;
}
}
16、合并两个排序得链表
输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。
/*
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}*/
public class Solution {
public ListNode Merge(ListNode list1,ListNode list2) {
if(list1==null) {
return list2;
}
if(list2==null) {
return list1;
}
ListNode temp=new ListNode(-1);
ListNode result=temp;
while(list1!=null && list2!=null) {
if(list1.val<list2.val) {
temp.next=list1;
list1=list1.next;
}else {
temp.next=list2;
list2=list2.next;
}
temp=temp.next;
}
if(list2!=null) {
temp.next=list2;
}
if(list1!=null) {
temp.next=list1;
}
return result.next;
}
}
17、树的子结构
输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）
/**
public class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}
*/
public class Solution {
public boolean HasSubtree(TreeNode root1,TreeNode root2) {
boolean falg = false;
//当Tree1和Tree2都不为null的时候，才进行比较。否则直接返回false
if (root1 != null && root2 != null){
if (root1.val == root2.val){
falg = DoesTree1HaveTree2(root1,root2);
}
//根节点不匹配，则继续匹配左子节点
if (!falg){
falg = DoesTree1HaveTree2(root1.left,root2);
}
//根节点不匹配，则继续匹配右子节点
if (!falg){
falg = DoesTree1HaveTree2(root1.right,root2);
}
}
return falg;
}
public boolean DoesTree1HaveTree2(TreeNode root1,TreeNode root2){
//说明root2遍历完了，返回true
if (root2 == null){
return true;
}
//root遍历完了，root2还没，说明root2不是root1的子树
if (root1 == null){
return false;
}
//值不匹配返回false
if (root1.val != root2.val){
return false;
}
//匹配则继续递归左子节点和右子节点
return DoesTree1HaveTree2(root1.left,root2.left) &&
DoesTree1HaveTree2(root1.right,root2.right);
}
}
18、二叉树的镜像
操作给定的二叉树，将其变换为源二叉树的镜像。
/**
public class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}
*/
public class Solution {
public void Mirror(TreeNode root) {
//递归
//终止条件
if(root==null) {
return;
}
//左子数深度
Mirror(root.left);
//右子树深度
Mirror(root.right);
//交换左右子数
TreeNode temp=root.left;
root.left=root.right;
root.right=temp;
}
}
19、顺时针打印矩阵
输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下4 X 4矩阵： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.
import java.util.ArrayList;
public class Solution {
public ArrayList<Integer> printMatrix(int [][] matrix) {
ArrayList<Integer> list = new ArrayList<Integer>();
if(matrix == null || matrix.length == 0)
return list;
int m = matrix.length;
int n = matrix[0].length;
int i = 0;
//统计矩阵从外向内的层数，如果矩阵非空，那么它的层数至少为1层
int count = (Math.min(m, n)+1)/2;
//从外部向内部遍历，逐层打印数据
while(i < count) {
for (int j = i; j < n-i; j++) {
list.add(matrix[i][j]);
}
for (int j = i+1; j < m-i; j++) {
list.add(matrix[j][(n-1)-i]);
}
for (int j = (n-1)-(i+1); j >= i && (m-1-i != i); j--) {
list.add(matrix[(m-1)-i][j]);
}
for (int j = (m-1)-(i+1); j >= i+1 && (n-1-i) != i; j--) {
list.add(matrix[j][i]);
}
i++;
}
return list;
}
}
20、包含min的函数栈
定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。
思路：使用一个栈记录进入栈的所有数据，在每一次进栈的时候，记录当前栈最小的值是多少
import java.util.Stack;
public class Solution {
Stack<Integer> dataStack;
Stack<Integer> minStack;
{
dataStack=new Stack<Integer>();
minStack=new Stack<Integer>();
}
public void push(int node) {
//直接调用
dataStack.push(node);
//判断当前的min栈是否为空
if(isEmpty()) {
minStack.push(node);
}else {
Integer peek = minStack.peek();
minStack.push(node>peek?peek:node);
}
}
public void pop() {
if(isEmpty()) {
return;
}
dataStack.pop();
minStack.pop();
}
public int top() {
return dataStack.peek();
}
public int min() {
return minStack.peek();
}
private boolean isEmpty() {
return minStack.isEmpty();
}
}
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) {
if(pushA.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();
}
}
22、从上往下打印二叉树
从上往下打印出二叉树的每个节点，同层节点从左至右打印。
思路：使用队列展开BFS，比较经典的bfs，建议学习
import java.util.ArrayList;
/**
public class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}
*/
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;
public class Solution {
public ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {
//思路：使用队列来实现
ArrayList<Integer> res=new ArrayList<>();
if(root==null)
return res;
Queue<TreeNode> queue=new LinkedList<>(); //定义一个队列
queue.add(root);
while(queue.size()!=0){
TreeNode temp=queue.poll();//队头移除
res.add(temp.val);
if(temp.left!=null)
queue.add(temp.left);
if(temp.right!=null)
queue.add(temp.right);
}
return res;
}
}
23、二叉搜索树的后序遍历序列
输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则返回true,否则返回false。假设输入的数组的任意两个数字都互不相同。
思路：分治，递归
public class Solution {
public boolean VerifySquenceOfBST(int sequence[]){
if(sequence == null || sequence.length==0){
return false;
}
return verifySquenceOfBST1(sequence, 0, sequence.length - 1);
}
private boolean verifySquenceOfBST1(int[] sequence, int start, int end) {
if(start >= end){
return true;
}
int root = sequence[end]; //后序遍历的最后一个结点为根结点
//在二叉搜索树中左子树的结点小于根结点
int i = 0;
for(; i < end; ++i){
if(sequence[i] > root){
break;
}
}
//在二叉搜索树中右子树的结点大于根结点
int j = i;
for(; j < end; ++j){
if(sequence[j] < root){
return false;
}
}
//判断左子树是不是二叉树
boolean left = true;
if(i > start){
left = verifySquenceOfBST1(sequence, start, i-1);
}
//判断右子树是不是二叉树
boolean right = true;
if(i < end){
right = verifySquenceOfBST1(sequence, i, end -1);
}
return (left && right);
}
}
24、二叉树中和为某一值得路径
输入一颗二叉树的根节点和一个整数，按字典序打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。
思路：dfs回溯
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>> alist;
public ArrayList<ArrayList<Integer>> FindPath(TreeNode root,int target) {
alist=new ArrayList<ArrayList<Integer>>();
trackBack(new ArrayList<Integer>(), root, target);
return alist;
}
public void trackBack(ArrayList<Integer> list,TreeNode root,int target) {
if(root==null || root.val>target) {
return;
}
if(root.left==null && root.right==null) {
if(root.val==target) {
list.add(root.val);
alist.add(new ArrayList<Integer>(list));
return;
}
}
list.add(root.val);
ArrayList<Integer> copy=(ArrayList<Integer>) list.clone();
trackBack(list, root.left, target-root.val);
trackBack(copy, root.right, target-root.val);
}
}
25、复杂链表的复制
输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针random指向一个随机节点），请对此链表进行深拷贝，并返回拷贝后的头结点。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）
思路：先将每个结点赋值一个新的结点，放置在旧结点的后面，复制完成之后，我们回头最开始，开始复制random结点，最后一步就是新旧结点分离
/*
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 p1=pHead;
while(p1!=null){
RandomListNode temp=new RandomListNode(p1.label);
temp.next=p1.next;
p1.next=temp;
p1=temp.next;
}
p1=pHead;
//将random指针赋值
while(p1!=null){
if(p1.random!=null)
p1.next.random=p1.random.next;
p1=p1.next.next;
}
//将链表分离
RandomListNode head=pHead.next;
RandomListNode temp1=head;
p1=pHead;
while(p1.next!=null){
temp1=p1.next;
p1.next=temp1.next;
p1=temp1;
}
return head;
// return pHead;
}
}
26、二叉搜索树与双向链表
输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。
/**
public class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}
*/
public class Solution {
TreeNode head=null;
TreeNode relhead=null;
public TreeNode Convert(TreeNode pRootOfTree) {
if(pRootOfTree==null) {
return null;
}
Convert(pRootOfTree.left);
if(head==null) {
head=pRootOfTree;
relhead=pRootOfTree;
}else {
head.right=pRootOfTree;
pRootOfTree.left=head;
head=pRootOfTree;
}
Convert(pRootOfTree.right);
return relhead;
}
}
27、字符串的排列
输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则按字典序打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。
思路：dfs
import java.util.ArrayList;
public class Solution {
public ArrayList<String> Permutation(String str) {
//首先创建一个数组来定义当前是否遍历过
int len=str.length();
ArrayList<String> list=new ArrayList<String>();
if(len==0||str==null) {
return list;
}
boolean[] isVal=new boolean[len];
char[] charArray = str.toCharArray();
trackBack(list,0,isVal,charArray,new StringBuilder());
return list;
}
public void trackBack(ArrayList<String> list,int index,
boolean[] isVal,char[] charArray,
StringBuilder sb) {
int len = charArray.length;
if(index>=len) {
String str = sb.toString();
if(list.indexOf(str)<0) {
list.add(str);
}
return;
}
for(int i=0;i<len;i++) {
if(!isVal[i]) {
isVal[i]=true;
sb.append(charArray[i]);
trackBack(list, index+1, isVal, charArray, sb);
isVal[i]=false;
sb.deleteCharAt(sb.length()-1);
}
}
}
}
28、数组中出现次数超过一半的数字
数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。
import java.util.HashMap;
import java.util.Map;
public class Solution {
public int MoreThanHalfNum_Solution(int [] array) {
int i=0,len=array.length;
if(array==null || len==0) {
return 0;
}
Map<Integer, Integer> map=new HashMap<Integer, Integer>();
int target=len/2;
int num=0;
while(i<len) {
int put=map.getOrDefault(array[i], 0)+1;
map.put(array[i], put);
if(put>target) {
num=array[i];
break;
}
i++;
}
return num;
}
}
29、最小的K个数
输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4。
//使用傻子API
import java.util.ArrayList;
import java.util.Arrays;
public class Solution {
public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
ArrayList<Integer> list=new ArrayList<Integer>();
if(k>input.length) {
return list;
}
Arrays.sort(input);
for(int i=0;i<k;i++) {
list.add(input[i]);
}
return list;
}
}
//使用快速排序
//一次快速排序下来，大于这个基准的全在这个基准右边，小于这个基准的全部在这个基准的左边
//然后判断这个基准的位置和K的位置，决定向那一边排序
class Solution {
public int[] getLeastNumbers(int[] arr, int k) {
if(arr==null || arr.length==0){
return null;
}
if(arr.length==1){
return arr;
}
if(k==0){
return new int[0];
}
quickSort(arr,0,arr.length-1,k-1);
int[] re = new int[k];
for(int i=0;i<k;i++){
re[i] = arr[i];
}
return re;
}
public void quickSort(int[] a ,int low,int high,int k) {
int start = low;
int end = high;
int temp = a[low];//标记值
while (start < end){
//通行条件：while()中的值为停止循环条件，即标记值更小就停止循环
while (start < end && temp <= a[end]){
end--;
}
//再次确认标记值是否大于后面的值
if (temp > a[end]){
a[start] = a[end];
a[end] =temp;
}
while (start < end && temp >= a[start]){//标记值更大就停止循环
start++;
}
if (temp < a[start]){
a[end] = a[start];
a[start] = temp;
}
}
//当start >= end 时将跳出循环
//此时temp值一定会在数组的中间 即(a =2,1,3,4,6,5,)， 左边比3小，右边比3大
if(start==k) {
return;
}else if(start<k) {
//说明在右边
quickSort(a, end+1, high, k);
}else {
//说明在左边
quickSort(a, low, start-1, k);
}
}
}
如果不懂快排的，可以去看看我的这篇博客
30、连续子数组的最大和
HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。给一个数组，返回它的最大连续子序列的和，你会不会被他忽悠住？(子向量的长度至少是1)
public class Solution {
public int FindGreatestSumOfSubArray(int[] array) {
int max=array[0];
int ans=array[0];
//正数溢出
for(int i=1;i<array.length;i++) {
int temp=ans+array[i];
if(ans<0) {
ans=array[i];
}else {
ans=temp;
}
max=Math.max(max, ans);
}
return max;
}
}
1304
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
