JAVA实现的常用排序算法及对比

转载 2007年10月11日 14:37:00
package Sort;

class Data {

 Comparable key;

 Object value;

 public Data() {

 }

 

 public Data(Data data){

    this.key=data.key;

    this.value=data.value;

 }

 

 public Data(Comparable key,Object value){

    this.key=key;

    this.value=value;

 }

 public String toString(){

    return "key="+key+";"+"value="+value+";"+"/n";

 }

}

 

Insertion.java

package Sort;

public class InsertionSort {

 public InsertionSort() {

 }

 //直接插入排序,从下标1开始

 public static void straightInsertionSort(Data[] data) {

    int i, j;

    for (i = 2; i <data.length; i++) {

      if (data[i].key.compareTo(data[i - 1].key) < 0) {

        data[0] = data[i];//复制为监视哨

        for (j = i - 1; data[0].key.compareTo(data[j].key) < 0; --j) {

          data[j + 1] = data[j];//记录右移

        }

        data[j + 1] = data[0];//插入

      }

    }

 }

 

 //折半插入排序,从下标1开始

 public static void BinaryInsertionSort(Data[] data){

    int i,j,low,high,mid;

    for(i=2;i<data.length;i++){

      if (data[i].key.compareTo(data[i - 1].key) < 0) {

        data[0]=data[i];

        //找插入位置

        low=1;high=i-1;

        while(low<=high){

          mid =(low+high)/2;

          if(data[0].key.compareTo(data[mid].key)<0) high=mid-1;

          else low=mid+1;

        }

        //移动插入位置以后的元素

        for(j=i-1;j>=high+1;j--){

          data[j+1]=data[j];

        }

        data[high+1]=data[0];//插入

      }

    }

 }

 

 //表插入排序

 public static void ListInsertionSort(Data[] data){

 int i,j,k;

 //inner class:Table

    class Table{

      Comparable key;

      int next;

    }

    Table[] table=new Table[data.length];

    for(i=1;i<data.length;i++){

      table[i]=new Table();

      table[i].key=data[i].key;

    }

    table[0]=new Table();

    table[0].key=new Integer(Integer.MAX_VALUE);

    table[0].next=1;

    table[1].next=0;

    for(i=2;i<data.length;i++){

      for(j=0,k=table[0].next;table[k].key.compareTo(table[i].key)<=0;j=k,k=table[k].next);

      table[j].next=i;

      table[i].next=k;

    }

    Data[] newData=new Data[data.length];

    int position=table[0].next;

    for(i=1;i<data.length;i++){

      newData[i]=data[position];

      position=table[position].next;

    }

    //data=newData;//不知为什么不能把newData赋给data,而必须用下面的

    for(i=1;i<data.length;i++){

      data[i]=newData[i];

    }

 }

}

 

QuickSort.java

package Sort;

import Queue.*;

 

public class QuickSort {

 public QuickSort() {

 }

 

 //起泡排序

 public static void BubbleSort(Data[] data) {

    int i, j, lastChangeIndex;

    Data temp;

    i = data.length - 1;

    while (i > 1) {

      lastChangeIndex = 1;

      for (j = 1; j < i; j++) {

        if (data[j + 1].key.compareTo(data[j].key) < 0) {

          temp = data[j + 1];

          data[j + 1] = data[j];

          data[j] = temp;

          lastChangeIndex = j;

        }

      }

      i = lastChangeIndex;

    }

 }

 

 //快速排序

 public static void QuickSort(Data[] data) {

    QSort(data, 1, data.length - 1);

 }

 

 public static void OptimizeQuickSort(Data[] data){

    OQSort(data,1,data.length-1);

 }

 

 private static void QSort(Data[] data, int s, int t) {

    int pivotLoc;

    if (s < t) {

      pivotLoc = Partition(data, s, t); //data[1...data.length-1]进行一次划分

      QSort(data, s, pivotLoc - 1); //对低子序列进行递归排序

      QSort(data, pivotLoc + 1, t); //对高子序列进行递归排序

    }

 }

 private static void OQSort(Data[] data,int s,int t){

    int pivotLoc;

    if(s<t){

      pivotLoc=RandomPartition(data,s,t);

      QSort(data, s, pivotLoc - 1); //对低子序列进行递归排序

      QSort(data, pivotLoc + 1, t); //对高子序列进行递归排序

    }

 }

 

 private static int RandomPartition(Data[] data,int low,int high){

    //ilow

    int i=(int)Math.random()*(high-low)+low;

    Data temp=data[low];

    data[low]=data[i];

    data[i]=temp;

    return Partition(data,low,high);

 }

 

