1、冒泡排序（时间复杂度——O（n^2））
public class BubbleSort {
public static void main(String[] args) {
int[] array = randomArray(10, 20);
System.out.println(Arrays.toString(array));
int[] sort = bubbleSort(array);
System.out.println(Arrays.toString(sort));
}
public static int[] randomArray(int size, int range) {
int[] array = new int[size];
Random random = new Random();
for (int i = 0; i < array.length; i++) {
array[i] = random.nextInt(range);
}
return array;
}
public static int[] bubbleSort(int[] array) {
//拷贝数组
int[] copyArray = Arrays.copyOf(array, array.length);
int length = copyArray.length, temp, count;
//每趟排序，将最大的数排在后面
for (int i = 0; i < length - 1; i++) {
//重置count
count = 0;
for (int j = 0; j < length - 1 - i; j++) {
//如果前面的数比后面的数大，则交换
if (copyArray[j] > copyArray[j + 1]) {
temp = copyArray[j];
copyArray[j] = copyArray[j + 1];
copyArray[j + 1] = temp;
count++;
}
}
//如果该循环交换次数只有等于0的情况下则不用再排了
if (count == 0) {
break;
}
}
return copyArray;
}
}
采用8万个数据测试冒泡排序的性能
public static void main(String[] args) {
long start, end;
int[] array = randomArray(80000, 80000);
start = System.currentTimeMillis();
int[] sort = bubbleSort(array);
end = System.currentTimeMillis();
System.out.println("耗时:" + (end - start));
}
多次测试平均10秒左右
2、选择排序（时间复杂度——O（n^2））
public class SelectSort {
public static void main(String[] args) {
int[] array = randomArray(10, 20);
int[] sort = selectSort(array);
System.out.println(Arrays.toString(array));
System.out.println(Arrays.toString(sort));
}
public static int[] randomArray(int size, int range) {
int[] array = new int[size];
Random random = new Random();
for (int i = 0; i < array.length; i++) {
array[i] = random.nextInt(range);
}
return array;
}
public static int[] selectSort(int[] array){
int[] copyArray = Arrays.copyOf(array, array.length);
int length = copyArray.length, min, minIndex = 0;
for (int i = 0; i < length-1; i++) {
//每次假定第一个数是最小的
min = copyArray[i];
minIndex = i;
for (int j = i + 1; j < length; j++) {
//比较，重置最小值
if(copyArray[j]<min){ //如果按从大到小排序只需修改成大于号
min = copyArray[j];
minIndex = j;
}
}
//判断最小值是否仍是第一个数，避免不必要的交换
if(minIndex!=i){
//交换最小值和第一个数
copyArray[minIndex] = copyArray[i];
copyArray[i] = min;
}
}
return copyArray;
}
}
采用8万个数据测试选择排序的性能
public static void main(String[] args) {
long start, end;
int[] array = randomArray(80000, 80000);
start = System.currentTimeMillis();
int[] sort = selectSort(array);
end = System.currentTimeMillis();
System.out.println("耗时:" + (end - start));
}
多次测试平均3秒左右
3、插入排序 （时间复杂度——O（n^2））
写代码时，前一个元素进行后移的体现是，将前一个元素覆盖后一个元素（插入值已经被存起来）
public class InsertSort {
public static void main(String[] args) {
int[] array = randomArray(10, 20);
System.out.println(Arrays.toString(array));
int[] sort = insertSort(array);
System.out.println(Arrays.toString(sort));
}
public static int[] randomArray(int size, int range) {
int[] array = new int[size];
Random random = new Random();
for (int i = 0; i < array.length; i++) {
array[i] = random.nextInt(range);
}
return array;
}
public static int[] insertSort(int[] array) {
int[] copyArray = Arrays.copyOf(array, array.length);
int length = copyArray.length, insertVal, insertIndex;
for (int i = 0; i < length - 1; i++) {
insertIndex = i; //保存插入值的前一个进行比较的元素的下标
insertVal = copyArray[i + 1]; //保存插入数据的值
/*
如果插入值小于前一个元素，则让前一个元素覆盖掉插入元素的位置；往前比较的同时也要注意数组下标的越界问题insertIndex >= 0。以此类推。
如果插入值大于前一个元素，则不用进行操作。
*/
while (insertIndex >= 0 && insertVal < copyArray[insertIndex]) {
copyArray[insertIndex + 1] = copyArray[insertIndex];
insertIndex--;
}
/*
判断是否要替换元素。
两种情况：
第一种：插入值大于前一个元素，即插入原来的位置
第二种：插入值小于前一个元素，while循环中最后insertIndex每次都自减一次，所以这里必须加一才可以正确表示插入位置
*/
if (i + 1 != insertIndex + 1) {
copyArray[insertIndex + 1] = insertVal;
}
}
return copyArray;
}
}
采用8万个数据测试插入排序的性能
public static void main(String[] args) {
long start, end;
int[] array = randomArray(80000, 80000);
start = System.currentTimeMillis();
int[] sort = insertSort(array);
end = System.currentTimeMillis();
System.out.println("耗时:" + (end - start));
}
多次测试平均0.6秒左右
4、希尔排序（分组式的插入排序）（时间复杂度——O（nlogn）
简单概括：
通过步长gap分多个组，每个组进行插入排序。随着gap不断缩小，插入排序最后面向整个数组
注意：
但代码中体现的是同时对所有分组进行插入排序，而不是一个个分组按顺序来操作。它是交叉操作的
public class HillSort {
public static void main(String[] args) {
int[] array = randomArray(10, 20);
int[] sort = hillSort(array);
System.out.println(Arrays.toString(array));
System.out.println(Arrays.toString(sort));
}
public static int[] randomArray(int size, int range) {
int[] array = new int[size];
Random random = new Random();
for (int i = 0; i < array.length; i++) {
array[i] = random.nextInt(range);
}
return array;
}
public static int[] hillSort(int[] array) {
//拷贝数组
int[] copyArray = Arrays.copyOf(array, array.length);
int length = copyArray.length, temp, insertIndex, insertVal;
for (int gap = length/2; gap > 0; gap/=2) {
for (int i = gap; i < length; i++) {
insertIndex = i;
insertVal = copyArray[i];
while (insertIndex-gap>=0&&insertVal<copyArray[insertIndex-gap]){
copyArray[insertIndex] = copyArray[insertIndex-gap];
insertIndex-=gap;
}
if(insertIndex!=i){
copyArray[insertIndex] = insertVal;
}
}
}
return copyArray;
}
}
采用8万个数据测试希尔排序的性能
public static void main(String[] args) {
long start, end;
int[] array = randomArray(80000, 80000);
start = System.currentTimeMillis();
int[] sort = insertSort(array);
end = System.currentTimeMillis();
System.out.println("耗时:" + (end - start));
}
多次测试平均0.018秒左右
采用8百万个数据测试希尔排序的性能
多次测试平均3秒左右
5、快速排序 （时间复杂度——O（nlogn）挖坑 + 分治
最后我觉得快排的最重要思想就是根据第一个基准元素，轮流按j->i的顺序去比较，挖坑填坑，
如此循环直到 i == j
public class QuickSort {
public static void main(String[] args) {
int[] array = randomArray(10, 20);
// int[] array = {18, 12, 17, 2, 11, 8, 3, 7, 14, 2};
System.out.println(Arrays.toString(array));
int[] sort = quickSort(array, 0, array.length - 1);
System.out.println(Arrays.toString(sort));
}
public static int[] randomArray(int size, int range) {
int[] array = new int[size];
Random random = new Random();
for (int i = 0; i < array.length; i++) {
array[i] = random.nextInt(range);
}
return array;
}
public static int[] quickSort(int array[], int l, int r) {
/*
1、判断这个序列是否只有一个元素，一个元素就不用再排序了
2、防止递归传递l,r参数时造成数组越界，比如 quickSort(array, i + 1, r); 当i就是数组最后一个元素时，i+1会越界
*/
if (l < r) {
int flagVal = array[l], i = l, j = r;
//i与j相遇之时就是该分组排序结束之时
while (i < j) {
/*
进行交换
*/
while (i < j && array[j] > flagVal) {
j--;
}
if (i < j) {
array[i++] = array[j];
}
while (i < j && array[i] <= flagVal) {
i++;
}
if (i < j) {
array[j--] = array[i];
}
}
//最后把坑补上
array[i] = flagVal;
quickSort(array, l, i - 1);
quickSort(array, i + 1, r);
}
return array;
}
}
采用80000个数据测试快速排序的性能
public static void main(String[] args) {
long start, end;
int[] array = randomArray(80000, 80000);
start = System.currentTimeMillis();
int[] sort = insertSort(array);
end = System.currentTimeMillis();
System.out.println("耗时:" + (end - start));
}
多次测试平均0.022秒左右
采用8百万个数据测试快速排序的性能
多次测试平均1秒左右
6、归并排序（时间复杂度——O（nlogn）
最后一次合并两个有序数组过程
public class MergeSort {
public static void main(String []args){
int []arr = {9,8,7,6,5,4,3,2,1};
sort(arr);
System.out.println(Arrays.toString(arr));
}
public static void sort(int []arr){
int []temp = new int[arr.length];//在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
sort(arr,0,arr.length-1,temp);
}
private static void sort(int[] arr,int left,int right,int []temp){
if(left<right){
int mid = (left+right)/2;
sort(arr,left,mid,temp);//左边归并排序，使得左子序列有序
sort(arr,mid+1,right,temp);//右边归并排序，使得右子序列有序
merge(arr,left,mid,right,temp);//将两个有序子数组合并操作
}
}
private static void merge(int[] arr,int left,int mid,int right,int[] temp){
int i = left;//左序列指针
int j = mid+1;//右序列指针
int t = 0;//临时数组指针
while (i<=mid && j<=right){
if(arr[i]<=arr[j]){
temp[t++] = arr[i++];
}else {
temp[t++] = arr[j++];
}
}
while(i<=mid){//将左边剩余元素填充进temp中
temp[t++] = arr[i++];
}
while(j<=right){//将右序列剩余元素填充进temp中
temp[t++] = arr[j++];
}
t = 0;
//将temp中的元素全部拷贝到原数组中
while(left <= right){
arr[left++] = temp[t++];
}
}
}
采用80000个数据测试归并排序的性能
public static void main(String []args){
long start, end;
int[] array = randomArray(80000, 80000);
start = System.currentTimeMillis();
sort(array);
end = System.currentTimeMillis();
System.out.println("耗时:" + (end - start));
}
多次测试平均0.018秒左右
性能上是ok的（牺牲了空间换取了性能）
7、堆排序（时间复杂度——O（NlogN）
public class HeapSort {
public static void main(String[] args) throws Exception {
int[] array = randomArray(10, 20);
heap_sort(array, array.length);
System.out.println(Arrays.toString(array));
}
public static int[] randomArray(int size, int range) {
int[] array = new int[size];
Random random = new Random();
for (int i = 0; i < array.length; i++) {
array[i] = random.nextInt(range);
}
return array;
}
//交换堆顶（最大值）和最后一个节点的值，再进行大顶堆整理
public static void heap_sort(int tree[], int n) {
build_heap(tree, n);
for (int i = n - 1; i > 0; i--) {
swap(tree, i, 0);
heapify(tree, i, 0);
}
}
//构建所有父节点的大顶堆
public static void build_heap(int[] tree, int n) {
int lastIndex = n - 1;
int parent = (lastIndex - 1) / 2;
for (int i = parent; i >= 0; i--) {
heapify(tree, n, i);
}
}
/**
*构建其中一个大顶堆
* @param tree
* @param n 数组长度
* @param i 将要操作的节点下标
*/
public static void heapify(int[] tree, int n, int i) {
int c1 = i * 2 + 1;
int c2 = i * 2 + 2;
int max = i;
if (c1 < n && tree[c1] > tree[max]) {
max = c1;
}
if (c2 < n && tree[c2] > tree[max]) {
max = c2;
}
if (max != i) {
swap(tree, i, max);
heapify(tree, n, max);
}
}
private static void swap(int[] tree, int i, int max) {
int temp = tree[i];
tree[i] = tree[max];
tree[max] = temp;
}
}
采用8万个数据测试堆排序的性能
public static void main(String []args){
long start, end;
int[] array = randomArray(80000, 80000);
start = System.currentTimeMillis();
heap_sort(array, array.length);
end = System.currentTimeMillis();
System.out.println("耗时:" + (end - start));
}
多次测试平均0.018秒左右
采用8百万个数据测试堆排序的性能
多次测试平均2秒左右
8、计数排序（时间复杂度——O（N + k）
注意：
该排序只适合数据范围小，量大的数组（排序成绩、年龄是最好的）
计数排序思想简单，但要注意两个点：
1、计数数组的空间优化
2、排序后元素的稳定性
稳定意思是说原本键值一样的元素排序后相对位置不变
稳定性对于简单数据看不出差别，但对于复杂类型就有差别了，比如年龄一样的学生，但不是同一个人
public class CountSort {
public static void main(String[] args) {
int[] array = randomArray(10, 10, 20);
System.out.println(Arrays.toString(array));
//获取数组值的范围（最大值-最小值）
Map map = getMaxAndMin(array);
int[] sort = countSort(array, (Integer) map.get("min"), (Integer) map.get("max"));
System.out.println(Arrays.toString(sort));
}
public static int[] randomArray(int size, int range1, int range2) {
int[] array = new int[size];
Random random = new Random();
for (int i = 0; i < array.length; i++) {
array[i] = random.nextInt(range2 - range1 + 1) + range1; //注意，这里的元素大小是[range1, range2]
}
return array;
}
public static int[] countSort(int[] array, int range1, int range2) {
int size = range2 - range1 + 1;
int[] countArray = new int[size];
for (int i = 0; i < array.length; i++) {
countArray[array[i] - range1]++;
}
return copy(countArray, array, range1);
}
public static int[] copy(int[] countArray, int[] array, int range1) {
//新建一个和原始数组一样的数组
int[] copy = new int[array.length];
//记录每个元素出现在copy数组出现的最后位置
for (int i = 1; i < countArray.length; i++) {
countArray[i] = countArray[i] + countArray[i - 1];
}
//根据原始数组从后往前遍历，再根据countArray记录的最后出现的下标，可以保证排序的稳定性
for (int i = array.length - 1; i >= 0; i--) {
copy[--countArray[array[i] - range1]] = array[i];
}
return copy;
}
public static Map getMaxAndMin(int[] array) {
int max = array[0], min = array[0];
HashMap<String, Integer> map = new HashMap<>();
for (int i = 1; i < array.length; i++) {
if (array[i] > max) {
max = array[i];
}
if (array[i] < min) {
min = array[i];
}
}
map.put("max", max);
map.put("min", min);
return map;
}
}
采用8万个数据测试堆排序的性能
public static void main(String[] args) {
long start, end;
int[] array = randomArray(80000, 10, 20);
start = System.currentTimeMillis();
Map map = getMaxAndMin(array);
int[] sort = countSort(array, (Integer) map.get("min"), (Integer) map.get("max"));
end = System.currentTimeMillis();
System.out.println("耗时:" + (end - start));
}
多次测试平均0.005秒左右
9、基数排序（时间复杂度——O（N + k）
基数排序基本思路：
1、先计算出数组最大值的位数，作为排序的总次数
2、创建二维数组储存排序过程（二维数组使用ArrayList，可动态扩容）
3、第一次循环先排序个位，将按个位排序的结果放到二维数组中，在从二维数组中按顺序取出来，以此
类推
4、最后得到从小到大的数组
public class BasicSort {
public static void main(String[] args) throws Exception {
int[] array = randomArray(10, 20);
System.out.println(Arrays.toString(array));
//获取数组中值最大值的位数
int position = countHighestPosition(array);
basicSort(array, position);
System.out.println(Arrays.toString(array));
}
public static int[] randomArray(int size, int range) {
int[] array = new int[size];
Random random = new Random();
for (int i = 0; i < array.length; i++) {
array[i] = random.nextInt(range);
}
return array;
}
private static void basicSort(int[] array, int position) {
ArrayList<ArrayList> queue = new ArrayList<>(10);
int x;
//创建一个二维数组（二维数组适使用ArrayList,可变）
for (int i = 0; i < 10; i++) {
queue.add(new ArrayList<>());
}
//排的总次数取决于数组最大值的位数
for (int i = 0; i < position; i++) {
//先按个位->十位->百位......
for (int j = 0; j < array.length; j++) {
x = (int) (array[j]%Math.pow(10, i+1)/Math.pow(10, i));
queue.get(x).add(array[j]);
}
//将二维数组中的元素按顺序取出来放到初始数组中
int flag = 0;
for (int j = 0; j < 10; j++) {
ArrayList<Integer> q = queue.get(j);
while (q.size()>0){
array[flag++] = q.get(0);
q.remove(0);
}
}
}
}
public static int countHighestPosition(int[] array){
int max = array[0], position = 0;
for (int i = 1; i < array.length; i++) {
if(array[i]>max){
max = array[i];
}
}
while (max>0){
max /= 10;
position++;
}
return position;
}
}
采用8万个数据测试堆排序的性能
public static void main(String[] args) throws Exception {
long start, end;
int[] array = randomArray(80000, 80000);
start = System.currentTimeMillis();
//获取数组中值最大值的位数
int position = countHighestPosition(array);
basicSort(array, position);
end = System.currentTimeMillis();
System.out.println("耗时:" + (end - start));
}
多次测试平均0.226秒左右
采用8百万个数据测试堆排序的性能
很久，太久了。。。。
10、桶排序（时间复杂度——O（N * k）
桶排序的基本思路：
1、找到数组的最小值和最大值，最为该数组的区间范围
2、根据区间范围平均划分，每个区间相当于一个桶。（几个区间随意）
3、将数组元素放进区间桶内
4、对桶中的元素进行排序（采用哪种排序随你）
5、按照桶顺序输出就是从小到大的有序数组
662
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
