4种常见的排序算法(Java版)

import java.util.Scanner;

public class Sort {
/**

* 作者：zpc 功能： 实现主流的排序算法,并进实际行性能比较。

* 1、冒泡排序（改进版）

* 2、简单选择排序

* 3、直接插入排序

* 4、快速排序

*/

public static void
main(String[] args) {

System.out.println("请输入测试的数据数量，建议5万--10万之间！");

Scanner sn = new
Scanner(System.in);

int num = sn.nextInt();

int[] dataArray
= new int[num];

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

int t = (int) (Math.random()
* 100000);// 产生范围在0--10000的随机数

dataArray[i] =
t;

}

Sort sort = new
Sort();

System.out.println("请选择排序算法："
+ "\n" + "1、冒泡排序（改进版）" + "\n"

+ "2、简单选择排序" +
"\n" + "3、直接插入排序" + "\n" + "4、快速排序");

// Calendar cal
= Calendar.getInstance();

int c = sn.nextInt();

switch (c) {

case 1:

long beginTime
= System.currentTimeMillis();

sort.bubbleSort(dataArray);

long endTime =
System.currentTimeMillis();

System.out.println(num
+ "个数据 " + " 冒泡排序消耗时间:"

+ (endTime - beginTime)
/ 1000 + "秒。");

break;

case 2:

long beginTime2
= System.currentTimeMillis();

sort.selectSort(dataArray);

long endTime2 =
System.currentTimeMillis();

System.out.println(num
+ "个数据 " + " 简单选择消耗时间:"

+ (endTime2 - beginTime2)
/ 1000 + "秒。");

break;

case 3:

long beginTime3
= System.currentTimeMillis();

sort.insertSort(dataArray);

long endTime3 =
System.currentTimeMillis();

System.out.println(num
+ "个数据 " + " 直接插入排序消耗时间:"

+ (endTime3 - beginTime3)
/ 1000 + "秒。");

break;

case 4:

long beginTime4
= System.currentTimeMillis();

sort.quickSort(0,
dataArray.length - 1, dataArray);

long endTime4 =
System.currentTimeMillis();

System.out.println(num
+ "个数据 " + " 快速排序消耗时间:"

+ (endTime4 - beginTime4)
/ 1000 + "秒。");

break;

}

// 打印数据比较较多时控制台不能完全看到效果！

// System.out.println("排完序的结果：");

// sort.printResult(dataArray);

}

//打印排序结果

public void printResult(int
dataArray[]) {

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

System.out.println("dataArray["
+ i + "] = " + dataArray[i]);

}

}

public void bubbleSort(int[]
array) {

// 冒泡排序，从小到大，总共比较n-1趟

for (int i = 0;
i < array.length - 1; i++) {

int flag = 0;//
改进的冒泡排序算法，设置标记，如果这一趟没有进行数据交换，则排序立即完毕

for (int j = array.length
- 1; j > i; j--) {

// 从后向前比较，小的数上浮

if (array[j] <
array[j - 1]) {

int temp = array[j
- 1];

array[j - 1] =
array[j];

array[j] = temp;

flag = 1;// 记录是否发生数据交换

}

}

if (flag == 0)

break;

}

}

public void selectSort(int[]
array) {

// 选择排序，从小到大，总共比较n-1趟

for (int i = 0;
i < array.length - 1; i++) {

int min = i;//
不妨选择每趟第一个元素为比较对象，min记录最小值下标

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

if (array[j] <
array[min]) {

min = j;

}

}

// 找到了本趟最小值下标，将其值与本趟第一个值交换

int temp = array[i];

array[i] = array[min];

array[min] = temp;

}

}

public void insertSort(int[]
array) {

/*

* 直接插入排序 ，总共比较n-1趟
思想：把n个待排序的元素看成一个有序表和一个无序表， 开始时有序表中有1个元素，无序表中有n-1个元素，

* 排序过程中每次从无序表中取出第一个元素，依次与有序表中的元素比较，
找到适当的位置插入，使之成为新的有序表。

*/

for (int i = 1;
i < array.length; i++) {// 先认为第一个数是有序的，从数组中第二个元素开始与有序表中元素比较

int insertVal =
array[i];// 获取待比较的元素

int index = i -
1;// 第i趟，有序表中已经有了i个元素

while (index >=
0 && insertVal < array[index]) {// 将待插入的元素依次与前面的有序元素比较，直到找到适当位置

array[index + 1]
= array[index];// 给待插入的元素空出位置

index--;

}

array[index + 1]
= insertVal;// 执行插入操作

}

}

// partition函数，为快速排序做准备，把数据分割成以枢轴为中心的两部分

public int partition(int
low, int high, int[] array) {

int pivot = array[low];

while (low < high)
{

while (low < high
&& array[high] >= pivot)

--high; // high位置值与pivot比，高位下标--

array[low] = array[high];//
当以上条件不满足时，将high位置的值暂存于data[low]中。此时data[high]为空位

while (low < high
&& array[low] <= pivot)

++low; // low位置值与pivot比，低位下标++

array[high] = array[low];
// 当上条件不满足时，将low位置的值暂存于data[high]中。此时data[low]为空位

}

// while结束时，data[low]一定是空位

array[low] = pivot;

return low;

}

public void quickSort(int
low, int high, int[] array) {

// 快速排序(最快，但是占用内存大，典型的空间换时间)O(nlogn
(以2为底的))

if (low < high)
{

int k = partition(low,
high, array);

quickSort(low,
k - 1, array);

quickSort(k + 1,
high, array);

}

}

}

转自：http://cfanz.cn/index.php?c=article&a=read&id=50946