package com.rails;
import java.util.Arrays;
/**
* @author: noob
* @description : 冒泡排序 选择排序 插入排序(和冒泡排序有点像) 快速排序 基数排序
* @Date : 17:36 2018/04/19
*/
public class sort {
public static void main(String[] args) {
Integer[] s = {1, 6, 4, 34, 32, 45, 43, 26, 17};
s = CockTailSort(s);
System.out.print(Arrays.toString(s));
}
/// <summary>
/// 鸡尾酒排序
static Integer[] CockTailSort(Integer[] list) {
//判断是否已经排序了
Boolean isSorted = false;
//因为是双向比较,所以比较次数为原来数组的1/2次即可。
for (Integer i = 1; i <= list.length / 2; i++) {
//从前到后的排序 (升序)
/**冒泡排序的活动空间由一边向另一边主键缩小,此处的活动返回由两边向中间缩小*/
for (Integer m = i - 1; m < list.length - i; m++) {
//如果前面大于后面,则进行交换
if (list[m] > list[m + 1]) {
Integer temp = list[m];
list[m] = list[m + 1];
list[m + 1] = temp;
isSorted = true;
}
}
//从后到前的排序(降序)
for (Integer n = list.length - i - 1; n > i; n--) {
//如果前面大于后面,则进行交换
if (list[n - 1] > list[n]) {
Integer temp = list[n];
list[n] = list[n - 1];
list[n - 1] = temp;
isSorted = true;
}
}
//当不再有排序,提前退出
if (!isSorted)
System.out.println(Arrays.toString(list));
break;
}
return list;
}
public static Integer[] insert_sort(Integer array[]) {
Integer temp;
for (Integer i = 0; i < array.length - 1; i++) {
for (Integer j = i + 1; j > 0; j--) {
if (array[j] < array[j - 1]) {
temp = array[j - 1];
array[j - 1] = array[j];
array[j] = temp;
} else {
break;
}
}
}
return array;
}
/**
* 二
* 选择排序。
*/
public static Integer[] select_sort(Integer array[], Integer lenth) {
for (Integer i = 0; i < lenth - 1; i++) {
Integer minIndex = i;
for (Integer j = i + 1; j < lenth; j++) {
if (array[j] < array[minIndex]) {
minIndex = j;
}
}
if (minIndex != i) {
Integer temp = array[i];
array[i] = array[minIndex];
array[minIndex] = temp;
}
}
return array;
}
/**
* 选择排序改进
*/
public static Integer[] Bselect_sort(Integer array[]) {
for (Integer i = 0; i < array.length - 1; i++) {
Integer temp = array[i];
for (Integer j = i + 1; j < array.length; j++) {
if (array[j] < temp) {
array[i] = array[j];
array[j] = temp;
temp = array[i];
}
}
}
return array;
}
/**
* 一、
* 冒泡排序 两两比较 循环n次进行数组排序
* 优化:设置标志位判断数据是否已经排序完成。
*/
public static Integer[] BubbleSort(Integer[] arr) {
Integer temp;//临时变量
boolean flag = true;
for (Integer i = 0; i < arr.length - 1; i++) { //表示趟数,一共arr.length-1次。
flag = true;
for (Integer j = arr.length - 1; j > i; j--) {//此处使用j>i 因为第一次冒泡已经找到最小的数,并且控制不会数组越界
if (arr[j] < arr[j - 1]) {
temp = arr[j];
arr[j] = arr[j - 1];
arr[j - 1] = temp;
flag = false;
}
if (flag) {
break;
}
}
}
return arr;
}
/**
* 改造冒泡排序
*/
public static Integer[] SBubbleSort(Integer[] arr) {
Integer temp;//临时变量
for (Integer i = 0; i < arr.length - 1; i++) { //表示趟数,一共arr.length-1次。
for (Integer j = 0; j < arr.length - i - 1; j++) {//
if (i == 0) {
System.out.println(j);
}
if (arr[j] > arr[j + 1]) {
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
return arr;
}
/**
* 插入排序 将需要排序的数据一个个测插入到新的数组中
*/
static Integer[] sier_sort(Integer[] unsorted) {
Integer[] temp = new Integer[unsorted.length];
temp[0] = unsorted[0];//将第一个数据直接复制到新数组
/**控制第一个循环,从1开始,循环提取数据*/
for (Integer a = 1; a < unsorted.length; a++) {
/**将原数组中提取的数据循环 和新数组的数据比较 直到遇到比他大的数,将数据插入到新数组*/
for (Integer v = 0; v < temp.length; v++) {
if (temp[v] != null && unsorted[a] < temp[v]) {
temp = insertArray(temp, v, unsorted[a]);
break;
} else if (temp[v] == null) {
temp = insertArray(temp, v, unsorted[a]);
break;
}
}
}
return temp;
}
/**
* 希尔排序使用 将一个数插入到原数组的指定位置并且返回新的数组
*/
static Integer[] insertArray(Integer[] begin, Integer index, Integer num) {
Integer[] end = new Integer[begin.length];
if (begin.length - 1 >= index) {
for (Integer i = 0; i < end.length; i++)
if (i < index) {
end[i] = begin[i];
} else if (i == index) {
end[index] = num;
} else {
end[i] = begin[i - 1];
}
}
return end;
}
/**
* 地精排序
*/
static Integer[] gnome_sort(Integer[] unsorted) {
Integer i = 0;
while (i < unsorted.length - 1) {
if (unsorted[i] <= unsorted[i + 1]) {
i++;
} else {
Integer tmp = unsorted[i];
unsorted[i] = unsorted[i + 1];
unsorted[i + 1] = tmp;
i--;
}
}
return unsorted;
}
}
几个常见的排序算法
最新推荐文章于 2022-02-18 18:09:19 发布