- 冒泡排序
- 插入排序
- 快速排序
- 选择排序
- 希尔排序
1冒泡排序
1.1 原理
每轮循环 多次两两比较选出一个最大的排在最后面
1.2 原码
/**
* Description TODO 冒泡排序
* Author Cloudr
* Date 2020/4/1 22:43
**/
public class BubbleSort {
private static void bubbleSorts(int[] a) {
int i, j, temp;
for (i = 0; i < a.length - 1; i++) { //每轮都是把最大的数排到最后 注意是 a.length-1 因为下文有一个j+1
for (j = 0; j < a.length - 1 - i; j++) { //每次需要排的个数减少i个
if (a[j] > a[j + 1]) {
temp = a[j + 1];
a[j + 1] = a[j];
a[j] = temp;
}
}
}
}
public static void main(String[] args) {
int[] a = {1, 253, 56, 745, 342, 41, 654, 321432, 131, 324};
bubbleSorts(a);
for (int i : a) {
System.out.println(i);
}
}
}
1.3 复杂度
* 时间复杂度
2直接插入排序
2.1 原理
直接插入排序是将未排序的数据插入至已排好序序列的合适位置。
具体流程如下：
1、首先比较数组的前两个数据，并排序；
2、比较第三个元素与前两个排好序的数据，并将第三个元素放入适当的位置；
3、比较第四个元素与前三个排好序的数据，并将第四个元素放入适当的位置；
......
4、直至把最后一个元素放入适当的位置。
2.2 代码
public class insertSort {
private static void insertSort(int[] a) {
int Temp;
for (int i = 1; i < a.length; i++) { //注意是从i=1开始的
Temp = a[i]; //必须要用Temp 否则移动过程中会改变a[i]的值
int j;
for (j = i - 1; j >= 0; j--) { //从已经排好的序列中的末尾（即最大的开始比较），即是从0~i-1与a[j]比较
if (a[j] > Temp)
a[j + 1] = a[j];
else {
a[j + 1] = Temp; //因为之前j--了一次
break;
}
}
}
}
public static void main(String[] args) {
int[] a = {1, 2, 4, 623, 1, 132, 634, 2, 3, 4};
insertSort(a);
for (int i : a) {
System.out.println(i);
}
}
}
3快速排序
3.1原理简述
- 找一个基准数，将大于这个基准数的数放在右边，小于它的放在其左边
3.2源代码
public class QuickSort {
private static void quickSort(int[] a, int left, int right) {
// 将a分成一边大的，一边小的，重复执行这个过程
if (left < right) {
int index = getIndex(a, left, right);
quickSort(a, left, index - 1);
quickSort(a, index + 1, right);
}
}
private static int getIndex(int[] a, int left, int right) {
int standard = a[left]; // 基准数据
while (left < right) {
while (left < right && a[right] >= standard) { //必须要 >= 不然 =等于那个得不到处理 left也指不到这边
right--; // 当队尾的元素大于等于基准数据时,向前挪动high指针
}
a[left] = a[right]; //将小于基准数据的值放到左边（小的一边）
while (left < right && a[left] <= standard) {
left++;
}
a[right] = a[left]; //将大于基准数据的值放到右边（大的一边）
}
a[left] = standard; //此时left==right 同时这个位置也是standard的位置
return left;
}
public static void main(String[] args) {
int[] a = {1, 2, 4, 2, 21, 563, 1, 6246, 13, 4331};
quickSort(a, 0, a.length - 1);
for (int i : a) {
System.out.println(i);
}
}
}
4选择排序
4.1原理简述：
首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
- 
4.2源代码
public class SelectSort {
private static void select(int[] a) {
for (int i = 0; i < a.length; ++i) {
int index = i;
for (int j = i + 1; j < a.length; j++) {
if (a[index] > a[j]) {
index = j; // 找到当前循环中最小的数的索引
}
}
int temp = a[index];
a[index] = a[i];
a[i] = temp;
}
}
public static void main(String[] args) {
int[] a = {2, 1, 63, 2, 12, 7, 3, 12, 78, 6, 43};
select(a);
for (int i : a) {
System.out.println(i);
}
}
}
5希尔排序
5.1原理简述
希尔排序是把记录按下表的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。
5.2源代码
public class ShellSort {
private static void shell(int[] a) {
int gap = a.length / 2; //增量，每隔gap为一组
while (gap >= 1) {
for (int i = gap; i < a.length; i++) { //依次遍历每一组 i=gap是因为后面的j-gap才有意义
int j = i;
while (j - gap >= 0 && a[j] < a[j - gap]) { //遍历每一组 如何发现后面的小于前面的则交换
int temp = a[j]; //这里不采用每次给j+gap是因为 会有gap个a[j]遍历不到 换种方法也会比较麻烦
a[j] = a[j - gap];
a[j - gap] = temp;
j = j - gap;
}
}
gap = gap / 2;
}
}
public static void main(String[] args) {
int[] a = {3, 2, 5, 7, 43, 12, 15, 33, 15, 2, 12, 14, 3};
shell(a);
for (int i : a) {
System.out.println(i);
}
}
}