整理的常见排序算法

package 排序;

/**

*

* @ClassName: Sort

* @Description: 各种排序

* @author liuwei

* @date 2016年7月5日

*

*/

//有些排序没作判断优化，请读者自行发觉。

//选择排序交换次数过多，可以直接设坐标

public class Sort {

public static void swap(int[] s, int a, int b) {// swap

int temp = s[a];

s[a] = s[b];

s[b] = temp;

}

// 冒泡排序
// 两两比较待排序记录的关键字，发现两个记录的次序相反时进行交换
public static void bubbleSort(int[] a) {
for (int i = a.length - 1; i > 0; i--) {
for (int j = 0; j < i; j++) {
if (a[j] > a[j + 1]) {
swap(a, j, j + 1);
}
}
}
}

static void bidBubbleSort(int a[]) // 双向冒泡排序
{
int left, right, t, l, r, j, i = 0;

left = 0;
right = a.length - 1;

// 双向冒泡算法，极大的减少了循环排序的次数
while (left < right) {
// 必须要给l和r赋值，否则若数组一开始就有序，则right=r中的r未赋值，即报错
l = left + 1;
r = right - 1;

// 第一次循环将最大的值放到末尾
for (j = left; j < right; j++) {
if (a[j] > a[j + 1]) {
t = a[j];
a[j] = a[j + 1];
a[j + 1] = t;
r = j;
}
}
right = r;

// 第二次循环将最小的值放到了开头
for (j = right; j > left; j--) {
if (a[j] < a[j - 1]) {
t = a[j];
a[j] = a[j - 1];
a[j - 1] = t;
l = j;
}
}
left = l;

System.out.println("第%d次排序结果：" + (i + 1));
i++;
for (j = 0; j < a.length; j++) {
System.out.println("%d\t" + a[j]);
}
}
System.out.println("最终排序结果： ");
for (j = 0; j < a.length; j++) {
System.out.println("%d\t" + a[j]);
}
}

// 选择排序
// 首先在未排序中找到最小元素，存放到排序序列的起始位置
public static void selectSort(int[] a) {
for (int i = 0; i < a.length; i++) {
for (int j = i + 1; j < a.length; j++) {
if (a[j] < a[i])
swap(a, i, j);
}
}
}

// 插入排序
// 从第一个元素开始，该元素认为已经被排序
// 取出下一个元素，在已经排序的元素序列中从后向前扫描
// 如果该元素（已排序）大于新元素，则该元素前移，直到找到已排序的元素小雨或者等于新元素的位置，将新元素插入到该位置中
public static void inertSort(int[] a) {
for (int i = 1; i < a.length; i++) {
for (int j = i; j > 0; j--) {
if (a[j] < a[j - 1])
swap(a, j, j - 1);
}
}
}

// 希尔排序（不是最优解）
public static void shellSort(int[] a) {
// 计算出最大的h值
int h = 1;
while (h <= a.length / 3) {
h = h * 3 + 1;
}
while (h > 0) {
for (int i = h; i < a.length; i += h) {
if (a[i] < a[i - h]) {
int tmp = a[i];
int j = i - h;
while (j >= 0 && a[j] > tmp) {
a[j + h] = a[j];
j -= h;
}
a[j + h] = tmp;
}
}
// 计算出下一个h值
h = (h - 1) / 3;
}
}

static void shellsort2(int a[]) {
int j, gap;
gap = a.length;
// for (gap = n / 2; gap > 0; gap /= 2)
do {
gap = gap / 3 + 1;
for (j = gap; j < a.length; j++)
// 从数组第gap个元素开始
if (a[j] < a[j - gap])// 每个元素与自己组内的数据进行直接插入排序
{
int temp = a[j];
int k = j - gap;
while (k >= 0 && a[k] > temp) {
a[k + gap] = a[k];
k -= gap;
}
a[k + gap] = temp;

}
} while (gap > 1);
}

static void shellsort3(int a[]) {
int gap = a.length;
// for (gap = n / 2; gap > 0; gap /= 2)
do {
gap = gap / 3 + 1;
for (int i = gap; i < a.length; i++)
for (int j = i - gap; j >= 0 && a[j] > a[j + gap]; j -= gap)
swap(a, j, j + gap);
} while (gap > 1);
}

// 折半插入排序
private static void binaryInsertSort(int[] a) {
for (int i = 1; i < a.length; i++) {
int temp = a[i];
int start = 0;
int end = i - 1;
while (start <= end) {
int mid = (start + end) / 2;
if (temp < a[mid]) {
end = mid - 1;
} else {
start = mid + 1;
}
}
for (int j = i; j >= start + 1; j--) {
a[j] = a[j - 1];
}
a[start] = temp;
}
}

// 快排
static void quickSort(int n[], int left, int right) {
int dp;
if (left < right) {
dp = partition(n, left, right);
quickSort(n, left, dp - 1);
quickSort(n, dp + 1, right);
}
}

// 找基准值
static int partition(int a[], int left, int right) {
int pivot = a[left];
while (left < right) {
while (left < right && a[right] >= pivot)
right--;
swap(a, left, right);
while (left < right && a[left] <= pivot)
left++;
swap(a, right, left);
}
// a[left] = pivot;
return left;
}

// 归并排序
public static void mergesort(int[] a, int start, int end) {
int mid = (start + end) / 2;
if (start < end) {
mergesort(a, start, mid);// 左边
mergesort(a, mid + 1, end);// 右边
merge(a, start, mid, end);// 左右归并
}
//  return a;
}

public static void merge(int[] a, int start, int mid, int end) {
int[] temp = new int[end - start + 1];
int i = start;// 左指针
int j = mid + 1;// 右指针
int k = 0; // 把较小的数先移到新数组中
while (i <= mid && j <= end) {
if (a[i] < a[j]) {
temp[k++] = a[i++];
} else {
temp[k++] = a[j++];
}
} // 把左边剩余的数移入数组
while (i <= mid) {
temp[k++] = a[i++];
} // 把右边边剩余的数移入数组
while (j <= end) {
temp[k++] = a[j++];
} // 把新数组中的数覆盖a数组
for (int k2 = 0; k2 < temp.length; k2++) {
a[k2 + start] = temp[k2];
}
}

public static void print(int[] a) {
for (int i = 0; i < a.length; i++)
System.out.print(a[i] + "  ");
System.out.println();
}

public static void main(String[] args) {
// int[] a = {46, 30, 82, 90, 56, 17, 95, 15 };
int[] a = new int[20];
for (int i = 0; i < a.length; i++)
a[i] = (int) (Math.random() * 50);
for (int i = 0; i < a.length; i++)
System.out.print(a[i] + "  ");
System.out.println();
System.out.println();
// mergesort(a, 0, a.length - 1);
// bidBubbleSort(a);
// long start = System.currentTimeMillis();
mergesort(a, 0, a.length - 1);
// long end = System.currentTimeMillis();
//
// System.out.println("cost time: " + (end - start) + "ms");

System.out.println();
for (int i = 0; i < a.length; i++)
System.out.print(a[i] + "  ");
System.out.println();
}

}