 private static int Partition(Data[] data, int low, int high) {

    Comparable pivotKey;

    data[0] = data[low];

    pivotKey = data[low].key; //枢轴

    while (low < high) {

      while (low < high && data[high].key.compareTo(pivotKey) >= 0) {

        high--;

      }

      data[low] = data[high];

      while (low < high && data[low].key.compareTo(pivotKey) <= 0) {

        low++;

      }

      data[high] = data[low];

    }

    data[low] = data[0];

    return low;

 }

 

 //堆排序

 public static void HeapSort(Data[] data) {

    //先对顺序表进行堆排序,建立大顶堆

    int i;

    Data temp;

    for (i = (data.length-1)/2; i > 0; i--) {

      HeapAdjust(data, i, data.length-1);

    } //建立大顶堆

 

    for (i = (data.length - 1); i >1; i--) {

      temp = data[1];

      data[1] = data[i];

      data[i] = temp;

      HeapAdjust(data, 1, i - 1);

    }

 }

 

 private static void HeapAdjust(Data[] data, int start, int end) {

    int j;

    Data temp;

    temp = data[start];

    for (j = 2 * start; j <=end; j *=2) {

      if (j < end && data[j].key.compareTo(data[j+1].key) < 0) {

        j++;

      }

      if (temp.key.compareTo(data[j].key) >= 0) {

        break;

      }

      data[start] = data[j];

      start = j;

    }

    data[start] = temp;

 }

 

 //简单选择排序

 public static void SimpleSelectSort(Data[] data) {

    int i, j;

    Data temp;

    for (i = 1; i < data.length; i++) {

      j = MinKey(data, i);

      if (j != i) {

        temp = data[i];

        data[i] = data[j];

        data[j] = temp;

      }

    }

 }

 

 private static int MinKey(Data[] data, int start) {

    int i, j = start;

    Comparable temp;

    temp = data[start].key;

    if (data.length - start == 0) {

      return start;

    }

    for (i = start + 1; i < data.length; i++) {

      if (temp.compareTo(data[i].key) > 0) {

        temp = data[i].key;

        j = i;

      }

    }

    return j;

 }

 

 //归并排序

 private static Data[] originalnewData2;

 private static Data[] newData2;

 public static void MergingSort(Data[] data) {

    originalnewData2 = new Data[data.length];

    newData2 = new Data[data.length];

    for (int i = 1; i < data.length; i++) {

      originalnewData2[i]=new Data();

      newData2[i] = new Data();

    }

    MSort(data, data, 1, data.length - 1);

 }

 

 private static void MSort(Data[] originalData,Data[] data, int start,

                            int end) {

    if (start == end) {

      data[start] = originalData[start];

    }

    else {

      int mid = (start + end) / 2;

      MSort(originalData, newData2, start, mid);

      MSort(originalData, newData2, mid + 1, end);

      //怎样才能像值传递一样使用引用传递,即不改变它的值

      for(int k=start;k<=end;k++) originalnewData2[k]=new Data(newData2[k]);

      merge(originalnewData2, data, start, mid, end);//这里的data好像不再是一开始传入的data,而是递归时的newData2

    }

 }

 

 private static void merge(Data[] newData, Data[] data, int start, int mid,

                            int end) {

    int i, j;

    int k=start;

    for (i = start, j = mid + 1; start <= mid && j <= end; i++) {

      if (newData[start].key.compareTo(newData[j].key) <= 0) {

        data[i] = newData[start++];

      }

      else {

        data[i] = newData[j++];

      }

    }

    if (start <= mid) {

      for (int tempI = start; tempI <= mid; tempI++) {

        data[i++] = newData[tempI];

      }

    }

    if (j <= end) {

      for (int tempJ = j; tempJ <= end; tempJ++) {

        data[i++] = newData[tempJ];

      }

    }

 }

 

 //基数排序

 public static void RadixSort(Data[] data,int digits){

    int d,j,k,factor=1;

    QueueInterface[] queues=new LinkQueue[10];

    for(int i=0;i<10;i++){

      queues[i]=new LinkQueue();

    }

    for(d=1;d<=digits;factor*=10,d++){

      //distribution

      for(j=1;j<data.length;j++){

        queues[(((Integer)data[j].key).intValue()/factor)%10].put(new Data(data[j]));

      }

      //collection

      for(j=0,k=1;j<10;j++){

 

        while(!queues[j].isEmpty()){

          data[k++]=(Data)queues[j].removeHead();

        }

      }

    }

 }

}

测试类:

package Sort;

 

public class Test {

