常见排序算法的对比:
排序算法 | 平均时间 | 最坏情况 | 辅助存储 |
简单排序 | O(n*n) | O(n*n) | O(1) |
希尔排序 | O(n*logn) | O(n^s) 1<s<2 | O(1) |
快速排序 | O(n*logn) | O(n*n) | O(1) |
归并排序 | O(n*logn) | O(n*logn) | O(n) |
堆排序 | O(n*logn) | O(n*logn) | O(1) |
源代码[Java]
/*
* $filename: SortAll.java,v $
* $Date: 2014-3-9 $
* Copyright (C) ZhengHaibo, Inc. All rights reserved.
* This software is Made by Zhenghaibo.
*/
package edu.njupt.zhb;
/*
*@author: ZhengHaibo
*web: http://blog.csdn.net/nuptboyzhb
*mail: zhb931706659@126.com
*2014-3-9 Nanjing,njupt,China
*/
public class SortAll {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int []a = {12,5,6,98,45,2};
//bubbleSort(a);
//selectSort(a);
//insertSort(a);
//int []steps = {5,3,1};
//shellSort(a,steps);
//quickSort(a,0,a.length-1);
int[] b = mergeSort(a);
for(int e:b){
System.out.println(e);
}
}
/**
* 冒泡排序 从小到大
* 时间复杂度 O(n*n)
* @param data
*/
public static void bubbleSort(int []data){
for(int i=0;i<data.length-1;i++){
for(int j=i+1;j<data.length;j++){//将当前元素i后面的元素,依次与i进行对比
if(data[j]<data[i]){
int temp = data[j];
data[j]=data[i];
data[i]=temp;
}
}
}
}
/**
* 简单选择排序 从小到大
* 时间复杂度 O(n*n) 与冒泡算法相比,减少了交换次数
* @param data
*/
public static void selectSort(int []data){
for(int i=0;i<data.length-1;i++){
int min = i;//初始化最小值
for(int j=i+1;j<data.length;j++){//从剩余的data.length-i-1中找到最小的值
if(data[j]<data[min]){
min = j;
}
}
if(min!=i){//不是初始值
int temp = data[min];
data[min]=data[i];
data[i]=temp;
}
}
}
/**
* 插入排序 从小到大
* 时间复杂度O(n*n)
* @param data
*/
public static void insertSort(int []data){
for(int i=1;i<data.length;i++){//可将data[0]自己看成有序的,然后逐步插入后面的数据
int value = data[i];//取出待插入的值
int j;
for(j=i-1;j>=0&&value<data[j];j--){//从当前已经排序好的0~i进行扫描(从后面扫描),寻找待插入的位置
data[j+1]=data[j];//从后面逐步移动
}
data[j+1]=value;//将待插入的值插入到j+1
}
}
/**
* 希尔排序 从小到大
* 插入排序的改进
* @param data
*/
public static void shellSort(int []data,int []delta){
for(int k=0;k<delta.length;k++){
shellInsert(data, 0, data.length, delta[k]);
}
}
/**
* 希尔插入
* @param data 待排序数组
* @param low 数组中的待排序区域
* @param high
* @param deltaK 步长
*/
public static void shellInsert(int []data,int low,int high,int deltaK){
for(int i=low+deltaK;i<high;i++){
int value = data[i];
int j;
for(j=i-deltaK;j>=low&&value<data[j];j=j-deltaK){
data[j+deltaK]=data[j];
}
data[j+deltaK] = value;
}
}
/**
* 快速排序
* 平均时间复杂度O(n*logn)
* @param data 待排序数组
* @param low 数组的待排序区域
* @param high
*/
public static void quickSort(int []data,int low,int high){
if(low<high){
int partIndex = partition(data,low,high);
quickSort(data, low, partIndex-1);
quickSort(data, partIndex+1, high);
}
}
/**
* 快速排序中 查找分割线枢纽part,使得右边的全部大于左边的
* @param data
* @param low
* @param high
* @return 返回枢纽的下标
*/
public static int partition(int []data,int low,int high){
int value = data[low];//将最左端的值设置为枢纽值
while(low<high){
while(low<high&&data[high]>=value){//从右边向左边扫描,查找第一个小于枢纽值的下标
high--;
}
data[low]=data[high];
while(low<high&&data[low]<=value){//从左边向右边扫描,查找第一个大于枢纽值的下标
low++;
}
data[high]=data[low];
}
data[low]=value;
return low;
}
/**
* 归并排序
* 1.用递归的方式将数组分割成单个数据(单个数据可认为自己有序)
* 2.逐步合并已经有序的2个数组
* 平均时间复杂度O(n*logn) 最坏O(nlogn)
* @param data 待排序的数组
* @return
*/
public static int[] mergeSort(int []data){
if(data.length<2){//递归:分割成了一个一个的数据
return data;
}
int middle = data.length/2;
int []leftData = new int [middle];
int []rightData = new int[data.length-middle];
System.arraycopy(data, 0, leftData, 0, middle);
System.arraycopy(data, middle, rightData, 0, rightData.length);
int []leftResult = mergeSort(leftData);
int []rightResult = mergeSort(rightData);
return merge(leftResult,rightResult);
}
/**
* 合并2个有序的数组
* @param leftResult 左边的有序数组
* @param rightResult 右边的有序数组
* @return
* result[i]=left (left<right)
* result[i]=right (left>=right)
*/
public static int [] merge(int []leftResult,int []rightResult){
int []result = new int[leftResult.length+rightResult.length];//合并数组存放位置
int leftIndex = 0;
int rightIndex = 0;
int resultIndex = 0;
while(leftIndex<leftResult.length&&rightIndex<rightResult.length){
if(leftResult[leftIndex]<rightResult[rightIndex]){
result[resultIndex++]=leftResult[leftIndex++];
}else {
result[resultIndex++]=rightResult[rightIndex++];
}
}
while(leftIndex<leftResult.length){
result[resultIndex++]=leftResult[leftIndex++];
}
while(rightIndex<rightResult.length){
result[resultIndex++]=rightResult[rightIndex++];
}
return result;
}
}
归并排序的另外两种写法:
public static int[] mergeSort(int []data,int low,int high){
if(low>=high){
int []temp={data[low]};
return temp;
}
int middle=(low+high)/2;
int []left=mergeSort(data, low, middle);
int []right=mergeSort(data, middle+1, high);
return merge(left,right);
}
private static int[] merge(int[] left, int[] right) {
// TODO Auto-generated method stub
int []result=new int[left.length+right.length];
int pa=0,pb=0,pc=0;
while(pa<left.length&&pb<right.length){
if(left[pa]<right[pb]){
result[pc++]=left[pa++];
}else {
result[pc++]=right[pb++];
}
}
while(pa<left.length){
result[pc++]=left[pa++];
}
while(pb<right.length){
result[pc++]=right[pb++];
}
return result;
}
写法二:
public static void mergeSort(int []data,int low,int high){
if(low<high){
int middle=(low+high)/2;
mergeSort(data, low, middle);
mergeSort(data, middle+1, high);
merge(data,low,middle,high);
}
}
/**
* 将data数组中的low~middle和middle+1~high
* 两段数据合并
* @param data 数据
* @param low 起始位置
* @param middle 第一段的结束位置
* @param high 第二段的结束位置
* @return
*/
private static void merge(int[] data,int low,int middle,int high) {
// TODO Auto-generated method stub
int [] result=new int[high-low+1];
int pa=low;
int pb=middle+1;
int pc=0;
while(pa<=middle&&pb<=high){
if(data[pa]<data[pb]){
result[pc++]=data[pa++];
}else {
result[pc++]=data[pb++];
}
}
while(pa<=middle){
result[pc++]=data[pa++];
}
while(pb<=high){
result[pc++]=data[pb++];
}
for(int i=0;i<result.length;i++){
data[low+i]=result[i];
}
}
理解了算法的核心思想后,想怎么写都很容易
快速排序的另一种实现,java版本,比较好理解:
public class QuickSort {
public static void main(String[] args) {
List<Integer> arr = new ArrayList<>();
for (int i = 0; i < 10; i++) {
int a = new Random().nextInt(100);
arr.add(a);
}
System.out.println("排序前:");
System.out.println(arr);
List<Integer> result = new QuickSort().quickSort(arr);
System.out.println("排序后:");
System.out.println(result);
}
public List<Integer> quickSort(List<Integer> arr) {
if (arr == null || arr.size() <= 1) {
return arr;
}
int p = arr.get(0);//取第一个作为基准值
List<Integer> less = new ArrayList<>();//保存小于基准值的数组
List<Integer> more = new ArrayList<>();//保存大于等于基准值的数据
for (int i = 1; i < arr.size(); i++) {
int item = arr.get(i);
if (item < p) {
less.add(item);
} else {
more.add(item);
}
}
//对左边的进行排序
List<Integer> left = quickSort(less);
//对右面的进行排序
List<Integer> right = quickSort(more);
//以left数组来保存结果,将基准值和右边的加入到数组中
left.add(p);
left.addAll(right);
return left;
}
}