刷题第四天

今天也是一觉到十点的一天，王哥今天走，所以今天刷题比较没有心情哦
提醒自己一下要持续关注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;
    }
}