 public Test() {

 }

 //产生测试数据

 public static Data[] getData(int size){

    Data[] data=new Data[size+1];

    int number;

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

      number=(int) (Math.random() * size*10);

      data[i] = new Data(new Integer(number),new Integer(number));

    }

    return data;

 }

 

 //复制测试数据

 public static Data[] duplicationData(Data[] data){

    Data[] duplication=new Data[data.length];

    for(int i=1;i<data.length;i++){

      duplication[i]=new Data(data[i]);

    }

    return duplication;

 }

 

 public static void printData(Data[] data){

    for(int i=1;i<data.length;i++)

      System.out.print(data[i].toString());

 }

 

 public static void main(String[] args) {

    long startTime,stopTime,sortingTime;

    Data[] data=getData(6000);

    Data[] data1,data2,data3,data4,data5,data6,data7,data8,data9,data10;

    data1=duplicationData(data);

    data2=duplicationData(data);

    data3=duplicationData(data);

    data4=duplicationData(data);

    data5=duplicationData(data);

    data6=duplicationData(data);

    data7=duplicationData(data);

    data8=duplicationData(data);

    data9=duplicationData(data);

    data10=duplicationData(data);

 

 

    startTime= System.currentTimeMillis();

    Sort.InsertionSort.straightInsertionSort(data1);

    stopTime= System.currentTimeMillis();

    sortingTime=stopTime-startTime;

    System.out.println("Straight Insertion Sort time is "+ sortingTime);

    //System.out.println("Straight Insertion Sort Answer");

    //printData(data1);

 

 

    startTime= System.currentTimeMillis();

    Sort.InsertionSort.BinaryInsertionSort(data2);

    stopTime= System.currentTimeMillis();

    sortingTime=stopTime-startTime;

    System.out.println("Binary Insertion Sort time is "+ sortingTime);

    //System.out.println("Binary Insertion Sort Answer");

    //printData(data2);

 

    startTime= System.currentTimeMillis();

    Sort.InsertionSort.ListInsertionSort(data3);

    stopTime= System.currentTimeMillis();

    sortingTime=stopTime-startTime;

    System.out.println("List Insertion Sort time is "+ sortingTime);

    //System.out.println("List Insertion Sort Answer");

    //printData(data3);

 

    startTime= System.currentTimeMillis();

    Sort.QuickSort.BubbleSort(data4);

    stopTime= System.currentTimeMillis();

    sortingTime=stopTime-startTime;

    System.out.println("Bubble Sort time is "+ sortingTime);

    //System.out.println("Bubble Sort Answer");

    //printData(data4);

 

    startTime= System.currentTimeMillis();

    Sort.QuickSort.QuickSort(data5);

    stopTime= System.currentTimeMillis();

    sortingTime=stopTime-startTime;

    System.out.println("Quick Sort time is "+ sortingTime);

    //System.out.println("Quick Sort Answer");

    //printData(data5);

 

    startTime= System.currentTimeMillis();

    Sort.QuickSort.SimpleSelectSort(data6);

    stopTime= System.currentTimeMillis();

    sortingTime=stopTime-startTime;

    System.out.println("Select Sort time is "+ sortingTime);

    //System.out.println("Select Sort Answer");

    //printData(data6);

 

    startTime= System.currentTimeMillis();

    Sort.QuickSort.MergingSort(data7);

    stopTime= System.currentTimeMillis();

    sortingTime=stopTime-startTime;

    System.out.println("Merging Sort time is "+ sortingTime);

    //System.out.println("Merging Sort Answer");

    //printData(data7);

 

    startTime= System.currentTimeMillis();

    Sort.QuickSort.RadixSort(data8,5);

    stopTime= System.currentTimeMillis();

    sortingTime=stopTime-startTime;

    System.out.println("Radix Sort time is "+ sortingTime);

    //System.out.println("Radix Sort Answer");

    //printData(data8);

 

    startTime= System.currentTimeMillis();

    Sort.QuickSort.HeapSort(data);

    stopTime= System.currentTimeMillis();

    sortingTime=stopTime-startTime;

    //System.out.println("Heap Sort time is "+ sortingTime);

    //System.out.println("Radix Sort Answer");

    //printData(data9);

   

    startTime= System.currentTimeMillis();

    Sort.QuickSort.OptimizeQuickSort(data10);

    stopTime= System.currentTimeMillis();

    sortingTime=stopTime-startTime;

    System.out.println("Optimize Quick Sort time is "+ sortingTime);

    //System.out.println("Optimize Quick Sort Answer");

    //printData(data10);

 }

}

测试结果:

