java语言排序方法_常用的内部排序方法(Java语言实现)

package cn.by.Struct.Sort;

public class Sort {

/**

*  插入排序

*

*  基本思想：

*  每一趟将一个待排序的记录，按其关键字值的大小插入到已经排序的

*  部分文件中适当位置上，直到全部插入完成。

*/

/**

* 直接插入排序(插入法)

*

* 逐个将纪录插入到已排好次序的有序表中得到一个新的有序表.

*

*/

public static void  chaSort(int[] table) {

int i,j;

int shao;//哨兵位

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) {

int i;

int j;

int shao;//哨兵位

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(int i = 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 (int i = 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;

int i = 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);

}

}