几种基本算法

摘要: 在JDK中有这几句话：

如果一个要排序的数组长度小于这个常数(47)，插入排序是优先用于快速排序。

如果一个要排序的数组长度小于这个常数(286)，快速排序是优先使用归并排序。

如果要排序的字节数组的长度大于此常数(29)， 计数排序优先用于插入排序。

如果长度short或char数组进行排序是大于这个常数(3200)，计数排序是优先用于快速排序。

在这里记录下：

/**
* 排序
*/
public class PaiXuTest {

// 1、直接插入排序
/*
* 基本思想：在要排序的一组数中，假设前面(n-1)[n>=2] 个数已经是排 好顺序的，现在要把第n个数插到前面的有序数中，使得这 n个数
* 也是排好顺序的。如此反复循环，直到全部排好顺序。
*/
public static void insertSort(int array[]) {
int temp = 0;
for (int i = 0; i < array.length; i++) {
int j = i - 1;
temp = array[i];
for (; j >= 0 && temp < array[j]; j--) {
array[j + 1] = array[j];// 将temp的值整体向后移动一个单位
}
array[j + 1] = temp;
}

for (int i = 0; i < array.length; i++) {
System.out.println("插入排序="+array[i]);
}
}

// 2、希尔排序（最小增量排序）
/*
* 基本思想：算法先将要排序的一组数按某个增量 d（n/2,n为要排序数的个数）分成若 干组，每组中记录的下标相差
* d.对每组中全部元素进行直接插入排序，然后再用一个较小 的增量（d/2）对它进行分组，在每组中再进行直接插入排序。当增量减到 1 时，进行直接
* 插入排序后，排序完成。
*/

public static void shellSort(int array[]) {
double d1 = array.length;
int temp = 0;
while (true) {
d1 = Math.ceil(d1 / 2);
int d = (int) d1;
for (int i = 0; i < d; i++) {
for (int j = i + d; j < array.length; j += d) {
int k = j - d;
temp = array[j];
for (; k >= 0 && temp < array[k]; k -= d) {
array[k + d] = array[k];
}
array[k + d] = temp;
}
}
if (d == 1) {
break;
}

}
for (int i = 0; i < array.length; i++) {
System.out.println("希尔排序="+array[i]);
}
}

// 3、选择排序
/*
* 基本思想：在要排序的一组数中，选出最小的一个数与第一个位置的数交换；
*
* 然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一
*
* 个数比较为止。
*/
public static void selectSort(int array[]) {
int point = 0;
for (int i = 0; i < array.length; i++) {
int j = i + 1;
point = i;
int temp = array[i];
for (; j < array.length; j++) {
if (array[j] < temp) {
temp = array[j];
point = j;
}
}
array[point] = array[i];
array[i] = temp;
}

for (int i = 0; i < array.length; i++) {
System.out.println("选择排序"+array[i]);
}
}

// 4、冒泡排序
/*
* 基本思想：在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对
*
* 相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的
*
* 数比较后发现它们的排序与排序要求相反时，就将它们互换。
*/
public static void bubbleSort(int array[]){
int temp = 0;
for (int i = 0; i < array.length-1; i++) {
for (int j = 0; j < array.length-1-i; j++) {
if (array[j] > array[j+1]) {
temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
}
}
}
for (int i = 0; i < array.length; i++) {
System.out.println("冒泡排序"+array[i]);
}
}

//5、快速排序
/*
* 基本思想：选择一个基准元素,通常选择第一个元素或者最后一个元素,通过一趟扫描，
*
* 将待排序列分成两部分,一部分比基准元素小,一部分大于等于基准元素,此时基准元素在其
*
* 排好序后的正确位置,然后再用同样的方法递归地排序划分的两部分。
*/
public static void quickSort(int array[]){
// 判断数组是否为空
if (array.length > 0) {
_quickSort(array, 0, array.length-1);
}
for (int i = 0; i < array.length; i++) {
System.out.println("快速排序="+array[i]);
}
}
public static	int getMiddle(int[] list,int low,int hight){
// 数组的第一个做为中轴
int temp = list[low];
while (low < hight) {
while (low < hight && list[hight] >= temp) {
hight --;
}
// 比中轴小的记录移动到低	端
list[low] = list[hight];
while (low < hight && list[low] <= temp) {
low ++;
}
// 比中轴大的移动到高端
list[hight] = list[low];
}
// 中轴记录到尾
list[low] = temp;
// 返回中轴的位置
return low;
}
public static void _quickSort(int[] list,int low,int hight) {
if (low < hight) {
// 将list 数组进行一分为二
int middle = getMiddle(list, low, hight);
// 对低字表进行递归排序
_quickSort(list, low, middle-1);
// 对高子表进行递归排序
_quickSort(list, middle+1, hight);
}
}

// 6、归并排序
/*
* 基本排序：归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有
*
* 序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并
*
* 为整体有序序列。
*/
public static void mergingSort(int array[]){
sort(array,0,array.length-1);
for (int i = 0; i < array.length; i++) {
System.out.println("归并排序"+array[i]);
}
}
public static void sort(int[] array, int left, int right) {
if (left < right) {
// 找出中间索引
int middle = (left+right) / 2;
// 对左边数组进行递归
sort(array, left, middle);
// 对右边数组进行递归
sort(array, middle+1, right);
// 合并
merge(array,left,middle,right);
}

}
public static void merge(int[] array, int left, int middle, int right) {
int[] tempArray = new int[array.length];
int mid = middle +1;
// third 记录中间数组的索引
int third = left;
int temp = left;
while (left <= middle && mid <= right) {
// 从两个数组中取出最小的数组放在中间数组
if (array[left] <= array[mid]) {
tempArray[third++] = array[left++];
}else{
tempArray[third++] = array[mid++];
}
}
// 剩余部分依次放入中间数组
while (mid <= right) {
tempArray[third++] = array[mid++];
}
while (left <= middle) {
tempArray[third++] = array[left++];
}
// 将中间数组中的内容复制到原数组
while (temp <= right) {
array[temp] = tempArray[temp++];
}
}

// 主程序
public static void main(String[] args) {
int array[] = { 49, 38, 65, 97, 76, 13, 27 };
/* Java 工具类
* Arrays.sort(array);
for (int i = 0; i < array.length; i++) {
System.out.println("--" + array[i]);
}*/

// 1、PaiXuTest.insertSort(array);
// 2、PaiXuTest.shellSort(array);
// 3、PaiXuTest.selectSort(array);
// 4、bubbleSort(array);
// 5、quickSort(array);
// 6、mergingSort(array);
}

}