leetcode算法题-剑指Offer篇（17）

1、数组中的逆序对

1.1 题目描述：

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

1.2 题解

1.2.1 暴力求解

  public int reversePairs(int[] nums) {
        int count=0;
        for(int i=0;i<nums.length-1;i++){
            for(int j=i+1;j<nums.length;j++){
                if(nums[i]>nums[j])
                    count++;
            }
        }
        return count;
    }

1.2.2 归并排序

 public int reversePairs(int[] nums) {
        int len = nums.length;
        if (len < 2)
            return 0;
        int[] copy = new int[len];//操作数组
        for (int i = 0; i < len; i++) {
            copy[i] = nums[i];
        }
        int[] temp = new int[len];//辅助数组
        return reversePairs(copy, 0, len - 1, temp);
    }

    /**
     * nums[left..right] 计算逆序对个数并且排序
     *
     * @param copy
     * @param left
     * @param right
     * @param temp
     * @return
     */
    private int reversePairs(int[] copy, int left, int right, int[] temp) {
        if (left == right)//退出递归的条件，当递归当一个数时
            return 0;

        int mid = left + (right - left) / 2;//避免大数计算错误
        int leftCount = reversePairs(copy, left, mid, temp);
        int rightCount = reversePairs(copy, mid + 1, right, temp);

        if (copy[mid] <= copy[mid + 1]) {//如果已经是排序完成的状态，则直接返回
            return leftCount + rightCount;
        }
        int count = mergeAndCount(copy, left, mid, right, temp);
        return leftCount + rightCount + count;

    }

    /**
     * 合并处理
     *
     * @param copy
     * @param left
     * @param mid
     * @param right
     * @param temp
     * @return
     */
    private int mergeAndCount(int[] copy, int left, int mid, int right, int[] temp) {

        for (int i = left; i <= right; i++) {
            temp[i] = copy[i];
        }
        int count = 0;
        int l = left, r = mid + 1;
        for (int j = left; j <= right; j++) {
            if (l == mid + 1) {//如果左侧已经排序完毕
                copy[j] = temp[r];
                r++;
            } else if (r == right + 1) {//如果右侧已经排序完毕
                copy[j] = temp[l];
                l++;
            } else if (temp[l] <= temp[r]) {//按序插入
                copy[j] = temp[l];
                l++;
            } else {
                copy[j] = temp[r];
                r++;
                count += (mid - l + 1);
            }
        }
        return count;
    }

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

2.1 题目描述：

输入两个链表，找出它们的第一个公共节点。
如下面的两个链表：
在节点 c1 开始相交。

2.2 题解

2.2.1 双指针法

解法形象来说就是：
你变成我，走过我走过的路。
我变成你，走过你走过的路。
然后我们便相遇了…

  public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode node1 =headA;
        ListNode node2 =headB;
        while(node1!=node2){
            node1=node1!=null?node1.next:headB;
            node2=node2!=null?node2.next:headA;
        }
        return node1;
    }

3、在排序数组中查找数字 I

3.1 题目描述：

示例 1:
输入: nums = [5,7,7,8,8,10], target = 8
输出: 2

3.2 题解

3.2.1二分法

排序数组中的搜索问题，首先想到 二分法 解决。

  public int search(int[] nums, int target) {
        return helper(nums, target) - helper(nums, target - 1);
    }
    int helper(int[] nums, int tar) {
        int i = 0, j = nums.length - 1;
        while(i <= j) {
            int m = (i + j) / 2;
            if(nums[m] <= tar) i = m + 1;
            else j = m - 1;
        }
        return i;
    }