简单排序-选择排序、直接插入排序、冒泡排序

 简单排序（选择排序、直接插入排序、冒泡排序）算法都是n^2量级的比较（n是元素个数）

 

---

 选择排序动态图：

 1 package com.inbreak.cnblogs.sort;
 2 
 3 /**
 4  * 选择排序：
 5  * 如果有N个元素需要排序，那么首先从N个元素中找到最小的那个(称为第0小的)放在第0个位子上(和原来的第0个位子上的元素交换位置)，
 6  * 然后再从剩下的N-1个元素中找到最小的放在第1个位子上，然后再从剩下的N-2个元素中找到最小的放在第2个位子上……直到所有的元素都就位。
 7  *
 8  * @author inbreak
 9  * @create 2018-07-10
10  **/
11 
12 import com.inbreak.cnblogs.Helper;
13 
14 public class SelectionSort {
15 
16     public static void main(int a[], int len) {
17         Helper.printArray(a);
18         for (int i = 0; i < len - 1; i++) {
19             //保存第i次的值
20             int tmpMin = i;
21             //后面j~len（最后一项）
22             for (int j = i+1; j < len ; j++) {
23                 if(a[j] <  a[tmpMin]) {
24                     tmpMin = j;
25                 }
26             }
27             if (i == tmpMin) {
28                 //当前位置已经是最小值
29                 continue;
30             }
31             //找到j~len中最小的位置tmpMin,然后与当前的位置i交换
32             Helper.swap(a, i, tmpMin);
33         }
34 
35         Helper.printArray(a);
36     }
37 
38 }

 

---

 

直接插入排序动态图：

 

 1 package com.inbreak.cnblogs.sort;
 2 
 3 import com.inbreak.cnblogs.Helper;
 4 
 5 /**
 6  * 直接插入排序 的思想：
 7  * 1.将整个数组分为 "有序" 和 "无序" 两个部分，有序部分在左边，无序部分在右边。
 8  * 2.初始时 只有第一个元素a[0]时有序的，其余为无序部分。
 9  * 3.取出从无序部分的第一个值插入到有序部分的合适位置p [如第一个无序部分就是a[1]与a[0]比较，找到a[1]应该放的位置p（可能是第0位，第1位）],
10  *     而后有序部分位置p以及p之后的元素都往后移一位。
11  * 4.直到无序部分没有元素为止。
12  *
13  * @author inbreak
14  * @create 2018-07-10
15  */
16 public class InsertionSort {
17 
18     public static void main(int a[], int size) {
19         Helper.printArray(a);
20         //i循环是对无序部分的便利
21         for (int i = 1; i < size; i++) {
22             int tmp = a[i];
23             //j循环是对有序部分
24             for (int j = 0; j < i; j++) {
25                 if(tmp < a[j]) {
26                     //k循环是对有序部分的数组移动
27                     for (int k = i; k > j; k--) {
28                         a[k] = a[k-1];
29                     }
30                     //找到i要插入的位置
31                     a[j] = tmp;
32                     break;
33                 }
34             }
35         }
36         Helper.printArray(a);
37     }
38 }

---

 

冒泡排序动态图：

 

 1 package com.inbreak.cnblogs.sort;
 2 
 3 import com.inbreak.cnblogs.Helper;
 4 
 5 /**
 6  * 冒泡排序：
 7  * 将整个数组a 分为有序部分和无序部分的两个部分，无序在上面，有序在下面。（感觉垂直方向形象点）
 8  * 开始时，整个数组时无序的，有序部分没有元素。
 9  * 每趟使得无序部分的最大元素移动到有序部分的最上面的元素的上边
10  *
11  * @author inbreak
12  * @create 2018-07-10
13  */
14 public class BubbleSort {
15 
16     public static void main(int[] a, int size) {
17         Helper.printArray(a);
18         //i循环是一共需要多少趟，倒叙计算
19         for (int i = size - 1; i > 0; i--) {
20             //j循环是对无序部分的数组元素两两比较交换
21             for (int j = 0; j < i; j++) {
22                 if (a[j] > a[j+1]) {
23                     Helper.swap(a, j, j+1);
24                 }
25             }
26 
27         }
28         Helper.printArray(a);
29     }
30 
31     public static void main2(int[] a, int size) {
32         Helper.printArray(a);
33         //i循环是一共需要多少趟，正序计算
34         for (int i = 0; i < size; i++) {
35             //j循环是对无序部分的数组元素两两比较交换
36             for (int j = 0; j < size -i-1; j++) {
37                 if (a[j] > a[j+1]) {
38                     Helper.swap(a, j, j+1);
39                 }
40             }
41 
42         }
43         Helper.printArray(a);
44     }
45 }