算法的六种常见排序

1 . 冒泡排序（ Bubble Sort )

在遍历数组时判断 当前位置的 数组大小（a[ j ]）是否比下一位（a[ j + 1 ]）大，如果是，则将

a[ j ] 与 a[ j + 1 ]数值交换，即把大的数往后放，就像是冒泡一样，大的数一直后移，直到数组有序。

在此进行了优化，添加了flag判断本次循环是否进行了交换，如未进行交换则说明排序完毕，跳出循环，减少了可能出现的已经排好序但循环没有结束，继续运行的情况；

当前数组 ：6    1    5    3    4

内循环第一遍                   1    6    5    3    4

内循环第一遍                   1    5    6    3    4

内循环第一遍                   1    5    3    4    6

下一次内循环

内循环第一遍                   1    3    5    4    6

内循环第二遍                   1    3    4    5    6

内循环第三遍                   1    3    4    5    6

此时未进行交换，flag = 0，跳出循环，无需再进行下一次内循环

冒泡排序的时间复杂度是O(n^2)的

import java.util.Scanner;

public class BubbleSort {
    public static void main(String[] args) {
        int n;
        Scanner scanner = new Scanner(System.in);
        n = scanner.nextInt();
        int[] a = new int[n];
        for (int i = 0; i < n; i++) {
            a[i] = scanner.nextInt();
        }
        bubble(a, n);
    }

    public static void bubble(int[] a, int n) {
        int x;
        int flag = 0;//这句可以不写
        x = a[0];
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (a[j] >a[j  + 1]) {
                    flag++;
                    x = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = x;
                }
            }
            if (flag == 0) {//可以不写
                break;
            } else
                flag = 0;
        }
        for (int i = 0; i < n; i++) {
            System.out.print(a[i] + " ");
        }
    }
}

2 . 插入排序 ( Insert Sort )

插入排序运用到了链表，将数据存储在链表中，我在写的时候先在头节点后插入了两个节点，这算是一个bug，不能输入两个以下的数。

在输入时，遍历链表，将新建的链表节点按顺序插入链表中：

此时链表中数值：1     2    5    6    9

新输入的值：3

遍历链表，找到第一个大于三的数，在这个数之前插入新的节点：

1    2    3    5    6    9

插入完毕

如果遍历结束没有找到比输入数值大的节点，则将新建的节点插入链表末尾

import javax.xml.soap.Node;
import java.util.*;

public class InsertSort {
    public static void main(String[]