文章标题

public class Sort {

public static void swap(int[] array,int i,int j){
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}

public static  void insertSort(int[] arrayToSort){

for( int i = 0 ; i < arrayToSort.length; ++i){

//从i的位置往前去排 保证i前面的分片是有序的
for( int j = i-1 ; j >= 0 ; --j){
if( arrayToSort[j+1] < arrayToSort[j]){
swap(arrayToSort, j+1,j);
}
}
}
}

//选择排序
public static  void selectSort(int[] arrayToSort){

//每次选择arrayToSort[i] 后面最小的元素来进行交换
for( int i = 0 ; i < arrayToSort.length ; ++i){

int min = i;
for( int j = i+1; j < arrayToSort.length ; ++j){
if( arrayToSort[j] < arrayToSort[min]){
min = j;
}
}
swap(arrayToSort,min,i);
}
}

//归并排序 时间复杂度O(nlogn) 空间复杂度 O(n)+O(logn)
//可以将数组分成二组。依次类推，当分出来的小组只有一个数据时，可以认为这个小组组内已经达到了有序，
// 然后再合并相邻的二个小组就可以了。这样通过先递归的分解数列，再合并数列就完成了归并排序

public static void mergerSort(int[] arrayToSort){
sort(arrayToSort,0,arrayToSort.length-1);
}

private  static void sort(int[] array ,int left,int  right) {

if (left < right) {
int center = (left + right) / 2;
//对左边递归
sort(array, left, center);

//对右边递归
sort(array, center + 1, right);

//mergerArray
mergerArray(array, left, center, right);

}
}

private static void mergerArray(int array[],int left,int mid,int right){

int[] tmp = new int[array.length];
int r1 = mid + 1;
int tIndex = left;       //tmp 数组索引
int sIndex = left;       //swap 时的索引
while (left <= mid && r1 <= right){
if(array[left] <= array[r1]){
tmp[tIndex++] = array[left++];
}else {
tmp[tIndex++] = array[r1++];
}
}
while (left <= mid){
tmp[tIndex++] = array[left++];
}

while (r1 <= right){
tmp[tIndex++] = array[r1++];
}
while (sIndex <= right){
array[sIndex] = tmp[sIndex++];
}
}
//快速排序的每一轮就是将这一轮的基准数归位，直到所有的数都归为为止，排序结束。（类似冒泡）. partition是返回一个基准值的index, index 左边都小于该index的数，右边都大于该index的数。

public static void quickSort(int[] arrayToSort,int left ,int right){

int p ;
if( left < right){
p = parition(arrayToSort,left,right);
quickSort(arrayToSort,left,p-1); // 从[left,p-1]
quickSort(arrayToSort, p + 1,r
bbd8
ight);//从[p+1,right]
}

}

//三个指针 一个 是 i  从left开始 j 是从right开始 还有个基准变量
private static int parition(int[] array,int left,int right){

int povit = left;
int j = right;
int i = left;
int povitNum = array[povit];
while (i != j){
while (array[j] >= povitNum && i != j){
j--;
}
while ( array[i] <= povitNum && i != j){
i++;
}
if(i == j){
swap(array,povit,i);
}
swap(array,i,j);
}

return i;
}

public static int[] getMinKNumsByHeap(int[] arr,int k){

if(arr == null || k <= 0){
return null;
}
/*int[] heap = new int[k];
for(int i = 0  ; i < k; i++){
heapInsert(heap,arr[i],i);
}

for(int i = k ; i < arr.length;i++){
if(arr[i] < heap[0]){
heap[0] = arr[i];
heapify(heap,0,k);
}
}
return heap;
*/
int[] heap = creatHeap(arr,k);
for(int i = k ; i < arr.length ; ++i){
if(arr[i] > heap[0]){
insert(heap,arr[i]);
}
}
return  heap;
}

private static void heapInsert(int[] arr, int value, int index) {
arr[index] = value;
while (index != 0){
int parent = (index-1)/2;
if(arr[parent] <arr[index]){
swap(arr,index,parent);
index = parent;
}else {
break;
}
}
}

public static void heapify(int[] arr,int index,int heapsize){

int left = index * 2 + 1;
int right = index * 2 +2 ;
int largest = index;
while (left < heapsize){
if(arr[left] > arr[index]){
largest = left;
}
if(right < heapsize && arr[right] > arr[largest]){
largest = right;
}
if(largest != index){
swap(arr,largest,index);
}else {
break;
}
index = largest;
left = index * 2 + 1;
right = index * 2 + 2;
}
}

public static int[] creatHeap(int[] a,int k){
int[] result = new int[k];
for(int i = 0 ;i < k; ++i){
result[i] = a[i];
}

for(int i = 0 ; i < k; ++i){
int child = i;
int parent = (i -1)/2;
int temp = a[i];
while(parent >= 0 && child != 0 && result[parent] > temp){
result[child] = result[parent];
child = parent;
parent = (parent -1)/2;
}
result[child] = temp;
}
return result;
}

public static void insert(int[] a,int value){
a[0] = value;
int parent = 0;
while (parent < a.length){
int lchild = parent*2 + 1;
int rchild = parent*2 + 2;
int minIndex = parent;
if(lchild < a.length && a[parent] > a[lchild]){
minIndex = lchild;
}
if(rchild < a.length && a[minIndex] > a[rchild]){
minIndex = rchild;
}
if(minIndex == parent){
return ;
}else {
swap(a,parent,minIndex);
parent = minIndex;
}
}
}

public static void main(String[] args) {
//        int[] array = {2,1,49,30,32,-1,20,50,49};

int[] array = {26,5,98,108,28,99,100};
/*
Scanner in = new Scanner(System.in);
int m = in.nextInt();
array = new int[m];
for(int i = 0 ; i < m;i++){
array[i] = in.nextInt();
}
*/
System.out.println("before sort:" + Arrays.toString(array));
long start = System.nanoTime();
//        insertSort(array);
//      selectSort(array);
//        mergerSort(array);
//        quickSort(array,0,array.length - 1);
int[] heap = getMinKNumsByHeap(array,3);
System.out.println(System.nanoTime() - start);
System.out.println("After sort:"+Arrays.toString(heap));
}
}