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