冒泡排序和选择排序

冒泡排序（Bubble sort）：

有时也称为下沉排序，是一种简单的排序算法，通过重复地遍历待排序的元素，比较每对相邻元素并且如果它们以错误的顺序排列，就交换它们。通过不断交换元素直至不需要交换，排序结束。

简单来说：每相邻的两个数比较，大的下沉，小的上浮

Ps: 假设有这样一个数组 int[] a = { a1,a2,a3,a4,a5,a6}；

1 a[0]与a[1] a[1]与a[2] a[2]与a[3] a[3]与a[4] a[4]与a[5] 得到a[5]

2 a[0]与a[1] a[1]与a[2] a[2]与a[3] a[3]与a[4] 得到a[4]

3 a[0]与a[1] a[1]与a[2] a[2]与a[3] 得到a[3]

4 a[0]与a[1] a[1]与a[2] 得到a[2]

5 a[0]与a[1] 得到a[1]

典型的for循环嵌套，一个控制行（比较的次数），一个控制列数（每次比较需要循环的次数）。为了更直观，贴图一张：By Swfung8-Own work, bubble sort GIF

代码实现：

public static void bubbleSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    swap(arr,j,j+1);
                }
            }
        }
    }

Swap方法：

private static void swap(int[] arr,int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

选择排序（Select Sort）：

该算法将列表分为两部分：已排序的子列，其从列表从左到右构建，待排序的子列占据剩余的列表。最初，排序的子列是空的，未排序的子列是整个输入列表。通过找到未排序子列中的最小（或最大，根据排序顺序）元素，与最左边的未排序元素交换（以排序顺序），并将排序好的子列边界向右移动一个元素，直至排序子列覆盖整个列表，排序结束。

64 25 12 22 11 // this is the initial, starting state of the array

11 25 12 22 64 // sorted sublist = {11}

11 12 25 22 64 // sorted sublist = {11, 12}

11 12 22 25 64 // sorted sublist = {11, 12, 22}

11 12 22 25 64 // sorted sublist = {11, 12, 22, 25}

11 12 22 25 64 // sorted sublist = {11, 12, 22, 25, 64}

简单来说：

先从数组中找出最小的排列在左侧的sorted sublist，然后在剩下的unsorted element里找出最小的元素添加到左侧的sorted sublist，好比蛇通象最终形成一个有序的数组。

为了更直观，贴图一张，By Joestape89 at the English language Wikipedia, CC BY-SA 3.0, select sort GIF

代码实现：

private static void selectSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[i] > arr[j]) {
                    swap(arr,i,j);
                }
            }
        }
    }

牵涉到算法的具体分析方面，本人还在fighting中，故不做分析。。。