冒泡排序
第一个元素开始向第二个元素比较，若大于则交换位置，不大于则不动。然后第二个元素和第三个元素比较，再然后第三个元素和第四个元素比较…一直比到最后一个元素。这一趟下来，就把最大的元素放到了最后。
然后又从第一个元素开始，开始第二趟…然后开始第三趟…一直走完最后一趟。
package com.serein.sort;
import java.util.Arrays;
/**
* @author baichuan
* @version 1.0
*/
public class BubbleSort {
public static void main(String[] args) {
// int[] arr = {3,10,5,7,-1};
int[] arr = new int[80000];
for (int i = 0; i < 80000; i++) {
arr[i] = (int) (Math.random()*800000);
}
long millisStart = System.currentTimeMillis();
bubble(arr);
long millisEnd = System.currentTimeMillis();
System.out.println("一共耗时：" + (millisEnd - millisStart)/1000 + " 秒");
//把排序结果打印出来看看
System.out.println(Arrays.toString(arr));
}
private static void bubble(int[] arr){
int temp = 0;
boolean flag = false;
//这样的排序一共执行 arr.length - 1次
for (int j = 0;j < arr.length - 1;j++) {
//因为后面的元素已经确定是更大的数，遍历的时候没必要再走过去判断画蛇添足
for (int i = 0; i < arr.length - 1 - j; i++) {
//若前面的数字比后面的大，交换大小
if (arr[i] > arr[i + 1]){
flag = true;
temp = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = temp;
}
}
//如果若前面的数字比后面的小，那就不必再判，退出当前循环
if (!flag){
break;
}else {
flag = false;
}
}
}
}
测试截图
选择排序
先定义一个索引，把它指向第一个元素。让第一个元素和第二个比较。若第二个小，就把索引指向第二个元素；若不是，索引不动。然后把索引指向的元素和第三个元素比较，更新索引位置。然后和第四个元素比较…以此类推，一直比到最后一个元素，然后把索引指向的元素和第一个元素换位置。这一趟下来就把最小的元素放到了最前面。
然后就从第二个元素开始重复上述步骤，这一趟下来把第二小的元素放到了第二个位置…以此类推，直到最后一个元素。
和冒泡排序相比，一趟下来，冒泡排序每一步都在交换位置；而选择排序一趟只换了一次位置。
package com.serein.sort;
import java.util.Arrays;
/**
* @author baichuan
* @version 1.0
*/
public class SelectSort {
public static void main(String[] args) {
// int[] arr = {50,999,6,3};
int[] arr = new int[80000];
for (int i = 0; i < 80000; i++) {
arr[i] = (int) (Math.random()*800000);
}
long millisStart = System.currentTimeMillis();
select(arr);
long millisEnd = System.currentTimeMillis();
System.out.println("一共耗时：" + (millisEnd - millisStart)/1000.00 + " 秒");
System.out.println(Arrays.toString(arr));
}
public static void select(int[] arr) {
int minIndex = 0;//单签最小值的索引
int min = arr[0];//当前最小值，先假定第一个元素使最小的，然后执行逻辑判断
boolean flag = false;
for (int j = 0; j < arr.length - 1; j++) {
minIndex = j;
min = arr[j];
//先完成一轮操作，找规律，然后在外面嵌套一层for循环帮我们做事
for (int i = j + 1; i < arr.length; i++) {
if (min > arr[i]) {
flag = true;
min = arr[i];
minIndex = i;
}
}
//把最小值放到arr[j],即交换。最开始就是arr[0],即第一个位置，第二次for循环是就是第二个位置
//以此类推，以j为分界线，每次都找出当前最小的放到分界线末尾，一直把分界线推到数组最后
if (!flag) {
//如果min 没有大于arr[i]，那就不用再交换位置了，退出本次循环
break;
}else {
flag = false;
}
arr[minIndex] = arr[j];
arr[j] = min;
}
}
}
插入排序
把一个数组视为有序列表和无序列表两部分。
初始来说，有序列表就是数组的第一个元素，后面的所有元素是无序列表，待插入元素就是数组第二个元素。我们要做的就是把无序列表的数一个一个放到有序列表里。
走一轮，把第二个元素放入有序列表并比大小，有序列表就有两个元素了。后面的所有元素是无序列表，待插入元素就是数组第三个元素，以此类推
我们站在待插入元素的位置上看待问题，核心就是给待插入元素找位置。
package com.serein.sort;
import java.util.Arrays;
/**
* @author baichuan
* @version 1.0
*/
public class InsertSort {
public static void main(String[] args) {
// int[] arr = {66,4,5,1};
int[] arr = new int[80000];
for (int i = 0; i < 80000; i++) {
arr[i] = (int) (Math.random()*800000);
}
long millisStart = System.currentTimeMillis();
insert(arr);
long millisEnd = System.currentTimeMillis();
System.out.println("一共耗时：" + (millisEnd - millisStart)/1000.00 + " 秒");
System.out.println(Arrays.toString(arr));
}
//初始来说，有序列表就是数组的第一个元素，后面的所有元素是无序列表，待插入元素就是数组第二个元素
//走一轮，有序列表就有两个元素了，后面的所有元素是无序列表，待插入元素就是数组第三个元素，以此类推
//我们站在待插入元素的位置上看待问题，核心就是给待插入元素找位置
private static void insert(int[] arr){
int insertIndex = 0;//待插入元素的索引
int insertValue = 0;//把待插入元素的值
for (int i = 1; i < arr.length; i++) {
insertIndex = i- 1;//待插入元素的默认索引为，加到序列表的最后面
insertValue = arr[i];//把待插入元素的值保存起来
//先和有序列表的第一个元素比较，如果不行就往后比较
while(insertIndex >= 0 && insertValue < arr[insertIndex]){
//如果待插入元素的值比原有序列表的最后一个元素要小，就把有序列表（有序列表是定义在心中的）扩容一位，
//并且把这个元素的值赋给新增的位置（说明：我们只定义了一个数组，这时
//有序列表和无序列表是此消彼长的零和博弈，我们要的就是此消彼长。）
arr[insertIndex + 1] = arr[insertIndex];
//第一次插入元素上述流程只走一遍的话即可，到后面索引还要往前拨，
//判断待插入元素比有序列表倒数第二个元素的大小...然后再判断和倒数第三个元素的大小，以此类推
//一个待插入元素第二次及以上找位置时，复制元素就不是和无序列表抢位置的
//此消彼长了，而是有序列表的内斗。无序列表不受影响。
insertIndex--;
}
//退出while循环，说明找到了位置，我们把待插入元素的值赋给该索引。
arr[insertIndex + 1] = insertValue;
}
}
}
测试截图
希尔排序
在插入排序的基础上，先按步长先分组调位置，使得在插入排序前在宏观上大致有序，提高了插入排序的效率。步长逐步缩小，叫做缩小增量。
package com.serein.sort;
import java.util.Arrays;
/**
* @author baichuan
* @version 1.0
*/
public class ShellSort {
public static void main(String[] args) {
// int[] arr = {8,9,1,7,2,3,5,4,6,0};
int[] arr = new int[80000];
for (int i = 0; i < 80000; i++) {
arr[i] = (int) (Math.random()*800000);
}
long millisStart = System.currentTimeMillis();
// shell(arr);
shell2(arr);
long millisEnd = System.currentTimeMillis();
System.out.println("一共耗时：" + (millisEnd - millisStart) + " 毫秒");
System.out.println("希尔牛皮！！！");
System.out.println(Arrays.toString(arr));
}
private static void shell(int[] arr){
int temp = 0;//交换元素需要的临时变量，定义在循环外面可节省开销
//gap是步长，初始化为数组长度的一半，每次循环都让步长减半。减到1组的时候循环会结束
for (int gap = arr.length / 2;gap > 0;gap /= 2){
//分出有多少组步长
for (int i = gap; i < arr.length; i++) {
//走一次就是判断一组步长，因为i的变化会使得走完所有组
for (int j = i - gap; j >= 0 ; j -= gap){
//若前面的数大于步长后面的数，则位置互换
if (arr[j] > arr[j + gap]){
temp = arr[j];
arr[j] = arr[j + gap];
arr[j + gap] = temp;
}
}
}
}
}
//上面那个是交换式希尔排序，由于交换次数较多，所以耗时也比较久。
//以下采用移位式希尔排序
//对比
private static void shell2(int[] arr){
for (int gap = arr.length / 2; gap > 0; gap /= 2){
//分出有多少组步长
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]){//上面的if判断似乎多余，这里就起到了判断一组步长前后元素大小的作用
arr[j] = arr[j - gap];
//让j指向前面的数
j -= gap;
}
//把原始后面那个数赋给步长前面那个数
arr[j] = temp;
// }
}
}
}
}
1693
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
