目录
冒泡排序
假定采取从小到大的排列方式，具体步骤思路如下图（标红的数字为确定的值）：
假设原数组有四个元素。
在第一轮排序中，指针1指向第0个元素，指针2指向第1个元素，当指针2指向的元素小于指针1指向的元素时，两者交换位置。接着两者分别向后移动一位，直到指针2指向最后一个元素，因此可以确定一个最大值。
第二轮，将指针1指向第1个元素，指针2指向后一个元素，同上方进行比较。可以确定第二大的值。第三轮同理，可以确定第三大的值。
冒泡排序（从小到大排序）可以概括为：前一个元素与后一个元素比较大小，如果前一个元素的值大于后一个值，则两者交换位置，从大到小排序则取反。
完整代码
public class BubbleSort {
public static void main(String[] args) {
int[] arr = {45, 15, 7, 6};
System.out.println("排列前的结果为:" + Arrays.toString(arr));
bubbleSort(arr);
System.out.println("排列后的结果为:" + Arrays.toString(arr));
}
//冒泡排序
public static void bubbleSort(int[] arr){
//临时变量，保存数据
int temp = 0;
//总共排序的轮数为 arr.length - 1
for (int i = 0; i < arr.length - 1; i++) {
//每轮的比较次数为 arr.length - i - 1
for (int j = 0; j < arr.length - i - 1; j++) {
//比较大小，如果前一个元素比后一个元素大，则两者交换位置
//从大到小排序可以将 > 修改成 <
if (arr[j] > arr[j + 1]){
temp = arr[j];
//交换位置
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
//如果经过一轮比较，temp没有变化，那么代表数组已经有序
if (temp == 0){
break;
}
}
}
}
结果
排列前的结果为:[45, 15, 7, 6]
排列后的结果为:[6, 7, 15, 45]选择排序
假定采取从小到大的排列方式，具体步骤思路如下图（标红的数字为交换的数字）：
假设原数组有四个元素
第一轮，先假定第一个元素为最小的数min，指针1指向该元素，指针2指向下一个元素，将指针2指向的元素与min进行比较，当指针2指向的元素比min小时，min更改为指针2指向的值，并记录该下标，将指针2向后移动一位，同上过程，当指针2指向最后一个元素并比较后，即可得到最小值及其下标，最后跟指针1指向的元素交换位置。第一轮完成后，即可确认值最小的元素。
第二轮，假定第二个元素为除第一个数外最小的数min，指针1指向该元素，指针2指向下一个元素，同上原理进行比较。第二轮完成后，即可确认除第一个元素外值最小的元素。
第三轮，假定第三个元素为除第一、二个元素外最小的数min，同上原理进行比较。即可确定除第一、二个数外值最小的元素。
选择排序（从小到大排序）可以概括为：依次从第一个元素开始，假定该元素为最小的元素，分别与后面的元素进行比较，记录值最小的元素及其下标，最后与先前的假定元素进行交换。从大到小则取反。
完整代码
public class SelectSort {
public static void main(String[] args) {
int[] arr = {8, 15, 7, 6};
System.out.println("排列前的结果为:" + Arrays.toString(arr));
selectSort(arr);
System.out.println("排列后的结果为:" + Arrays.toString(arr));
}
public static void selectSort(int[] arr){
//记录最小值
int min = 0;
//记录最小值的下标
int minIndex = 0;
//总共比较 arr.length - 1 轮
for (int i = 0; i < arr.length - 1; i++) {
//当 i = 0 时，假定第一个元素为最小值。
//当 i = 1 时，假定第二个元素为除前一个元素外的最小值，后面同理
min = arr[i];
//记录下标
minIndex = i;
// 分别和下标为i的后面元素进行比较
for (int j = i + 1; j < arr.length; j++) {
if (arr[j] < min){
//改变min
min = arr[j];
minIndex = j;
}
//如果minIndex值改变，表示假定元素非最小值，即可进行交换元素
//如果minIndex没有改变，无需交换
if (minIndex != i){
//两者交换位置
arr[minIndex] = arr[i];
arr[i] = min;
}
}
}
}
}
结果
排列前的结果为:[8, 15, 7, 6]
排列后的结果为:[6, 7, 8, 15]插入排序
假定采取从小到大的排列方式，具体步骤思路如下图（标红的数字为插入的数字）：
假设原数组有四个元素
第一轮，将指针1指向的及其前面的元素看成一个有序表，指针2指向的及其后面的元素看成一个无序表，第一轮从无序表中取出第一个元素，与有序表中的元素的值进行比较，即可确定该元素在有序表中的位置。
第二轮，将指针1和指针2向后移动一位，同上进行比较排序，第三轮同理。最后完成排序。
插入排序可以概括为：将n个待排序的数组看成一个有1个元素的有序数组和一个有n-1个元素的无序数组，依次从无序数组中取出元素选择合适的位置插入有序数组。
完整代码及源码
public class InsertSort {
public static void main(String[] args) {
int[] arr = {8, 15, 7, 6};
System.out.println("排列前的结果为:" + Arrays.toString(arr));
insertSort(arr);
System.out.println("排列后的结果为:" + Arrays.toString(arr));
System.out.println("===========================");
int[] arr2 = {8, 15, 7, 6};
System.out.println("排列前的结果为:" + Arrays.toString(arr2));
insertSort2(arr2);
System.out.println("源码方式排列后的结果为:" + Arrays.toString(arr2));
}
//插入排序
public static void insertSort(int[] arr){
int insertVal = 0;
int insertIndex = 0;
for (int i = 1; i < arr.length; i++) {
//需要确定位置的值
insertVal = arr[i];
//有序表最后一个元素的下标
insertIndex = i - 1;
//从小到大排序，如果 arr[insertIndex] > insertVal
//表示当前为 insertIndex 下标的有序列表中元素的值大于需要确定位置的值，
//因此该位置非需要确定位置的值的位置，insertIndex向前移
while (insertIndex >= 0 && arr[insertIndex] > insertVal){
//将有序列表中最后一个元素向后移动
arr[insertIndex + 1] = arr[insertIndex];
insertIndex--;
}
// 如果 insertIndex 没有变化表示此轮已经有序，无需进行插入操作
if (insertIndex != i - 1) {
arr[insertIndex + 1] = insertVal;
}
}
}
/* 源码:
for (int i = left, j = i; i < right; j = ++i) {
int ai = a[i + 1];
while (ai < a[j]) {
a[j + 1] = a[j];
if (j-- == left) {
break;
}
}
a[j + 1] = ai;
}
*/
//使用gdk8源码中的插入排序方法
public static void insertSort2(int[] arr){
//最后一个元素的下标
int right = arr.length - 1;
for (int i = 0, j = i; i < right; j = ++i) {
//保存需要排序的元素
int arri = arr[i + 1];
//需要排序的元素和前一个元素进行比较
//当arri >= arr[j]，找到位置
while (arri < arr[j]){
arr[j + 1] = arr[j];
//未找到位置j向前移
if (j-- == 0){
break;
}
}
arr[j + 1] = arri;
}
}
}结果
排列前的结果为:[8, 15, 7, 6]
排列后的结果为:[6, 7, 8, 15]
===========================
排列前的结果为:[8, 15, 7, 6]
源码方式排列后的结果为:[6, 7, 8, 15]希尔排序
上方插入排序可以看出，当原数组采取从小到大的排列方式，并且最小值在数组最右侧的时候，插入排序需要经过多次循环才能找到该元素位置，当数组元素很多时，极大降低了排序的效率，这时可以采用希尔排序，具体步骤思路如下图：
假设原数组有四个元素
第一轮， 将数组分为 length / 2 组，每组有两个元素，按照插入排序方式，如果数组最后为最小值，即可以较大程度将最小值插入到数组前段。
第二轮，将数组分为 length / 2 / 2 组，每组有一个元素，按照插入排序方式，即无需大量移动操作便可完成数组排序。
完整代码
public class ShellSort {
public static void main(String[] args) {
int[] arr = {8, 15, 7, 6};
System.out.println("排列前的结果为:" + Arrays.toString(arr));
shellSort(arr);
System.out.println("排列后的结果为:" + Arrays.toString(arr));
}
//移位法
public static void shellSort(int[] arr){
int insertVal = 0;
int insertIndex = 0;
//进行分组
for (int step = arr.length / 2; step > 0; step /= 2) {
for (int i = step; i < arr.length; i++) {
//保存需要插入的值
insertVal = arr[i];
//保存下标
insertIndex = i;
//如果前step个元素比该元素大，则进行插入操作
while (insertIndex >= step && insertVal < arr[insertIndex - step]){
//下标为 insertIndex - step 的元素向前移动step
arr[insertIndex] = arr[insertIndex - step];
// insertIndex 向前移动 step
insertIndex -= step;
}
if (insertIndex != i) {
arr[insertIndex] = insertVal;
}
}
}
}
}结果
排列前的结果为:[8, 15, 7, 6]
排列后的结果为:[6, 7, 8, 15]还在学习中，有问题辛苦指出。
285
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
