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

来源：互联网发布：美国基因检测数据编辑：程序博客网时间：2024/05/18 12:40

小范围排序

已知一个几乎有序的数组，几乎有序是指，如果把数组排好顺序的话，每个元素移动的距离可以不超过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]

解题分析

。。。（有时间再写）

代码思路

首先先构建K个元素的小根堆heap

取出根节点放入A[0]，且把A[k]放入heap[0]；

继续调整成小根堆

重复步骤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

解题思路

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

代码思路

使用堆排序算法排序好数组（堆排序实现思路就不提供了）

再遍历数组对比找出是否存在相同数据

代码

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;    }}

0 0