排序算法

package sort.heapsort;
/**
 * 
 * 堆排序：
 * 实现思想：1.初始化操作：将R[1..n]构造为初始堆
 * 2每一趟排序的基本操作：将当前的无序区的堆顶记录R[1]和该区的最后一个记录交换
 * 然后将新的无序区调整为新的堆（重建堆）  大根堆
 */
public class HeapSort{
private int[] buildMaxHeap(int[] array){
//最后的一个节点array.length-1的父节点(array.length-1-1)/2开始，知道根节点为0，反复调整堆
for(int i=(array.length-2)/2;i>=0;i--){
adjustDownToUp(array,i,array.length);
}
return array;
}


private void adjustDownToUp(int[] array, int k, int length) {
int temp = array[k];
//i为初始化的节点k的左孩子，沿节点较大的子节点向下调整
for(int i=2*k+1;i<length-1;i=2*i+1){
//取出节点较大的下标
if(i<length&&array[i]<array[i+1]){//如果右节点较大
i++;
}
if(temp>=array[i]){
break;
}else{
array[k] = array[i];
k = i;//修改k值，调整继续进行
}
}
array[k] = temp;//被调整的节点的值放入最终的位置
}
//堆排序
public int[] heapSort(int[] array){
array = buildMaxHeap(array);
//只需要交换n-1次
for(int i=array.length-1;i>1;i--){
int temp = array[0];
array[0] = array[i];
array[i] = temp;
adjustDownToUp(array,0,i);
}
return array;
}
//删除堆顶的元素
public int[] deleteMax(int[] array){
array[0] = array[array.length-1];
array[array.length-1] = -9999;
//对此时的根节点进行向下调整
adjustDownToUp(array,0,array.length);
return array;
}
//插如数据，向大根堆中插入数据data,前提是最后一个元素为空
public int[] insertData(int[] array,int data){
array[array.length-1] = data;//新插入的数据放到最后
int k = array.length-1;
int parent = (k-1)/2;//双亲节点
while(parent>=0&&data>array[parent]){
array[k] = array[parent];//双亲节点的值小就向下调
k = parent;
if(parent !=0){
parent = (parent-1)/2;//双亲节点的父节点
}else{
break;
}
}
array[k] = data;
return array;
}
public void toString(int[] array){
for(int i:array){
System.out.print(i+" ");
}
}
//测试
public static void main(String[] args) {
HeapSort hs = new HeapSort();
int[] array = {87,4,5,55,6,65,57,7};
System.out.println("构建大根堆");
hs.toString(hs.buildMaxHeap(array));
System.out.println("删除堆顶元素");
hs.toString(hs.deleteMax(array));
}

}

下面一种快速排序：效率和性能都比较好

package sort.quick;
/*
 * 快速排序，基本思路，找准第一个基准的数，（基本上是数列的第一个数，）通过两个扫描的线，
 * i 从左到右扫描，j从右到左扫描,在数组中arr[i] >arr[j]就交换他们的位置，保证基准左边的都小于基准
 * 右边的，直到i=j基本上就是找到基准的位置，递归求出的余下数基准的位置，找完排序完成！
 * 
 */
public class QuickSort {
public static void sort(int arr[],int low,int hight){
int i, j,index;
if(low > hight){
return;
}
i = low;
j = hight;
index = arr[low];//选第一个作为基准
while(i!=j){
while(i<j&&arr[j]>=index)//说明右边大于基准数，继续右移
j--;
while(i<j&&arr[i]<=index)//说明左边大于基准数，继续左移
i++;
if(i<j){
//用比基准大的记录替换高位记录
int temp = arr[j];
arr[j] = arr[i];
arr[i] = temp;
}
}
arr[low] = arr[i];
arr[i] = index;//将基准归位
sort(arr,low,i-1);//递归求出其他的基准位
sort(arr,i+1,hight);
}
public static void main(String[] args) {
int arr[] = {5,6,7,3,2,9,4,1}; 
sort(arr,0,arr.length-1);
System.out.println(arr);
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}
}

}

package select.sort;
/*选择排序：时间复杂度（n-1)(n-i)  所以时间复杂度为O(n^2)
空间复杂度：O(1)
*/
public class SelectSort {
public static void main(String[] args) {
int[] arr = {1,24,5,6,7,3};
for(int i=0;i<arr.length-1;i++){//控制轮数
for(int j=i;j<arr.length-1;j++){//控制要比较的次数
if(arr[i]>arr[j+1]){//每次选择第一个元素与后面的元素依次比较
int temp =arr[i];
arr[i] = arr[j+1];
arr[j+1] = temp;
}
}
}
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);

}

}

package bubble.sort;
/*选择排序：时间复杂度（n-1)(n-i)  所以时间复杂度为O(n^2)
空间复杂度：O(1)
*/
public class BubbleSort {
public static void main(String[] args) {
int[] arr = {1,24,5,6,7,3};
for(int i=0;i<arr.length-1;i++){//控制轮数
for(int j=0;j<arr.length-1-i;j++){//控制要比较的次数
if(arr[i]>arr[i+1]){//每次选择第一个元素与后面的元素依次比较
int temp =arr[i];
arr[i] = arr[i+1];
arr[i+1] = temp;
}
}
}
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);

}

}

希尔排序：先确定一个分量，在从每一组中进行选择排序；

public class ShellSort{
public static void main(String[] args){
int[] arr ={1,6,3,4,9,7,8,11,45};
shellsor(arr);
for(int a:arr){
System.out.print(a+" ");
}
}
public static void shellsor(int[] data){
int j,temp;
for(int d=data.length/2;d>0;d/=2){//确定分量d
for(int i=d;i<data.length;i+=d){//进行选择排序
temp = data[i];
for(j=i-d;j>=0;j-=d){
if(temp<data[j]){
data[j+d] = data[j];
}else{
break;
}
}
data[j+d] = temp;
}

}
}
}