排序算法(1)-冒泡排序,选择排序,插入排序,希尔排序,快速排序
一些基本的排序算法:
package tenSortingMethods;
/**
* @author zhangdi
* @description 排序算法
* @Date 20180531
*/
public class Sort {
public static void main(String[] args) {
int[] arr = {6,1,2,7,9,3,4,5,10,8};//{ 26, 88, 45, 57, 12, 31, 12, 2, 64, 32, 20, 99, 1 };
int[] arr1 = { 2, 1, 3, 5, 4 };// {6,1,2,7,9,3,4,5,10,8};
// System.out.println(arr.getClass());
System.out.println(" arr before sorting: " + IntArrtoString(arr));
// BubbleSort(arr);
// BubbleSort2(arr);
// BubbleSort1_better(arr);
// SelectSort(arr);
// InsertionSort(arr);
// ShellSort(arr);
// ShellSort2(arr);
// int[] quickSort = new Sort().QuickSort(arr, 0, arr.length - 1);
// System.out.println(" quickSort after sorting: " +
// IntArrtoString(quickSort));
int[] quickSort2 = new Sort().QuickSort2(arr, 0, 9);
// System.out.println(" quickSort2 after sorting: " +
// IntArrtoString(quickSort2));
System.out.println(" arr after sorting: " + IntArrtoString(arr));
}
/**
* @description 冒泡排序
* @param arr
* @description : 两两比较,大的往后放; 每一次比较完成之后,下一次就少比较一个元素
* 第一次比较有0个元素不比较;第二次有一个元素不需要比较;第三次有两个元素不需要比较;
* 共需要比较arr.length-1次
*/
public static void BubbleSort(int[] arr) {
int temp;// 临时变量
if (arr == null || arr.length == 0)
return;
for (int i = 0; i < arr.length - 1; i++) { // 表示趟数，一共arr.length-1次。
for (int j = arr.length - 1; j > i; j--) {
if (arr[j] < arr[j - 1]) {
temp = arr[j];
arr[j] = arr[j - 1];
arr[j - 1] = temp;
}
}
}
}
/**
* @description 冒泡排序-2
* @param arr
*
*/
public static void BubbleSort2(int[] arr) {
int temp;// 临时变量
if (arr == null || arr.length == 0)
return;
for (int i = 0; i < arr.length - 1; i++) { // 表示趟数，一共arr.length-1次。
for (int j = 0; j < arr.length - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
/**
* @description 冒泡排序-1-优化
* @param arr
* * 针对问题:数据的顺序排好之后，冒泡算法仍然会继续进行下一轮的比较，直到arr.length-1次，后面的比较没有意义的。
* 方案: 设置标志位flag，如果发生了交换flag设置为true；如果没有交换就设置为false。
* 这样当一轮比较结束后如果flag仍为false，即：这一轮没有发生交换，说明数据的顺序已经排好，没有必要继续进行下去。
*
*/
public static void BubbleSort1_better(int[] arr) {
int temp;// 临时变量
boolean flag;
if (arr == null || arr.length == 0)
return;
for (int i = 0; i < arr.length - 1; i++) { // 表示趟数，一共arr.length-1次。
flag = false;
for (int j = arr.length - 1; j > i; j--) {
if (arr[j] < arr[j - 1]) {
temp = arr[j];
arr[j] = arr[j - 1];
arr[j - 1] = temp;
}
}
if (!flag)
break;
}
}
/**
* @description 选择排序
* @param arr
* 在长度为N的无序数组中，第一次遍历n-1个数，找到最小的数值与第一个元素交换；
* 第二次遍历n-2个数，找到最小的数值与第二个元素交换； 。。。
* 第n-1次遍历，找到最小的数值与第n-1个元素交换，排序完成。
*/
public static void SelectSort(int[] arr) {
int len = arr.length;
int temp;// 临时变量
if (arr == null || len == 0)
return;
for (int i = 0; i < len - 1; i++) {
int minIndex = i;// 假定此时i位置元素为最小数值
for (int j = i + 1; j < arr.length; j++) {
if (arr[j] < arr[minIndex]) {
// 如果i+1后的元素值小于i位置的元素,那么改变minIndex值.当内层循环走完,此时数组最小值得小标就确定了
minIndex = j;
}
}
if (minIndex != i) {
// 最小值下标改变,交换元素
temp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = temp;
}
}
}
/**
* @description 插入排序
* @param arr
* @description : 在要排序的一组数中，假定前n-1个数已经排好序，现在将第n个数插到前面的有序数列中，使得这n个数也是排好顺序的。
* 如此反复循环，直到全部排好顺序。 位于表中后面的元素依次与表中前面的元素比较，若比之小，则还需继续和更前面的元素比较，
* 直至遇到一个比它大的元素或者比较到第一个元素(哨兵)了。
*/
public static void InsertionSort(int[] arr) {
int len = arr.length;
int temp;// 临时变量
if (arr == null || len == 0)
return;
for (int i = 0; i < len - 1; i++) {// 趟数n-1趟
for (int j = i + 1; j > 0; j--) {
if (arr[j] < arr[j - 1]) {
temp = arr[j];
arr[j] = arr[j - 1];
arr[j - 1] = temp;
} else {
break;
}
}
}
}
/**
* @description 希尔排序 (最小增量排序)
* @param arr
* @description: 我们选择增量gap=length/2，缩小增量继续以gap =
* gap/2的方式，这种增量选择我们可以用一个序列来表示，{n /2,(n/2)/2...1}，称为增量序列。
* 希尔排序的增量序列的选择与证明是个数学难题， 我们选择的这个增量序列是比较常用的，也是希尔建议的增量，
* 称为希尔增量，但其实这个增量序列不是最优的。 此处我们做示例使用希尔增量。
* 比如原始数组8917235460,初始增量为gap =length/5;即数组被分为五组
* [8,3],[9,5],[1,4],[7,6],[2,0] ,对五组分别进行插入排序;第一次排序后:
* 3514089472,缩小增量为gap =gap/2 =
* 2;分为两组[3,5,1,4,0],[8,9,4,7,2],插入排序 -->[0214357698],
* 再缩小增量gap = gap/ = 1,[0214357698] -->插入排序.
*
*
*/
public static void ShellSort(int[] array) {
int temp = 0;
int incre = array.length;
while (true) {
incre = incre / 2;
for (int k = 0; k < incre; k++) { // 根据增量分为若干子序列
for (int i = k + incre; i < array.length; i += incre) {
for (int j = i; j > k; j -= incre) {
if (array[j] < array[j - incre]) {
temp = array[j - incre];
array[j - incre] = array[j];
array[j] = temp;
} else {
break;
}
}
}
}
if (incre == 1) {
break;
}
}
}
/**
* @description 希尔排序 (最小增量排序)
* @param arr
* 在希尔排序的理解时，我们倾向于对于每一个分组，逐组进行处理，但在代码实现中，
* 我们可以不用这么按部就班地处理完一组再调转回来处理下一组（ 这样还得加个for循环去处理分组）比如[5,4,3,2,1,0]
* ，首次增量设gap=length/2=3,则为3组[5,2] [4,1]
* [3,0]，实现时不用循环按组处理，我们可以从第gap个元素开始，逐个跨组处理。同时，在插入数据时，
* 可以采用元素交换法寻找最终位置， 也可以采用数组元素移动法寻觅。
*
*/
/**
* 希尔排序 针对有序序列在插入时采用交换法 见图
*
* @param arr
*/
public static void ShellSort2(int[] arr) {
System.out.println("ShellSort2 start.........");
// 增量gap，并逐步缩小增量
for (int gap = arr.length / 2; gap > 0; gap /= 2) {
// 从第gap个元素，逐个对其所在组进行直接插入排序操作
System.out.println("1 gap:" + gap + " arr:" + IntArrtoString(arr));
for (int i = gap; i < arr.length; i++) {
int j = i;
while (j - gap >= 0 && arr[j] < arr[j - gap]) {
// 插入排序采用交换法
swap(arr, j, j - gap);
j -= gap;
}
System.out.println("2 gap:" + gap + " i:" + i + " arr:" + IntArrtoString(arr));
}
}
System.out.println("ShellSort2 end...........");
}
/**
* 希尔排序 针对有序序列在插入时采用移动法。
*
* @param arr
*/
public static void ShellSort3(int[] arr) {
// 增量gap，并逐步缩小增量
for (int gap = arr.length / 2; gap > 0; gap /= 2) {
// 从第gap个元素，逐个对其所在组进行直接插入排序操作
for (int i = gap; i < arr.length; i++) {
int j = i;
int temp = arr[j];
if (arr[j] < arr[j - gap]) {
while (j - gap >= 0 && temp < arr[j - gap]) {
// 移动法
arr[j] = arr[j - gap];
j -= gap;
}
arr[j] = temp;
}
}
}
}
/**
* 交换数组元素
*
* @param arr
* @param a
* @param b
*/
public static void swap(int[] arr, int a, int b) {
arr[a] = arr[a] + arr[b];
arr[b] = arr[a] - arr[b];
arr[a] = arr[a] - arr[b];
}
/**
* @param arr
* @description 快速排序 基本思想：（分治） 先从数列中取出一个数作为key值；
* 将比这个数小的数全部放在它的左边，大于或等于它的数全部放在它的右边； 对左右两个小数列重复第二步，直至各区间只有1个数。
* @ses http://developer.51cto.com/art/201403/430986.htm
* https://blog.csdn.net/morewindows/article/details/6684558
*/
// 快速排序
public int[] QuickSort(int[] a, int l, int r) {
if (l < r) {
int i = l, j = r, v = a[l];// i:左边开始活动坐标，j:右边开始活动坐标，v：基数，用于对比的值，一般取第一个
while (i < j) {// 只要左边游标和游标不重叠的话那么就继续遍历
System.out.println("i:" + i + " j:" + j + " arr:" + IntArrtoString(a));
// 每一轮遍历的时候只进行一轮，把右边的一个比基数小的数移动到左边，把左边比基数大的数移动到右边
while (i < j && a[j] > v)
// 找出右边比左边小的坐标
j--;
if (i < j)
a[i++] = a[j];// 进行移动，左边坐标移动一个数
System.out.println("i:" + i + " j:" + j + " arr:" + IntArrtoString(a));
while (i < j && a[i] < v)
// 找出左边比右边大的坐标
i++;
if (i < j)
a[j--] = a[i];// 进行移动，右边坐标移动一个数
System.out.println("i:" + i + " j:" + j + " arr:" + IntArrtoString(a));
}
a[i] = v;// 当游标重叠时填入基数
this.QuickSort(a, l, i - 1);
this.QuickSort(a, i + 1, r);
return a;
}
return a;
}
/**
* @param a
* @param left
* @param right
* @return QuickSort2在一轮对比基准数的过程中不移动基准数,减少移动次数
*/
public int[] QuickSort2(int[] a, int left, int right) {
//校验要初始化变量之前;不校验易报错:java.lang.ArrayIndexOutOfBoundsException
if (left>right ) {
return a;
}
int i = left, j = right, s = a[left];
int temp;
while (i < j) {
//System.out.println("1--------i:" + i + " j:" + j + " arr:" + IntArrtoString(a));
while (a[j] >= s && j > i) {
j--;
//System.out.println("2--------i:" + i + " j:" + j + " arr:" + IntArrtoString(a));
}
while (a[i] <= s && j > i) {
i++;
//System.out.println("3--------i:" + i + " j:" + j + " arr:" + IntArrtoString(a));
}
if (i < j) {
temp = a[j];
a[j] = a[i];
a[i] = temp;
//System.out.println("4---------i:" + i + " j:" + j + " arr:" + IntArrtoString(a));
}
}
a[left] = a[i];
a[i] = s;
QuickSort2(a, left, i - 1);
QuickSort2(a, i + 1, right);
return a;
}
}