《剑指offer》算法题第十天

今日题目：

1. 数组中的逆序对
2. 两个链表的第一个公共节点
3. 数字在排序数组中出现的次数
4. 二叉搜索树的第k大节点
5. 字符流中第一个不重复的字符

1. 数组中的逆序对

题目描述：
在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。

思路：
这道题运用归并排序的思想来求解，归并排序是面试中经常问到的知识点，得经常翻出来熟悉熟悉。

代码如下：

 public class Solution {
     int cnt;

     public int InversePairs(int[] array) {
         cnt = 0;
         if (array != null)
             mergeSortUp2Down(array, 0, array.length - 1);
         return cnt;
     }

     /*
      * 归并排序(从上往下)
      */
     public void mergeSortUp2Down(int[] a, int start, int end) {
         if (start >= end)
             return;
         int mid = (start + end) >> 1;

         mergeSortUp2Down(a, start, mid);
         mergeSortUp2Down(a, mid + 1, end);

         merge(a, start, mid, end);
     }

     /*
      * 将一个数组中的两个相邻有序区间合并成一个
      */
     public void merge(int[] a, int start, int mid, int end) {
         int[] tmp = new int[end - start + 1];

         int i = start, j = mid + 1, k = 0;
         while (i <= mid && j <= end) {
             if (a[i] <= a[j])
                 tmp[k++] = a[i++];
             else {
                 tmp[k++] = a[j++];
                 cnt += mid - i + 1;  // core code, calculate InversePairs............
                 cnt %= 1000000007;
             }
         }

         while (i <= mid)
             tmp[k++] = a[i++];
         while (j <= end)
             tmp[k++] = a[j++];
         for (k = 0; k < tmp.length; k++)
             a[start + k] = tmp[k];
     }
 }

2.两个链表中的第一个公共节点

题目描述：
输入两个链表，找出它们的第一个公共结点。

思路：
《剑指offer》中的参考答案利用了两个栈来分别存储两个链表，然后从链尾到链头遍历两个链表，寻找公共的节点。但是博主觉得没必要那么麻烦，运用一个hashset就能够处理这道题。
另外，在这道题的讨论区中，有一个特别精妙的方法，利用两个指针遍历数组，第一趟得到链表长度的差值，第二趟寻找公共节点，下面也会贴出来。

代码如下：

//利用hashset
import java.util.HashSet;
public class Solution {
    public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
        if(pHead1 == null || pHead2 == null) return null;
        HashSet<ListNode> set = new HashSet();
        while(pHead1 != null){
            set.add(pHead1);
            pHead1 = pHead1.next;
        }
        while(pHead2 != null){
            if(set.contains(pHead2))
                return pHead2;
            pHead2 = pHead2.next;
        }
        return null;
    }
}

//两个指针的方法
public class Solution {
    public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
        ListNode p1 = pHead1;
        ListNode p2 = pHead2;
        while(p1 != p2){
            p1 = (p1==null ? pHead2 : p1.next);
            p2 = (p2==null ? pHead1 : p2.next);
        }
        return p1;
    }
}

3.数字在排序数组中出现的次数

题目描述：
统计一个数字在排序数组中出现的次数。

思路：
比较直接的方法是直接遍历数组，统计目标数字出现的次数，时间复杂度为O(n)。
比较快的方法是利用二分查找的思想，时间复杂度可达到O(logn)。

代码如下：

 public class Solution {
     int count = 0;
     public int GetNumberOfK(int [] array , int k) {
         binSearch(array,k,0,array.length-1);
         return count;
     }

     public void binSearch(int[] nums,int k,int start,int end){
         if(start == end){
             if(nums[start] == k) count++;
             return;
         }else if(start < end){
             int mid = (start+end)/2;
             if(nums[mid] == k){
                 count++;
                 binSearch(nums,k,start,mid-1);
                 binSearch(nums,k,mid+1,end);
             }else if(nums[mid] < k){
                 binSearch(nums,k,mid+1,end);
             }else{
                 binSearch(nums,k,start,mid-1);
             }
         }
     }
 }

4.二叉搜索树的第k大节点

题目描述：
给定一颗二叉搜索树，请找出其中的第k大的结点。例如， 5 / \ 3 7 /\ /\ 2 4 6 8 中，按结点数值大小顺序第三个结点的值为4。

思路：
比较直接，二叉树的中序遍历。不过需要提一下的是，二叉树三种遍历顺序的递归和迭代实现方式都得非常熟悉。

代码如下：

 import java.util.Stack;
 public class Solution {
     TreeNode KthNode(TreeNode pRoot, int k){
         if(pRoot == null || k == 0) return null;
         Stack<TreeNode> stack = new Stack();
         int count = 0;
         while(pRoot != null || !stack.isEmpty()){
             if(pRoot != null){
                 stack.push(pRoot);
                 pRoot = pRoot.left;
             }else{
                 pRoot = stack.pop();
                 count++;
                 if(count == k)
                     return pRoot;
                 pRoot = pRoot.right;
             }
         }
         return null;
     }
 }

5.字符流中第一个不重复的字符

题目描述：
请实现一个函数用来找出字符流中第一个只出现一次的字符。例如，当从字符流中只读出前两个字符"go"时，第一个只出现一次的字符是"g"。当从该字符流中读出前六个字符“google"时，第一个只出现一次的字符是"l"。

思路：
这道题和之前的求一个数据流中的中位数的题相似，重点是如何选择一个合适的数据结构来存储数据，是的插入和查询的效率都比较高。
在这道题中，《剑指offer》给的参考答案是声明一个int型的数组来存储各个字符的状态。这种思想非常地重要，应多做练习来熟悉。

代码如下：

 public class Solution {
     //Insert one char from stringstream
     int[] map = new int[256];
     int index = 1;
     public void Insert(char ch)
     {//0代表还未出现相应的字符，-1代表出现一次以上，其他数字代表什么时候出现
         if(map[ch] == 0)
             map[ch] = index;
         else if(map[ch] > 0)
             map[ch] = -1;
         index ++;
     }
   //return the first appearence once char in current stringstream
     public char FirstAppearingOnce()
     {
         int min = Integer.MAX_VALUE;
         int ind = -1;
         for(int i = 0; i < 256; i++){//找出大于0的最小值及其坐标
             if(map[i] > 0 && map[i] < min){
                 min = map[i];
                 ind = i;
             }
         }
         if(ind == -1)//不存在大于0的数，则没有字符出现一次
             return '#';
         else
             return (char)ind;
     }
 }