算法--小范围排序

---

小范围排序

时间复杂度

 

 

 

 

冒泡排序，选择排序不管原始序列怎么样，都是严格的O(N^2)

 

 

package com.hzf.sort;

import org.junit.Test;

public class ScaleSort {
    public int[] sortElement(int[] A, int n, int distance) {
        for (int i = 0; i < A.length - distance; i++) {
            if (i == (A.length - distance -1)) {  //如果只剩下最后k个数,使用插入排序
               for(i = A.length - distance; i < A.length; i++){
                   int j = i;
                   int target = A[j];
                   while(j > 0 && A[j-1] > target){
                       A[j] = A[j-1];
                       j--;
                   }
                   A[j] = target;
               }
               break;
            }
            //如果不是剩下最后k个数，那么构建最小堆
            buildMinHeap(A, i, distance+1);
        }
        return A;
    }

    public void swap(int[] arr, int m, int n) {
        int temp = arr[m];
        arr[m] = arr[n];
        arr[n] = temp;
    }

    public void buildMinHeap(int[] arr, int oldIndex, int heapSize) {
        
        int[] heapArr = new int[heapSize];//构建新的数组，便于构建最小堆
        int m = 0;
        
        //将传入的数组遍历到heapArr中
        for(int i=oldIndex; i<(oldIndex+heapSize); i++){
            heapArr[m++] = arr[i];
        }
        
        //从heapArr最后一个元素的父元素开始构建最小堆
        int j = (heapArr.length - 1)/2;
        int lastIndex = heapSize-1;
        
        while(j >= 0){
            int rootIndex = j;
            adjustHeap(heapArr, rootIndex, lastIndex);
            j--;
        }
        //将构建好的最小堆赋值到原数组中
        for(m=0; m<heapSize; m++){
            arr[oldIndex++] = heapArr[m];
        }
    }

    public void adjustHeap(int[] heapArr, int rootIndex, int lastIndex) {
        int smallerIndex = rootIndex;
        int leftChildIndex = rootIndex * 2 + 1;
        int rightChildIndex = rootIndex * 2 + 2;
        
        if(rightChildIndex <= lastIndex){//如果右孩子存在，那么左孩子一定存在
            if(heapArr[rightChildIndex] < heapArr[rootIndex] || heapArr[leftChildIndex] < heapArr[rootIndex]){
                smallerIndex = heapArr[leftChildIndex] < heapArr[rightChildIndex] ? leftChildIndex : rightChildIndex;
            }
        }else if(leftChildIndex <= lastIndex){//其他情况，如果右孩子不存在，那么左孩子可能存在,如果左孩子存在，保证它不能越界
            if(heapArr[leftChildIndex] < heapArr[rootIndex]){
                smallerIndex = leftChildIndex;
            }
        }
        if(smallerIndex != rootIndex){//判断此时最大元素的下标是否改变，如果改变交换位置
            swap(heapArr, rootIndex, smallerIndex);
            adjustHeap(heapArr,smallerIndex,lastIndex);//一旦发生交换，那么子树可能不是最小堆(最大堆)，接着往下调整
        }
    }
    @Test
    public void test() {
        int[] a = new int[] { 3, 2, 1, 4, 11, 5, 10, 13, 12 };

        System.out.println("排序前");
        for (int temp : a) {
            System.out.print(temp + " ");
        }

        sortElement(a, 9, 2);// 基数排序

        System.out.println("
排序后");
        for (int temp : a) {
            System.out.print(temp + " ");
        }
    }
}

测试结果