您的位置:首页 > 编程语言 > Java开发

几种排序算法java简单实现

2009-05-08 17:10 721 查看
package test;

/**
* 排序算法简单实现 冒泡排序,选择排序,插入排序,希尔排序,快速排序(中值划分,递归排序)
*
* @author LIUQIANG
*
*/
public class SortEnablement {

/**
* 交换数据项
*
* @param array
*            数组
* @param left
*            数组下标
* @param right
*            数组下标
*/
private void swap(int array[], int left, int right) {
int temp = array[left];
array[left] = array[right];
array[right] = temp;
}

/**
* 冒泡排序法 将较小的数据项冒泡似的浮起来
*
* @param array
*            需要排序的数组
*/
public void bubbleSort(int[] array) {
for (int i = 0; i < array.length - 1; i++) {
for (int n = i + 1; n < array.length; n++) {
if (array[i] > array
) {
swap(array, i, n);
}
}
}
}

/**
* 选择排序法 选择出未排序的数据项中的最小项,和剩余未排序数据项的起始项交换
*
* @param array
*            需要排序的数组
*/
public void chooseSort(int[] array) {
int tempIndex;
for (int i = 0; i < array.length; i++) {
tempIndex = i;
for (int n = i; n < array.length - 1; n++) {
if (array[tempIndex] > array[n + 1]) {
tempIndex = n + 1;
}
}
swap(array, i, tempIndex);
}
}

/**
* 插入排序法 假定开始的部分数据项已经有序,把剩下的无序数据项一一插入到,有序数据项的相应位置使其插入后有序
*
* @param array
*            需要排序的数组
*/
public void insertSort(int[] array) {
for (int i = 1; i < array.length; i++) {
for (int n = i; n > 0 && array[n - 1] > array
; n--) {
swap(array, n, n - 1);
}
}
}

/**
* 希尔排序法 排序相隔相同步长的各数据项,并循环的减小步长
*
* @param array
*            需要排序的数组
*/
public void shellSort(int[] array) {
int step = 1;
while (step <= array.length / 3) {
step = step * 3 + 1;
}

for (int i = step; i > 0; i = (i - 1) / 3) {
for (int n = i; n < array.length; n++) {
for (int o = n; o >= i; o = o - i) {
if (array[o] < array[o - i]) {
swap(array, o, o - i);
}
}
}
}
}

/**
* 划分算法 以枢纽为关键字把数组划分为,小于关键字的一组和大于关键字的一组
*
* @param array
*            划分的目标数组
* @param left
*            左边开始位置
* @param right
*            右边开始位置
* @param key
*            枢纽关键字
* @return 枢纽的正确位置
*/
private int partition(int[] array, int left, int right, int key) {
int indexRight = right - 1;
while (true) {
while (key > array[left])
left++;
while (right >= 0 && key <= array[right])
right--;
if (left >= right) {
break;
} else {
swap(array, left, right);
}
}
swap(array, indexRight, left);
return left;
}

/**
* 中值划分,获取中值,并排序各项
*
* @param array
*            需要排序的数组
* @param left
*            数组左端开始处
* @param right
*            数组右端开始出
* @return 数组中值
*/
private int getCenter(int[] array, int left, int right) {
int center = (left + right) / 2;
if (array[left] > array[center]) {
swap(array, left, center);
}
if (array[left] > array[right]) {
swap(array, left, right);
}
if (array[center] > array[right]) {
swap(array, center, right);
}
swap(array, center, right - 1);
return array[right - 1];
}

/**
* 快速排序-递归的划分数组
*
* @param array
*            排序的数组
* @param left
*            左边开始排序位置
* @param right
*            右边开始排序位置
*/
private void quiklySort(int[] array, int left, int right) {
int size = right - left + 1;
if(size <= 1) {
return;
}else if(size == 2){
if (array[left] > array[right]) {
swap(array, left, right);
}
}else if(size == 3){
getCenter(array, left, right);
}else{
int center = getCenter(array, left, right);
int partition = partition(array, left, right, center);
quiklySort(array, left, partition - 1);
quiklySort(array, partition + 1, right);
}
}

/**
* 快速排序-递归
*
* @param array
*            排序的数组
*/
public void quickSort(int[] array) {
quiklySort(array, 0, array.length - 1);
}
}
内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
标签: