Java排序算法(保证最全,呕心沥血制作)

大家都学习过数据结构，都知道各种各样的排序方法，比如冒泡排序，选择排序，堆排序，归并排序等等，我学习的教材是C语言版的，今天处于好奇，写了一个用Java语言实现的直接选择排序的程序，与大家分享一下。

直接选择排序的思想是；
n个记录的文件的直接选择排序可经过n-1趟直接选择排序得到有序结果：
①初始状态：无序区为R[1..n]，有序区为空。

②第1趟排序
在无序区R[1..n]中选出关键字最小的记录R[k]，将它与无序区的第1个记录R[1]交换，使R[1..1]和R[2..n]分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。

……
③第i趟排序
第i趟排序开始时，当前有序区和无序区分别为R[1..i-1]和R[i..n](1≤i≤n-1)。

该趟排序从当前无序区中选出关键字最小的记录R[k]，将它与无序区的第1个记录R[i]交换，使R[1..i]和R[i+1..n]分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。

这样，n个记录的文件的直接选择排序可经过n-1趟直接选择排序得到有序结果。

用Java实现的代码如下：
/*
*@author 我为J狂建立日期2007-4-16
*
*/
package net.blogjava.lzqdiy;
publicclass MySort
{
/**
* @param args
*/
publicstaticvoid main(String[] args)
{
// TODO Auto-generated method stub
int n = Integer.parseInt(args[0]);// 输入数组长度
double R[] = newdouble[n];
if(n == 0)
System.out.println("数组为空");
else
{
System.out.println("排序前：");
for(int i = 0; i< n; i++)
R[i] = Double.parseDouble(args[i + 1]);// 输入数组元素。

for(int i = 0; i< n; i++)
{
if(i> 0)
System.out.print(",");
System.out.print(R[i]);
}
double temp = 0;
for(int i = 0; i< n - 1; i++)
{
for(int j = i + 1; j < n; j++)
{
if(R[j] < R[i])
{
temp = R[i];
R[i] = R[j];
R[j] = temp;
}
}
}
System.out.println();
System.out.println("排序后：");
for(int i = 0; i< n; i++)
{
if(i> 0)
System.out.print(",");
System.out.print(R[i]);
}
}
}
}
Java 常用排序算法实现--快速排序、插入排序、选择、冒泡publicclass ArrayOperation {
//二分查找算法
publicstaticint branchSearch(int[] array, int searchNum) {
if (array == null)
thrownew NullPointerException("Null Referrence");
if (array.length == 0)
thrownew IllegalArgumentException("Array Length is Zero");
int low = 0, high = array.length;
int middle = (high + low) / 2;
int index = -1;
if (searchNum< array[0] || searchNum> array[array.length - 1]) return index;
while (middle >= 0) {
if (array[middle] == searchNum) {
index = middle;
break;
}
if (searchNum> array[middle]) {
low = middle;
} else {
high = middle;
}
middle = (low + high) / 2;
}
return index;
}
// 快速排序
publicstaticvoid quickSort(int a[], int left, int right) {
int i, j, temp;
i = left;
j = right;
if (left > right)
return;
temp = a[left];
while (i != j)/* 找到最终位置 */
{
while (a[j] >= temp && j >i)
j--;
if (j >i)
a[i++] = a[j];
while (a[i] <= temp && j >i)
i++;
if (j >i)
a[j--] = a[i];
}
a[i] = temp;
quickSort(a, left, i - 1);/* 递归左边 */
quickSort(a, i + 1, right);/* 递归右边 */
}
// 插入排序
// 特点：用temp保存将要排序的临时值，然后把大的值插入到这个位置。

publicstaticint[] insert_Sort(int[] array) {
int i, j, temp;
for (i = 1; i<array.length; i++) {
for (j = i, temp = array[i]; j > 0 && temp < array[j - 1]; j--)
array[j] = array[j - 1];
array[j] = temp;
}
return array;
}
// 冒泡排序
// 特点：从第一个元素开始，如果需要交换，就一直冒泡到底，如果不需要交换，就从下一个元素开始比较
publicvoid bubble_Sort(int[] array, int size) {
int i, j, temp;
for (i = size - 1; i> 1; i--)
for (j = 0; j <i; j++)
if (array[j] > array[j + 1]) {
temp = array[j + 1];
array[j + 1] = array[j];
array[j] = temp;
}
}
// 交换排序
// 特点：始终是第一个元素与其他元素一一比较，交互后，继续用第一个元素与后面元素一一比较，重复下去。

publicint[] change_Sort(int[] array, int size) {
int i, j, temp;
for (i = 0; i< size; i++)
for (j = i + 1; j < size; j++)
if (array[i] > array[j]) {
temp = array[j];
array[j] = array[i];
array[i] = temp;
}
return array;
}
// 选择排序一（便于区分：咱就叫：选择最小值排序法）
// 特点：分有序区（第一个元素）和无序区（除第一元素外的元素），从无序区找出最小的元素移动到有序区
publicvoid SelectSort(int[] array) {
int i, j, k;// 分别为有序区，无序区，无序区最小元素指针
for (i = 0; i<array.length; i++) {
k = i;
for (j = i + 1; j <array.length; j++) {
if (array[j] < array[k])
k = j;
}
if (k != i)// 若发现最小元素，则移动到有序区
{
int temp = array[k];
array[k] = array[i];
array[i] = array[temp];
}
}
}
// 选择排序二
publicint[] select_Sort(int[] array, int size) {
int i, j, temp, pos;
for (i = 0; i< size; i++) {
for (j = i + 1, temp = array[i], pos = i; j < size; j++)
if (temp > array[j]) {
temp = array[j];
pos = j;
}
array[pos] = array[i];
array[i] = temp;
}
return array;
}
//希尔排序
// 属于插入类排序,是将整个无序列分割成若干小的子序列分别进行插入排序
// 排序过程：先取一个正整数d1<n，把所有序号相隔d1的数组元素放一组，组内进行直接插入排序；
// 然后取d2<d1，重复上述分组和排序操作；直至di=1，即所有记录放进一个组中排序为止publicstaticvoid ShellSort(int[] array) {
int length = array.length;
for (int h = length / 2; h > 0; h = h / 2) {
// here is insert sort
for (int i = h; i< length; i++) {
int temp = array[i];
if (temp < array[i - h]) {
for (int j = 0; j <i; j += h) {
if (temp < array[j]) {
temp = array[j];
array[j] = array[i];
array[i] = temp;
}
}
}
}
}
}
}………………………………………………………………………………………………………………………………………………………
<1>利用Arrays带有的排序方法快速排序
1import java.util.Arrays;
2publicclass Test2{
3publicstaticvoid main(String[] args){
4int[] a={5,4,2,4,9,1};
5Arrays.sort(a); //进行排序
6for(int i: a){
7System.out.print(i);
8 }
9 }
10 }
<2>冒泡排序算法
1publicstaticint[] bubbleSort(int[] args){//冒泡排序算法
2for(int i=0;i<args.length-1;i++){
3for(int j=i+1;j<args.length;j++){
4if (args[i]>args[j]){
5int temp=args[i];
6args[i]=args[j];
7args[j]=temp;
8 }
9 }
10 }
11return args;
12 }
<3>选择排序算法
1publicstaticint[] selectSort(int[] args){//选择排序算法
2for (int i=0;i<args.length-1 ;i++ ){
3int min=i;
4for (int j=i+1;j<args.length ;j++ ){
5if (args[min]>args[j]){
6 min=j;
7 }
8 }
9if (min!=i){
10int temp=args[i];
11args[i]=args[min];
12args[min]=temp;
13 }
14 }
15return args;
16 }
<4>插入排序算法
1publicstaticint[] insertSort(int[] args){//插入排序算法
2for(int i=1;i<args.length;i++){
3for(int j=i;j>0;j--){
4if (args[j]<args[j-1]){
5int temp=args[j-1];
6args[j-1]=args[j];
7args[j]=temp;
8 }elsebreak;
9 }
10 }
11return args;
12 }
---------------------------------------------------------------------------------------------------------------------------------package cn.by.Struct.Sort;
public class Sort {
/**
* 插入排序
*
* 基本思想：
* 每一趟将一个待排序的记录，按其关键字值的大小插入到已经排序的
* 部分文件中适当位置上，直到全部插入完成。

*/
/**
* 直接插入排序（插入法）
*
* 逐个将纪录插入到已排好次序的有序表中得到一个新的有序表.
*
*/
public static void chaSort(int[] table) {
inti,j;
intshao;//哨兵位
for(i = 1; i<table.length; i++) {//要从下标为1的元素开始
shao = table[i];//每次把当前元素赋给哨兵位
j = i - 1;//j每次为有序表的最后一个元素，哨兵位要从它开始比起
while(j >= 0 &&shao< table[j]) {//控制边界，大小判断找到位置
table[j + 1] = table[j];//元素后移，以便空出一个位置插入shao
j--;//下一次循环
}
table[j + 1] = shao;//找到位置，插入shao,为什么是j+1呢？因为在while退出的
//时候，j的位置是指向小于或等于shao的元素，所以shao的位置j要加1
}
}
/**
* 希尔（shell）排序
*
* 基本思想：
*
* 把记录按下标的一定增量d分组，对每组记录采用直接插入排序方法进行排序，随着增量逐渐减小，所分成的组包
* 含的记录越来越多，当增量的值减小到1时，整个数据合成为一组，构成一组有序记录，则完成排序。

*
* @param table
* @param n 元素个数
*/
public static void shellSort(int table[], int n) {
inti;
int j;
intshao;//哨兵位
int gap = n/2;//初始增量为长度减1
while(gap > 0) {
for(i = gap; i< n; i++) {//对所有相隔gap位置的所有元素进行排序
shao = table[i];//每次把当前元素赋给哨兵位
j = i - gap;//j每次为有序表的最后一个元素，哨兵位要从它开始比起
while(j >= 0 &&shao< table[j]) {//对相隔gap位置的元素组进行排序
table[j + gap] = table[j];//元素后移，以便空出一个位置插入shao
j = j - gap;//下一次循环
}
table[j + gap] = shao;//找到位置，插入shao,为什么是j+gap呢？因为在while退出的
//时候，j的位置是指向小于或等于shao的元素，所以shao的位置j要加gap
}
gap = gap/2;//
}
}
/**
* 选择排序
*
* 基本思想：
* 每步从待排序的记录中选出关键字最小的记录，按顺序放在已排序的记录序列的最后，* 直到全部排完为止。

*
*/
/**
* 直接选择排序
*
* 进行n-1趟，每一趟逐个与剩余元素比较，找到小的就与之交换。

*/
public static void selectSort(int table[]) {
int temp;//用于交换
for(inti = 0; i<table.length - 1; i++) {
for(int j = i + 1; j <table.length; j++ ){
if(table[i] > table[j]) {
temp = table[i];
table[i] = table[j];
table[j] = temp;
}
}
}
}
/**
*交换排序
*
*基本思想:
*两两比较待排序记录的关键字，并交换不满足次序要求的那些偶对，直到全部满足为止。

*/
/**
*冒泡排序
*
*相邻之间相比较.n个元素要进行n-1趟。

每趟要比较n减该趟（当前趟）次。

*
*从后向前冒，冒出最小的数
*@param array 要查的一个数组
*@return无返回值
*/
public static void maoSort(int[] table) {
/**
*主要用于提前结束比较,即如果一趟中没有一个元素交换，则后面还没有进行的趟也不用进行了。

*/
int exchange;
// 临时交换变量
int temp;
for (inti = 1; i<= table.length - 1; i++) {//要走的趟数
exchange = 0; // 初始值为0
for (int j = table.length - 1; j >i - 1; j--)//每趟要交换的次数
if (table[j] < table[j - 1]) {
temp = table[j];
table[j] = table[j - 1];
table[j - 1] = temp;
exchange = 1; // 如有交换则更改为1
}
// 提前结束
if (exchange == 0)
return;
}
}
/**
*快速排序：
*
*通过一趟排序将待排序记录分割成独立的两部分，
*其中一部分记录的关键字均比另一部分的关键字小，再分别
*对这两部分记录继续进行排序，以达到整个序列有序。

*
*@param table-待排序数组
*@param begin-待排序的起始源点
*@param end-待排序的终止点
*/
public static void quickSort(int []table, int begin, int end) {
//异常处理，待排序的起始源点不能小于0且不能大于待排序的终止点if((begin < 0) || (begin > end))
return;
inti = begin;
int j = end;
int tem;
//存放界点,用区间的第一个元素作基准
tem = table[begin];
//从区间两端交替向中间扫描，直至i=j为止
while(i != j) {
//从右向左扫描，找第一个小于tem的元素
while((j >i) && table[j] > tem)
j--;
//从左向右扫描，找第一个大于tem的元素
while((i< j) && table[i] < tem)
i++;
//满足条件交换
if(i< j) {
int change;
change = table[j];
table[j] = table[i];
table[i] = change;
}
}
//分成两部分记录
table[i] = tem;
//对界点前部分记录排序
quickSort(table, begin, i - 1);
//对界点后部分记录排序
quickSort(table, i + 1, end);
}
}
//////////////////////////////////////////////////////////////////////////////////////////////////////
1./**
2.* 插入排序<br/>
3.* <ul>
4.* <li>从第一个元素开始，该元素可以认为已经被排序</li>
5.* <li>取出下一个元素，在已经排序的元素序列中从后向前扫描</li>
6.* <li>如果该元素（已排序）大于新元素，将该元素移到下一位置</li>
7.* <li>重复步骤3，直到找到已排序的元素小于或者等于新元素的位置</li>
8.* <li>将新元素插入到该位置中</li>
9.* <li>重复步骤2</li>
10.* </ul>
11.*
12.* @param numbers
13.*/
14.publicstaticvoidinsertSort(int[] numbers) {
15.int size = numbers.length, temp, j;
16.for(inti=1; i<size; i++) {
17.temp = numbers[i];
18.for(j = i; j >0&& temp < numbers[j-1]; j--)
19.numbers[j] = numbers[j-1];
20.numbers[j] = temp;
21.}
22.}
1./**
2.* 归并排序<br/>
3.* <ul>
4.* <li>申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列</li>
5.* <li>设定两个指针，最初位置分别为两个已经排序序列的起始位置</li>
6.* <li>比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
</li>
7.* <li>重复步骤3直到某一指针达到序列尾</li>
8.* <li>将另一序列剩下的所有元素直接复制到合并序列尾</li>
9.* </ul>
10.* 算法参考：<a href="/intrl/"
mce_href="/intrl/">Java部落</a>
11.*
12.* @param numbers
13.*/
14.publicstaticvoidmergeSort(int[] numbers, int left, int right) {
15.int t = 1;// 每组元素个数
16.int size = right - left + 1;
17.while (t < size) {
18.int s = t;// 本次循环每组元素个数
19.t = 2 * s;
20.inti = left;
21.while (i + (t - 1) < size) {
22.merge(numbers, i, i + (s - 1), i + (t - 1));
23.i += t;
24.}
25.if (i + (s - 1) < right)
26.merge(numbers, i, i + (s - 1), right);
27.}
28.}
29./**
30.* 归并算法实现
31.*
32.* @param data
33.* @param p
34.* @param q
35.* @param r
36.*/
37.privatestaticvoid merge(int[] data, int p, int q, int r) {
38.int[] B = newint[data.length];
39.int s = p;
40.int t = q + 1;
41.int k = p;
42.while (s <= q && t <= r) {
43.if (data[s] <= data[t]) {
44.B[k] = data[s];
45.s++;
46.} else {
47.B[k] = data[t];
48.t++;
49.}
50.k++;
51.}
52.if (s == q + 1)
53.B[k++] = data[t++];
54.else
55.B[k++] = data[s++];
56.for (inti = p; i<= r; i++)
57.data[i] = B[i];
58.}
1./**
2.* BubbleSort.class
3.*/
4.packagetest.sort;
5.importjava.util.Random;
6./**
7.* Java实现的排序类
9.* @author cyq
10.*
11.*/
12.publicclassNumberSort {
13./**
14.* 私有构造方法，禁止实例化
15.*/
16.privateNumberSort() {
17.super();
18.}
19./**
20.* 冒泡法排序<br/>
21.* <ul>
22.* <li>比较相邻的元素。

如果第一个比第二个大，就交换他们两个。

</li>
23.* <li>对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。

在这一点，最后的元
素应该会是最大的数。

</li>
24.* <li>针对所有的元素重复以上的步骤，除了最后一个。

</li>
25.* <li>持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

</li>
26.* </ul>
27.*
28.* @param numbers
29.* 需要排序的整型数组
30.*/
31.publicstaticvoidbubbleSort(int[] numbers) {
32.int temp; // 记录临时中间值
33.int size = numbers.length; // 数组大小
34.for (inti = 0; i< size - 1; i++) {
35.for (int j = i + 1; j < size; j++) {
36.if (numbers[i] < numbers[j]) { // 交换两数的位置
37.temp = numbers[i];
38.numbers[i] = numbers[j];
39.numbers[j] = temp;
40.}
41.}
43.}
44./**
45.* 快速排序<br/>
46.* <ul>
47.* <li>从数列中挑出一个元素，称为“基准”</li>
48.* <li>重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准
的后面（相同的数可以到任一边）。

在这个分割之后，
49.* 该基准是它的最后位置。

这个称为分割（partition）操作。

</li>
50.* <li>递归地把小于基准值元素的子数列和大于基准值元素的子数列排序。

</li>
51.* </ul>
52.*
53.* @param numbers
54.* @param start
55.* @param end
56.*/
57.publicstaticvoidquickSort(int[] numbers, int start, int end) {
58.if (start < end) {
59.int base = numbers[start]; // 选定的基准值（第一个数值作为基准值）
60.int temp; // 记录临时中间值
61.inti = start, j = end;
62.do {
63.while ((numbers[i] < base) && (i< end))
64.i++;
65.while ((numbers[j] > base) && (j > start))
66.j--;
67.if (i<= j) {
68.temp = numbers[i];
69.numbers[i] = numbers[j];
70.numbers[j] = temp;
71.i++;
72.j--;
73.}
74.} while (i<= j);
75.if (start < j)
76.quickSort(numbers, start, j);
77.if (end >i)
78.quickSort(numbers, i, end);
79.}
80.}
81./**
82.* 选择排序<br/>
83.* <ul>
84.* <li>在未排序序列中找到最小元素，存放到排序序列的起始位置</li>
85.* <li>再从剩余未排序元素中继续寻找最小元素，然后放到排序序列末尾。

</li>
86.* <li>以此类推，直到所有元素均排序完毕。

</li>
87.* </ul>
88.*
89.* @param numbers
90.*/
91.publicstaticvoidselectSort(int[] numbers) {
92.int size = numbers.length, temp;
93.for (inti = 0; i< size; i++) {
94.int k = i;
95.for (int j = size - 1; j >i; j--) {
96.if (numbers[j] < numbers[k])
97.k = j;
98.}
99.temp = numbers[i];
100.numbers[i] = numbers[k];
101.numbers[k] = temp;
102.}
103.}
104./**
105.* 插入排序<br/>
106.* <ul>
107.* <li>从第一个元素开始，该元素可以认为已经被排序</li>
108.* <li>取出下一个元素，在已经排序的元素序列中从后向前扫描</li>
109.* <li>如果该元素（已排序）大于新元素，将该元素移到下一位置</li>
110.* <li>重复步骤3，直到找到已排序的元素小于或者等于新元素的位置</li>
111.* <li>将新元素插入到该位置中</li>
112.* <li>重复步骤2</li>
113.* </ul>
114.*
115.* @param numbers
116.*/
117.publicstaticvoidinsertSort(int[] numbers) {
118.int size = numbers.length, temp, j;
119.for (inti = 1; i< size; i++) {
120.temp = numbers[i];
121.for (j = i; j >0&& temp < numbers[j - 1]; j--)
122.numbers[j] = numbers[j - 1];
123.numbers[j] = temp;
124.}
125.}
126./**
127.* 归并排序<br/>
128.* <ul>
129.* <li>申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列</li> 130.* <li>设定两个指针，最初位置分别为两个已经排序序列的起始位置</li>
131.* <li>比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置</li>
132.* <li>重复步骤3直到某一指针达到序列尾</li>
133.* <li>将另一序列剩下的所有元素直接复制到合并序列尾</li>
134.* </ul>
135.* 算法参考：<a href="/intrl/"
mce_href="/intrl/">Java部落</a>
136.*
137.* @param numbers
138.*/
139.publicstaticvoidmergeSort(int[] numbers, int left, int right) {
140.int t = 1;// 每组元素个数
141.int size = right - left + 1;
142.while (t < size) {
143.int s = t;// 本次循环每组元素个数
144.t = 2 * s;
145.inti = left;
146.while (i + (t - 1) < size) {
147.merge(numbers, i, i + (s - 1), i + (t - 1));
148.i += t;
149.}
150.if (i + (s - 1) < right)
151.merge(numbers, i, i + (s - 1), right);
152.}
153.}
154./**
155.* 归并算法实现
156.*
157.* @param data
158.* @param p
159.* @param q
160.* @param r
161.*/
162.privatestaticvoid merge(int[] data, int p, int q, int r) { 163.int[] B = newint[data.length];
164.int s = p;
165.int t = q + 1;
166.int k = p;
167.while (s <= q && t <= r) {
168.if (data[s] <= data[t]) {
169.B[k] = data[s];
170.s++;
171.} else {
172.B[k] = data[t];
173.t++;
174.}
175.k++;
176.}
177.if (s == q + 1)
178.B[k++] = data[t++];
179.else
180.B[k++] = data[s++];
181.for (inti = p; i<= r; i++) 182.data[i] = B[i];
183.}
184.
185.}。