今天也是一觉到十点的一天,王哥今天走,所以今天刷题比较没有心情哦
提醒自己一下要持续关注xds和gq的事情
1. 重建二叉树
题目描述:输入某二叉树的前序遍历和中序遍历的结果,请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6},则重建二叉树并返回。
思路:重建二叉树就是不断地识别根节点和左右子树然后依次重建的过程,众所周知,前序是根左右,中序是左根右,具体思路是这样,搞到前序的第一个root那么他就是一个根节点,然后找到他在中序对应的位置,那么他之前就是左子树的中序,他之后就是右子树的中序,根据他前后中序序列的个数,可以分割出在前序序列中,左右子树的起始和终止,因此可以划分出,左前,左中,右前,右中然后递归下去
public class Solution {
public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
TreeNode root=re(pre,0,pre.length-1,in, 0, in.length-1);
return root;
}
public TreeNode re(int[] pre, int ps, int pe, int[] in, int ns, int ne){
if(ps>pe||ns>ne)
return null;
TreeNode root=new TreeNode(pre[ps]);
for(int i=ns;i<=ne;i++)
{
if(in[i]==pre[ps])
{
root.left=re(pre,ps+1,ps+i-ns,in,ns,i-1);
root.right=re(pre,ps+i-ns+1,pe,in, i+1, ne);
}
}
return root;
}
}
2. 二叉树镜像
题目描述:操作给定的二叉树,将其变换为源二叉树的镜像。
只想写递归的方法循环的不想弄,就这样吧,就是一步步地交换左右子树,没啥
public class Solution {
public void Mirror(TreeNode root) {
if(root==null)
return;
TreeNode temp;
temp=root.right;
root.right=root.left;
root.left=temp;
Mirror(root.left);
Mirror(root.right);
}
}
3. 统计一个数字在排序数组中出现的次数
题目描述:如题
思路是,二分查找先找出,k第一次出现的index1, 然后找出k最后一次出现的index2,然后呢,index2-index1+1就可以找出来,然后,千万记得排除没出现的情况,是个巨坑
public class Solution {
public int GetNumberOfK(int [] array , int k) {
int indexf=0,indexl=0;
indexf=getFirstk(array, k);
indexl=getLastk(array,k);
if(indexf==-1||indexl==-1)
return 0;
return indexl-indexf+1;
}
public int getFirstk(int[] array, int k){
int low=0, high=array.length-1,mid=0;
while(low<=high)
{
mid=(low+high)/2;
if(array[low]==k)
return low;
if(array[mid]<k)
{
low=mid+1;
}
else if(array[mid]>k)
{
high=mid-1;
}
else low++;
}
return -1;
}
public int getLastk(int[] array, int k){
int low=0, high=array.length-1,mid=0;
while(low<=high)
{
mid=(low+high)/2;
if(array[high]==k)
return high;
if(array[mid]<k)
{
low=mid+1;
}
else if(array[mid]>k)
{
high=mid-1;
}
else high--;
}
return -1;
}
}
其实有点懒了,但是还是再做两题吧,毕竟昨天偷懒了一小会
4. 和为S的两个数字
题目描述:输入一个递增排序的数组和一个数字S,在数组中查找两个数,使得他们的和正好是S,如果有多对数字的和等于S,输出两个数的乘积最小的。
题目思路:一般看到排序数组那想都不必想,时间复杂度绝对是O(n)甚至O(logN), 这道题也可以使用二分来做,但是我太懒了不想写,自己手残写下好多坑,首先,本身为空和找不到两个边界情况要考虑,另外一个是,当找到正确答案的时候要继续检索,以找到乘积最小的, 忘记说思路了,用的是双指针思想,当加起来小于目标时候,说明过小,前指针移动,当加起来过大时,后指针移动。
import java.util.ArrayList;
public class Solution {
public ArrayList<Integer> FindNumbersWithSum(int [] array,int sum) {
ArrayList<Integer> ans=new ArrayList<Integer>();
if(array.length==0)
return ans;
int p1=0,p2=array.length-1,ans1=-1,ans2=-1;
int product=array[array.length-1]*array[array.length-2];
int s=0;
while(p1<p2)
{
s=array[p1]+array[p2];
if(s<sum) p1++;
else if(s>sum) p2--;
else
{
if(array[p1]*array[p2]<product)
{
product=array[p1]*array[p2];
ans1=p1;
ans2=p2;
}
p1++;
p2--;
}
}
if(ans1==-1&&ans2==-1)
{
return ans;
}
else
{
ans.add(array[ans1]);
ans.add(array[ans2]);
return ans;
}
}
}
5. 合并两个排序的链表
题目描述:输入两个单调递增的链表,输出两个链表合成后的链表,当然我们需要合成后的链表满足单调不减规则。
解题思路:今晚一晚上都在做这种唯手熟尔的题,典型的二路归并原题,没啥难度。
import java.util.ArrayList;
public class Solution {
public ListNode Merge(ListNode list1,ListNode list2) {
ArrayList<Integer> array=new ArrayList<Integer>();
while(list1!=null&&list2!=null)
{
if(list1.val<=list2.val){
array.add(list1.val);
list1=list1.next;
}
else
{
array.add(list2.val);
list2=list2.next;
}
}
while(list1!=null)
{
array.add(list1.val);
list1=list1.next;
}
while(list2!=null)
{
array.add(list2.val);
list2=list2.next;
}
ListNode head=new ListNode(0);
ListNode pre=head;
for(int i=0;i<array.size();i++)
{
ListNode newNode=new ListNode(array.get(i));
newNode.next=null;
pre.next=newNode;
pre=newNode;
}
return head.next;
}
}
由于前面刷的题没有什么含金量,决定再刷一题睡觉了
6. 包含min函数的栈
题目描述:定义栈的数据结构,请在该类型中实现一个能够得到栈中所含最小元素的min函数(时间复杂度应为O(1))
这道题还挺巧妙的,其实就是想让你去维护这个栈的最小值,那么入栈的时候,维护还算简单,但是出栈刷新最小值,就有些麻烦了,所以思路是维护一个最小值栈,当出栈时判断和最小值栈顶是否相同,如果相同需要同时出栈,还有异或操作的还没看懂,明天吧
import java.util.Stack;
public class Solution {
Stack<Integer> originalStack=new Stack<Integer>();
Stack<Integer> minStack=new Stack<Integer>();
int min=10000;
public void push(int node) {
if(originalStack.empty())
{
min=node;
minStack.push(min);
}
if(node<min)
{
min=node;
minStack.push(min);
}
originalStack.push(node);
}
public void pop() {
if(originalStack.peek()==minStack.peek()
minStack.pop();
originalStack.pop();
}
public int top() {
return originalStack.search(originalStack.peek());
}
public int min() {
return minStack.peek();
}
}
7. 树的子结构
题目描述:输入两棵二叉树A,B,判断B是不是A的子结构。(ps:我们约定空树不是任意一个树的子结构)
解题思路:首先先考虑树A和树B是否同构,如果根节点同构则继续比较左右子树,当B先遍历完,说明同构,但如果A先遍历完,则说明并非同构,
若树A树B根节点不同,则继续比较树A的左子树和B的根,以及A的右子树和B的根
public class Solution {
public boolean HasSubtree(TreeNode root1,TreeNode root2) {
if(root1==null||root2==null)
return false;
return core(root1,root2)||HasSubtree(root1.left,root2)||HasSubtree(root1.right,root2);
}
public boolean core(TreeNode root1, TreeNode root2)
{
if(root2==null)
return true;
if(root1==null)
return false;
if(root1.val == root2.val)
{
return core(root1.left, root2.left)&&core(root1.right,root2.right);
}
else
return false;
}
}