算法题——Find the Duplicate Number（JAVA）

最新推荐文章于 2024-01-18 12:04:36 发布

ivyusing

最新推荐文章于 2024-01-18 12:04:36 发布

阅读量242

点赞数

CC 4.0 BY-SA版权

分类专栏：算法文章标签： java 算法

本文链接：https://blog.youkuaiyun.com/ivyusing/article/details/57586397

算法专栏收录该内容

20 篇文章

订阅专栏

本文介绍了一种利用堆排序解决寻找数组中重复数字的问题的方法。通过构建最大堆并进行堆排序，可以实现在O(n log n)的时间复杂度内完成排序，并在O(1)的空间复杂度下找出数组中唯一的重复数字。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目描述：
Given an array nums containing n + 1 integers where each integer is between 1 and n (inclusive), prove that at least one duplicate number must exist. Assume that there is only one duplicate number, find the duplicate one.

Note:
You must not modify the array (assume the array is read only).
You must use only constant, O(1) extra space.
Your runtime complexity should be less than O(n2).
There is only one duplicate number in the array, but it could be repeated more than once.

读题：
1.时间复杂度O（n^2）
2.空间复杂度O（1）
3.只有一个数字是重复的

知识储备：
堆排序同时满足时间和空间复杂度要求。
堆是一棵完全二叉树。使用最大堆，最大堆的最大元素一定在第0位置，其操作内容如下：对于每个节点i，我们考察他与子节点的大小，如果他比某个子节点小，则将他与子节点中最大的那个互换位置，然后在相应的子节点位置重复操作，直到到达堆的叶子节点或者考察的位置比子节点的值都要大为止。
构建好堆之后，交换0位置元素与顶，将heapsize减1，然后再在根节点出调用最大堆过程将新的堆重新最大堆化。依次循环，我们每次都能将现有堆中最大的元素放到堆末尾。最后就完成了整个排序过程。堆排序为原位排序(空间小), 且最坏运行时间是O(nlgn)，是渐进最优的比较排序算法。

解题思路：
1.使用堆排序排列数组
2.将每一个元素与下一个元素的值进行比较，若相等，则该值为重复的数字

提交代码：

public class Solution {
    int[] heap;
    int heapsize;
    public int findDuplicate(int[] nums) {
        int re = 1;
        this.heap = nums;    
        this.heapsize = heap.length;
        BuildMaxHeap();
        HeapSort();
        for(int i = 0; i < nums.length - 1; i++) {
            if (nums[i] == nums[i+1]) {
                re = nums[i];
                break;
            }
        }
        return re;
    }
    public void BuildMaxHeap() {
        for (int i = heapsize / 2 - 1; i >= 0; i--) {
            Maxify(i);
        }
    }
    public void Maxify(int i) {
        int l = Left(i);
        int r = Right(i);
        int largest;
        if (l < heapsize && heap[l] > heap[i])
            largest = l;
        else
            largest = i;
        if (r < heapsize && heap[r] > heap[largest])
            largest = r;
        if (largest == i || largest >= heapsize)
            return;
        int tmp = heap[i];
        heap[i] = heap[largest];
        heap[largest] = tmp;
        Maxify(largest);
    }
    public void HeapSort() {
        for (int i = 0; i < heap.length; i++) {
            int tmp = heap[0];
            heap[0] = heap[heapsize-1];
            heap[heapsize-1] = tmp;
            heapsize--;
            Maxify(0);
        }
    }
    private int Parent(int i) {
        return (i-1)/2;
    }
    private int Left(int i) {
        return 2*(i+1)-1;
    }
    private int Right(int i) {
        return 2*(i+1);
    }
}