数据结构之排序算法整理（3）

选择排序

1.直接选择排序

package com.SelectSort;

import java.util.Arrays;

/**
* 选择排序中的直接选择排序
* 直接选择排序，对于n个元素，需要经过n-1此比较。
* 基本思想：
* 第1趟比较：程序将记录定位在第一个数据上，拿第一个数据依次和其后面的元素比较，如果第一个元素比后面的某个元素大(或者小)，交换两个位置上元素，依次类推。经过第一次比较，这组数据中最小的元素被选出，被排列在第一位；
* 第2趟比较：程序将记录定位在第二个数据上，拿第二个数据依次和其后面的元素比较，如果第一个元素比后面的某个元素大(或者小)，交换两个位置上元素，依次类推。经过第一次比较，这组数据中最小的元素被选出，被排列在第二位；
* ……
* 第n-1趟比较：……
* 按照这个规则一共进行n-1次比较。
* 优点：实现简单；缺点：每次只能确定一个元素
* 补充：1.运行时间和输入无关；（一组随机数和排序好的数运行时间是一样的）；2.数据移动是最少的。
* 其复杂度是O(n*n)，稳定性：不稳定；空间消：O(1)。
* @author lenovo
*
*/
public class SelectSort {
public static void selectSort(int[] datas){
for(int i = 0;i < datas.length - 1;i++){
for(int j = i+1;j < datas.length;j++){
//可以实现Comparable接口来实现对象的比较
if(datas[i] > datas[j]){
int temp = datas[i];
datas[i] = datas[j];
datas[j] = temp;
}
}
System.out.println(Arrays.toString(datas));
}
}

public static void main(String[] args){
int[] array = {22,30,49,30,16,9};
SelectSort.selectSort(array);
System.out.println(Arrays.toString(array));

}
}


直接选择排序的性能上还是要略优于冒泡排序。

2.堆排序

package com.HeapSort;

public class Heap {
private int[] heap;
private int heapsize;
public Heap(int[] array){
this.heap = array;
this.heapsize = heap.length;
}
public void BuildMaxHeap(){
for(int i = heapsize/2 - 1;i >= 0;i--){
Maxify(i);//依次向上将当前子树最大堆化
}
}
public void HeapSort(){
for(int i = 0;i < heap.length;i++){
//执行n次，将每个当前最大的值放到堆末尾
int tmp = heap[0];
heap[0] = heap[heapsize - 1];
heap[heapsize - 1] = tmp;
heapsize--;
Maxify(0);
}
}

public void Maxify(int i){
int l = Left(i);
int r = Right(i);
int largest;
if(l < heapsize && heap[l] > heap[i]){
largest = l;
}else{
largest = i;
}
if(r < heapsize && heap[r] > heap[largest]){
largest = r;
}
//如果largest等于i说明i是最大元素 largest超出heap范围说明不存在
//比i节点大的子女
if(largest == i || largest >= heapsize){
return;
}
int tmp = heap[i];
heap[i] = heap[largest];
heap[largest] = tmp;
Maxify(largest);
}

public void IncreaseValue(int i,int val){
heap[i] = val;
if(i >= heapsize || i <= 0 || heap[i] >= val){
return;
}
int p = Parent(i);
if(heap[p] >= val)
return;
heap[i] = heap[p];
IncreaseValue(p,val);
}

private int Parent(int i){
return (i-1)/2;
}

private int Left(int i){
return 2*(i+1) - 1;
}

private int Right(int i){
return 2*(i+1);
}

//测试
public static void main(String[] args){
int[] array = new int[]{1,2,3,4,7,8,9,10,14,16};
Heap MaxHeap = new Heap(array);
System.out.println("执行最大堆化前堆的结构：");
printHeapTree(MaxHeap.heap);
MaxHeap.BuildMaxHeap();
System.out.println("执行最大堆化后堆的结构：");
printHeapTree(MaxHeap.heap);
MaxHeap.HeapSort();
System.out.println("执行堆排序后数组的内容：");
printHeap(MaxHeap.heap);
}

public static void printHeapTree(int[] array){
for(int i = 1;i<array.length;i=i*2){
for(int k = i - 1;k <2*(i) - 1 && k < array.length;k++){
System.out.print(array[k]+" ");
}
System.out.println();
}
}

public static void printHeap(int[] array){
for(int i = 0;i < array.length;i++){
System.out.print(array[i]+" ");
}
}
}