剑指offer-Day05(28/35)

最新推荐文章于 2024-07-14 14:13:59 发布

原创最新推荐文章于 2024-07-14 14:13:59 发布 · 112 阅读

0 ·

CC 4.0 BY-SA版权

剑指offer 专栏收录该内容

5 篇文章

订阅专栏

这篇博客介绍了两种算法问题的解决方案。第一部分讲解了如何找到数组中出现次数超过一半的数字，提供了排序和哈希两种方法。第二部分探讨了计算数组中逆序对数量的问题，通过快慢指针和归并排序两种策略进行解决。这些算法在处理大规模数据时具有高效性。

JZ28-数组中出现次数超过一般的数字：

题目描述：

数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组[1,2,3,2,2,2,5,4,2]。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。你可以假设数组是非空的，并且给定的数组总是存在多数元素。1<=数组长度<=50000

示例：

input：[1,2,3,2,2,2,5,4,2]

output：2

题解思路1(数组)：

首先对数组进行排序，由于该数组中的某个元素超过了数组长度的一半，其必然位于数组的中间。

Code：

import java.util.Arrays;

public class Solution {
    public int MoreThanHalfNum_Solution(int [] array) {
        if(array.length == 0) return 0;
        // 先对数组进行排序
        Arrays.sort(array);
        // 找到位于中间的元素，返回
        return array[array.length/2];
    }
}

题解思路2(哈希)：

遍历数组，将数组元素array[i]作为key，出现次数作为value存入map，通过key遍历map查看其中value值大于数组长度一半的key。

Code：

import java.util.HashMap;
import java.util.Map;

public class Solution {
    public int MoreThanHalfNum_Solution(int [] array) {
         if(array.length == 0) return 0;

        // 创建HashMap用于存储键值对
        Map<Integer,Integer> map = new HashMap<>();

        // 遍历数组将键值对存入数组中
        for(int i = 0; i < array.length; i++){
            if(!map.keySet().contains(array[i])){
                // 如果该元素未存入过
                map.put(array[i], 1);
            } else {
                map.put(array[i],map.get(array[i]) + 1);
            }
        }
        // 遍历键值集合
        for (Integer key: map.keySet()) {
            if(map.get(key) > array.length/2) return key;
        }
        return 0;
    }
}

JZ35-数组中的逆序对：

题目描述：

在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。即输出P%1000000007

对于50\%50%的数据,size\leq 10^4size≤104
对于100\%100%的数据,size\leq 10^5size≤105

示例：

input：[1,2,3,4,5,6,7,0]

output：7

题解思路1(快慢指针)：

通过快慢指针遍历数组，计数逆序对。

Code：

public class Solution {
    public int InversePairs(int [] array) {
        // 通过快慢指针实现
        int n = array.length;
        if (n == 0) return 0;
        int p = 0;

        //遍历数组
        for(int slow = array.length-1; slow > 0; slow--){
            for(int quick = slow -1; quick >= 0; quick--){
                if(array[quick] > array[slow]) p++;
            }
        }
        return p%1000000007;
    }
}

题解思路2(归并排序)：

Code：

public class Solution {
    private int cnt;
    private void MergeSort(int[] array, int start, int end){
        if(start>=end)return;
        int mid = (start+end)/2;
        MergeSort(array, start, mid);
        MergeSort(array, mid+1, end);
        MergeOne(array, start, mid, end);
    }
    private void MergeOne(int[] array, int start, int mid, int end){
        int[] temp = new int[end-start+1];
        int k=0,i=start,j=mid+1;
        while(i<=mid && j<= end){
//如果前面的元素小于后面的不能构成逆序对
            if(array[i] <= array[j])
                temp[k++] = array[i++];
            else{
//如果前面的元素大于后面的，那么在前面元素之后的元素都能和后面的元素构成逆序对
                temp[k++] = array[j++];
                cnt = (cnt + (mid-i+1))%1000000007;
            }
        }
        while(i<= mid)
            temp[k++] = array[i++];
        while(j<=end)
            temp[k++] = array[j++];
        for(int l=0; l<k; l++){
            array[start+l] = temp[l];
        }
    }
    public int InversePairs(int [] array) {
        MergeSort(array, 0, array.length-1);
        return cnt;
    }
}