典型的排序算法有:
基础版:冒泡排序,简单选择排序,插入排序,归并排序
升级版:堆排序,希尔排序,快排,归并排序,
还有一些桶排序,计数排序等,这里没有实现
java代码实现如下:
package org.cn.sort;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class AllSortMethodDemo {
public static void main(String[] args){
AllSortMethodDemo demo=new AllSortMethodDemo();
demo.test();
}
public void test(){
AllSortMethodDemo demo=new AllSortMethodDemo();
int[] data={2,4,3,1,10,8,9,7,0,5,6,3};
//MaoPao3(data);
//selectSort(data);
//insertSort2(data);
//shellSort(data);
//headSort(data);
//mergeSort(data,0,data.length-1);
quickSort(data, 0, data.length-1);
printData(data);
//System.out.println("\n"+Arrays.toString(data));
}
public void printData(int[] data){
for(int i=0;i<data.length;i++){
System.out.print(data[i]+" ");
}
}
public void swap(int[] arr,int i,int j){
if(i<0 || i>=arr.length || j<0 || j>=arr.length){
return ;
}
int temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
/**
* 冒泡排序基础版
* @param arr
*/
public void maoPao1(int[] arr){
if(arr==null || arr.length==0){
return ;
}
for(int i=0;i<arr.length;i++){
for(int j=i+1;j<arr.length;j++){
if(arr[i]>arr[j]){
swap(arr, i, j);
}
}
}
}
/**
* 冒泡排序升级版
* @param arr
*/
public void maoPao2(int[] arr){
if(arr==null || arr.length==0){
return;
}
for(int i=0;i<arr.length;i++){
for(int j=arr.length-1;j>i;j--){
if(arr[j]<arr[j-1]){
swap(arr, j, j-1);
}
}
}
}
/**
* 冒泡排序优化版
* 增加了flag标志判断,减少了不必要的比较次数
* @param arr
*/
public void maoPao3(int[] arr){
if(arr==null || arr.length==0){
return;
}
boolean flag=true;
for(int i=0;i<arr.length && flag;i++){
flag=false;
for(int j=arr.length-1;j>i;j--){
if(arr[j]<arr[j-1]){
swap(arr, j, j-1);
flag=true;
}
}
}
}
/**
* 简单选择排序
* @param arr
*/
public void selectSort(int[] arr){
if(arr==null || arr.length==0){
return;
}
int min;
for(int i=0;i<arr.length;i++){
min=i;
for(int j=i+1;j<arr.length;j++){
if(arr[min]>arr[j]){
min=j;
}
}
if(min!=i){
swap(arr, min, i);
}
}
}
/**
* 直接插入排序
* @param arr
*/
public void insertSort(int[] arr){
if(arr.length==0 ||arr==null){
return;
}
for(int i=1;i<arr.length;i++){
if(arr[i]<arr[i-1]){
int temp=arr[i];
int j;
for(j=i-1;j>=0 && arr[j]>temp;j--){
arr[j+1]=arr[j];
}
arr[j+1]=temp;
}
}
}
/**
* 直接插入排序2
* @param arr
*/
public void insertSort2(int[] arr){
if(arr.length==0 ||arr==null){
return;
}
for(int i=1;i<arr.length;i++){
if(arr[i]<arr[i-1]){
int temp=arr[i];
int j;
for(j=i-1;j>=0;j--){
if(arr[j]>temp){
arr[j+1]=arr[j];
}else{
break;
}
}
arr[j+1]=temp;
}
}
}
/**
*希尔排序,实际为直接插入排序的升级版,优化版
*直接插入排序的升级版
* @param arr
*/
public void shellSort(int[] arr){
if(arr.length==0 || arr==null){
return;
}
int temp=0;
int j=0;
for(int increment=arr.length/2;increment>0;increment/=2){
System.out.println("increment:"+increment);
for(int i=increment;i<arr.length;i++){
temp=arr[i];
int count=0;
for(j=i-increment;j>=0;j-=increment){
if(arr[j]>temp){
arr[j+increment]=arr[j];
count++;
}else{
break;
}
}
arr[j+increment]=temp;
System.out.print("比较了:"+count+"次,第"+(i-increment)+"次排序之后,数组为:");
printData(arr);
System.out.println();
}
}
}
/*
*
* 堆排序
*/
public void headSort(int[] array){
if(array.length==0 || array==null){
return;
}
for(int i=array.length/2-1;i>=0;i--){
headAjust(array, i, array.length-1);
}
for(int i=array.length-1;i>=0;i--){
int temp=array[i];
array[i]=array[0];
array[0]=temp;
headAjust(array, 0, i-1);
}
}
/**
* 构造最大堆
* @param array
* @param i
* @param len
*/
public void headAjust(int[] array,int i,int len){
if(array==null ||array.length==0){
return;
}
int temp=array[i];
for(int j=2*i+1;j<=len;j*=2){
if(j+1<=len && array[j]<array[j+1]){
j++;
}
if(temp>array[j]){
break;
}
array[i]=array[j];
i=j;
}
array[i]=temp;
}
/*
*
* 归并排序中的合并操作
*/
public void merge(int[] array,int low,int mid,int hight){
int[] temp=new int[hight-low+1];
int k=0;
int left=low;
int right=mid+1;
while(left<=mid && right<=hight){
if(array[left]>array[right]){
temp[k++]=array[right++];
}else{
temp[k++]=array[left++];
}
}
//如果两边的长度不一样,可能左边还有剩余,也可能是右边还有剩余
while(left<=mid){
temp[k++]=array[left++];
}
while(right<=hight){
temp[k++]=array[right++];
}
//将临时数组中的值复制到原来的数组之中
for(int i=0;i<temp.length;i++){
array[low+i]=temp[i];
}
}
/**
* 归并排序
* @param array
* @param low
* @param hight
*/
public void mergeSort(int[] array,int low ,int hight){
if(low>=hight){
return;
}
int mid=low+(hight-low)/2;
mergeSort(array, low, mid);
mergeSort(array,mid+1, hight);
merge(array, low, mid, hight);
System.out.println(Arrays.toString(array));
}
/**
* 快排
* @param array
* @param low
* @param high
*/
public void quickSort(int[] array,int low,int high){
int position;
if(low<high){
position=partition(array, low, high);
quickSort(array, low, position-1);
quickSort(array, position+1, high);
}
}
/*
* 快排辅助方法
*/
public int partition(int[] array,int low ,int high){
int pointKey=array[low];
while(low<high){
while(low<high && array[high]>=pointKey){
high--;
}
swap(array, low, high);
while(low<high && array[low]<=pointKey){
low++;
}
swap(array, low, high);
}
return low;
}
/**
* 快排辅助方法2
* 优化方法,减少不必要的交换
* @param array
* @param low
* @param high
* @return
*/
public int partition2(int[] array,int low ,int high){
int pointKey=array[low];
while(low<high){
while(low<high && array[high]>=pointKey){
high--;
}
array[low]=array[high];
while(low<high && array[low]<=pointKey){
low++;
}
array[high]=array[low];
}
array[low]=pointKey;
return low;
}
}