各种排序的测试数据表:

100

500

1000

10000

直接插入排序

0

10

20

1752

二分插入排序

0

10

10

551

表插入排序

10

10

30

2153

起泡排序

10

30

50

5068

快排

0

0

10

20

简单选择排序

30

20

20

3535

归并排序

0

0

60

190

基数排序

20

20

110

140

堆排序

0

0

0

10

  

关于快排:

快速排序的运行时间与划分是否对称有关,最糟的情况是每次划分时一边是一个元素,一边是n-1个,这种情况的时间复杂度是

在最好的情况是,每次划分的枢轴都是中值,此时的时间复杂度是 ,在一些书上提到快速排序在平均情况下的复杂度也是 ,所以可以提出一个处理恶化的方法,在排序算法的每一步,可以随机选取一个元素关键字作为枢轴,这样总体来说平均划分是对称的。

可以把取枢轴的算法改一下:

int RandomizedPartition(DataType[] a , int p , int r){

       int i= Random(p , r);

       Swap(a[i] ,a[p]);

       return Partition(a,p,r);

}

 

500

1000

10000

100000

200000

普通快排

10

10

40

501

1181

优化快排

0

0

10

430

1142

 可以看出,优化后的快排明显的提高了排序的速度,但是同时也可以看出,当元素很多时,交换的次数也增多了,使得优化后的排序的优势不很明显了,这是因为被排的数据是随机的。

下面显示的是这两种快排对有序的处理时间(数据>7000,内存溢出)

 

100

500

1000

3000

6000

普通快排

10

10

80

250

991

优化快排

0

40

20

160

731

 由此可知,优化快排能缓解恶化。

java实现各种排序算法及比较

常见排序算法包括以下七种:选择排序、冒泡排序、插入排序、快速排序、希尔排序、堆排序、归并排序。 在学习具体算法实现并进行比较前,先来学习算法比较的几个维度。 一是稳定性 所谓稳定性,是指值相等的...
  • tang9140
  • tang9140
  • 2015-06-08 11:01:45
  • 5444

常见排序算法时间对比

  • Walker19900515
  • Walker19900515
  • 2015-06-16 10:26:18
  • 616

几种常见排序算法java实现

public class sort { public static void main(String[] args) { int[] a= {10,1,35,14,9,12,11}; int...
  • qq_34309305
  • qq_34309305
  • 2018-01-25 16:55:55
  • 155

常见排序算法的时间复杂度和空间复杂度对比表

在网上看到一个常用排序算法的时间复杂度和空间复杂度表格,自己整理了一下,如下:...
  • u010853261
  • u010853261
  • 2017-02-05 22:56:24
  • 2301

java实现四种常用排序算法

四种常用排序算法冒泡排序特点:效率低,实现简单 思想(从小到大排):每一趟将待排序序列中最大元素移到最后,剩下的为新的待排序序列,重复上述步骤直到排完所有元素。这只是冒泡排序的一种,当然也可以从后往...
  • huosanghuakai1995
  • huosanghuakai1995
  • 2017-07-13 19:16:34
  • 14845

几种常见排序算法的Java实现及时间复杂度

常见的的几种排序方式的Java实现在我们的学习中,在很多的环境里,我们都要进行排序,这里来介绍几种常见的排序方式的Java实现 排序方法主要分为两种排序 - 稳定排序:基数排序、冒泡排序、直接插入...
  • dxhua1996
  • dxhua1996
  • 2017-09-12 13:37:39
  • 981

几种常见排序算法总结(java版)

代码如下: /*************几种常见的排序算法总结***************************/ package paixu; public class PaiXu {...
  • zgrjkflmkyc
  • zgrjkflmkyc
  • 2013-09-13 12:50:28
  • 13612

各类排序算法的对比及实现

(直接插入排序,希尔,选择排序,堆排序,冒泡排序,快排,归并)各类排序的算法比较及实现...
  • wangiijing
  • wangiijing
  • 2016-05-23 23:29:09
  • 3759

java 常用排序算法

  • 2009年04月17日 09:44
  • 52KB
  • 下载

常用排序算法性能比较总结

1 概述 本文对比较常用且比较高效的排序算法进行了总结和解析,并贴出了比较精简的实现代码,包括选择排序、插入排序、归并排序、希尔排序、快速排序等。算法性能比较如下图所示: 2 选择...
  • pangqiandou
  • pangqiandou
  • 2016-12-03 23:20:04
  • 532
收藏助手
不良信息举报
您举报文章:JAVA实现的常用排序算法及对比
举报原因:
原因补充:

(最多只允许输入30个字)