数组排序 —— 堆排序算法的应用（小范围排序、重复值判断）

小范围排序

已知一个几乎有序的数组，几乎有序是指，如果把数组排好顺序的话，每个元素移动的距离可以不超过k，并且k相对于数组来说比较小。请选择一个合适的排序算法针对这个数据进行排序。 给定一个int数组A，同时给定A的大小n和题意中的k，请返回排序后的数组。

---

测试样例

[2,1,4,3,6,5,8,7,10,9],10,2
返回：[1,2,3,4,5,6,7,8,9,10]

---

解题分析

。。。（有时间再写）

---

代码思路

1. 首先先构建K个元素的小根堆heap
2. 取出根节点放入A[0]，且把A[k]放入heap[0]；
3. 继续调整成小根堆
4. 重复步骤2、3，且数据不断加1 5、直到i = n-1， 紧接着排序最后的k个元素

---

代码

import java.util.*;

public class ScaleSort {
    public int[] sortElement(int[] A, int n, int k) {
        if (A == null || A.length == 0 || n < k)
            return null;


        int[] heap = new int[k];
        for (int i = 0; i < k; i++){
            heap[i] = A[i];
        }
        // 构建小根堆
        for (int i = k/2-1; i >= 0; i--){
            ajustHeap(heap, i, k);
        }

        for (int i = k; i < n; i++){
            A[i-k] = heap[0]; // heap的根节点插入A里，且再向上移一位
            heap[0] = A[i];   // 从下一个元素放入heap堆顶！
            ajustHeap(heap, 0, k);  
        }
        // 排序最后的K 个数字，且放入A里
        for (int i = n-k; i < n; i++){
            A[i] = heap[0];
            heap[0] = heap[k-1];
            k = k-1;
            ajustHeap(heap, 0, k);
        }
        return A;
    }
    // 根据节点调整成小根堆
    public void ajustHeap(int[] heap, int k, int len){
        int temp = heap[k];
        for (int i = k*2+1; i < len; i = i*2+1){
            if (i < len-1){
                if (heap[i] > heap[i+1]){
                    i++;
                }
            }
            if (temp <= heap[i]){
                break;
            }
            else{
                heap[k] = heap[i];
                k = i;
            }
        }
        heap[k] = temp;
    }
}

---

重复值判断

请设计一个高效算法，判断数组中是否有重复值。必须保证额外空间复杂度为O(1)。给定一个int数组A及它的大小n，请返回它是否有重复值。

测试样例：
[1,2,3,4,5,5,6],7
返回：true

---

解题思路

1. 对于有空间复杂度限制，我们可以先排序，再判断的思路。因为排好序后，重复值排在了相邻位置。此时，问题就转化为了，空间复杂度限制为O(1)的情况下，考察经典排序算法，怎么实现一个最快的算法。
2. 空间复杂度为O(1)的有冒泡、选择、插入、希尔排序以及非递归形式的堆排序，再根据时间复杂度判断，堆排序为O(NlogN)，可以知道使用非递归实现的堆排序最快。
   此时的步骤就是，先通过堆排序将数组排好序，然后在遍历一遍数组，比较相邻两元素值是否相等。代

---

代码思路

1. 使用堆排序算法排序好数组（堆排序实现思路就不提供了）
2. 再遍历数组对比找出是否存在相同数据

---

代码

import java.util.*;

public class Checker {
    public boolean checkDuplicate(int[] a, int n) {

        heapSort(a, n);
        for (int i = 0; i < n-1; i++){
            if (a[i] == a[i+1])
                return true;
        }
        return false;
    }

    public  void swap(int[] A, int a, int b) {
        int temp = A[a];
        A[a] = A[b];
        A[b] = temp;
    }

    public  int[] heapSort(int[] A, int n) {

        // 开始的时候先排序，让每个节点为子节点的最大数
        for (int i = n / 2-1; i >= 0; i--) {
            buildHeap(A, i, n);

        }
        // 将第一位根节点最大数与最后一位交换，个数减一，接着构建根节点，再交换...
        for (int i = n-1; i > 0; i--) {
            swap(A, 0, i);            // i 为末尾数
            buildHeap(A, 0, i);        //    i 为还剩下的个数，包括 0 位，所以就不减一了！
        }
        return A;
    }


    public  void buildHeap(int[] A, int node, int n) {

        int temp = A[node];
        // 因为从 0 开始，所以需要加上 1
        for (int i = node * 2 + 1; i < n; i = i*2 +1) {
            // 防止没有右节点
            if (i < n-1){
                // 左右节点比较
                if (A[i] < A[i + 1]){        
                    i++;
                }
            }
            // node节点与子节点比较，如果大于就不需要再比较了
            if (temp >= A[i]) {
                break;
            }
            else{
                A[node] = A[i];
                node = i;
            }
        }
        A[node] = temp;
    }
}

---