冒泡排序：
总体思路：对未排序的各个元素，依次比较两个元素，如果这两个元素为逆序（与想要的顺序相反），则交换这两个元素。
这样可以有两种排序的思路：
思路一：
固定位置排序：比如有一个未排序队列，下标依次为0,1,2，.....N-1，
第一轮排序：首先固定位置0，将下标为0的元素依次和下标为1、下标为2、....下标为N-1的元素相比较，若相比较的两个元素为逆序，则交换这两个元素，这样第一轮排序完之后，位置为0的元素，就是最大的（最小的）。
第二轮排序：首先固定位置1，将下标为1的元素依次和下标为2、下标为3、....下标为N-1的元素相比较，若相比较的两个元素为逆序，则交换这两个元素，这样第二轮排序完之后，位置为1的元素，就是第二大的（第二小的）。
...
第i轮排序(i<N-1)：首先固定位置i，将下标为i的元素依次和下标为i+1、下标为i+2、....下标为N-1的元素相比较，若相比较的两个元素为逆序，则交换这两个元素，这样第i轮排序完之后，位置为i的元素，就是第i+1大的（第i+1小的）。
第N-1轮排序：首先固定位置N-2，将下标为N-2的元素和下标为N-1的元素相比较，若相比较的两个元素为逆序，则交换这两个元素，这样第N-1轮排序完之后，位置为N-2的元素，就是第N-1大的（第N-1小的）。
这样经过N-1轮排序之后，各个位置的元素都是已经排好序了的。
固定位置排序代码演示如下：
import java.util.Arrays; public class BubboleSort { public static void main(String[] args) { BubboleSort bs = new BubboleSort(); int[] array = {2,5,1,3,9,8,0,4,6}; System.out.println(Arrays.toString(array)); bs.bubbleSort(array); System.out.println(Arrays.toString(array)); } public void bubbleSort(int[] array){ //外层取出一个用来比较的位置，当位置i确定之后，内层循环进行完之后，该位置的元素就确定了 for (int i = 0; i < array.length; i++) { //内层循环依次取出需要进行比较的数据 for (int j = i+1; j < array.length; j++) { if (array[i] > array[j]) { swap(array,i,j); } } } } //交换数组中位置i和位置j的元素 public void swap(int[] array,int i,int j){ array[i] = array[i]^array[j]; array[j] = array[i]^array[j]; array[i] = array[i]^array[j]; } }
控制台输出：
[2, 5, 1, 3, 9, 8, 0, 4, 6]
[0, 1, 2, 3, 4, 5, 6, 8, 9]
思路二：
相邻元素比较：将相邻的两个元素依次进行比较，如果这两个元素逆序，则进行交换。比如有一个未排序队列，下标依次为0,1,2，.....N-1，
第一轮排序：
将下标为0的元素和下标为1的元素进行比较，若逆序，则交换；
再将下标为1的元素和下标为2的元素进行比较，若逆序，则交换；
再将下标为2的元素和下标为3的元素进行比较，若逆序，则交换；
...
将下标为i（i<N-2）的元素和下标为i+1的元素进行比较，若逆序，则交换；
最后将下标为N-2的元素和下标为N-1的元素进行比较，若逆序，则交换。
这样，经过第一轮排序之后，最大（最小）的元素，就排在最后面了（下标为N-1），即队列最后的元素是排好序的，下一轮排序不用再排序了。
第二轮排序：
将下标为0的元素和下标为1的元素进行比较，若逆序，则交换；
再将下标为1的元素和下标为2的元素进行比较，若逆序，则交换；
再将下标为2的元素和下标为3的元素进行比较，若逆序，则交换；
...
将下标为i（i<N-3）的元素和下标为i+1的元素进行比较，若逆序，则交换；
最后将下标为N-3的元素和下标为N-2的元素进行比较，若逆序，则交换。
这样，经过第二轮排序之后，最二大（最二小）的元素，就排在最后面了（下标为N-2），即下标为N-2的元素是排好序的，下一轮排序不用再排序了。
重复上面的排序思路即可将剩余的元素全部排好顺序。
代码演示如下：
import java.util.Arrays; public class BubboleSort { public static void main(String[] args) { BubboleSort bs = new BubboleSort(); int[] array = {2,5,1,3,9,8,0,4,6}; System.out.println(Arrays.toString(array)); bs.bubbleSort(array); System.out.println(Arrays.toString(array)); } //相邻元素进行比较排序 public void bubbleSort(int[] array){ //i用来控制比较的次数 for (int i = array.length -1; i > 0 ; i--) { //内层循环完成之后，表示一轮冒泡完成 for (int j = 0; j < i; j++) { if (array[j] > array[j+1]) { swap(array,j,j+1); } } } } //交换数组中位置i和位置j的元素 public void swap(int[] array,int i,int j){ array[i] = array[i]^array[j]; array[j] = array[i]^array[j]; array[i] = array[i]^array[j]; } }
控制台输出：
[2, 5, 1, 3, 9, 8, 0, 4, 6]
[0, 1, 2, 3, 4, 5, 6, 8, 9]
冒泡排序性能：比较和交换的次数为 O(n2)
选择排序：
假设有一个待排序的数组array,下标依次为0,1,2,3,....N-1
第一轮排序：从所有元素中选择一个最小（最大）值array[i],放在array[0]位置（即让array[i]与array[0]交换）。
第二轮排序：从array[1]开始，找出一个最小（最大）值array[j],放在array[1]位置。
...
N个数，要进行N-1轮排序。
下面是代码演示：
import java.util.Arrays; public class SelectSort { public static void main(String[] args) { SelectSort ss = new SelectSort(); int[] array = {2,5,1,3,9,8,0,4,6}; System.out.println(Arrays.toString(array)); ss.selectSort(array); System.out.println(Arrays.toString(array)); } public void selectSort(int[] array){ for (int i = 0; i < array.length; i++) { int minIndex = i; for (int j = i+1; j < array.length; j++) { //只记录位置，暂时不交换 if (array[minIndex] > array[j]) { minIndex = j; } } //经过内层循环之后，找到了该轮外层循环的位置i的要交换的最小值的位置minIndex,交换，若i== minIndex,说明位置i所在的元素，就是该轮比较的最小值了，所以不用交换了 if (i != minIndex) { swap(array,i,minIndex); } } } public void swap(int[] array,int i,int j){ array[i] = array[i]^array[j]; array[j] = array[i]^array[j]; array[i] = array[i]^array[j]; } }
控制台输出：
[2, 5, 1, 3, 9, 8, 0, 4, 6]
[0, 1, 2, 3, 4, 5, 6, 8, 9]
选择排序效率：比较次数为O(n²)，交换的次数为O(n)
插入法排序：
基本思路：（设数组为升序） 每拿到一个元素，都要将这个元素依次与它之前的元素进行比较，若前面的元素比该元素大，则将前面的元素往后移动；直到前面的元素（设下标为i）比该元素小，则下标为i+1,就是该元素要插入的位置，插入即可
代码演示如下：
package com.lewis.sort.simpleSort; import java.util.Arrays; public class InsertSort { public static void main(String[] args) { InsertSort is = new InsertSort(); int[] array = {2, 5, 1, 3, 0,9,-1, 8, 7, 4, 6}; System.out.println(Arrays.toString(array)); is.sort(array); System.out.println(Arrays.toString(array)); } /** * 插入法排序：通过构建有序数列，将未排序的元素，从后往前依次比较，进而找到要插入的位置并插入 * @param array */ public void sort(int[] array){ int j = 0; //假设数组中的第一个元素是已经排好序的 //外层循环 表示待排序的元素 for (int i = 1; i < array.length; i++) { //待排序的元素tmpData,要找到一个合适的位置插入 int tmpData = array[i]; //内层循环从待排序元素tmpData开始，依次往前扫描 for (j = i; j > 0 ; j--) { //将待排序元素tmpData依次和前面的元素比较， 若前面的元素比待排序的元素tmpData大，则将前面的元素依次往后移动 if (array[j - 1] > tmpData) { array[j] = array[j-1]; } else{ //说明前面已经是排好顺序了 break; } } //内层循环结束之后，位置j就是待排序元素要插入的位置 array[j] = tmpData; } } }
控制台输出：
[2, 5, 1, 3, 0, 9, -1, 8, 7, 4, 6]
[-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
插入法排序效率：比较和交换次数都为 O(n²)，但是比冒泡算法大约快一倍左右，比选择排序稍快，尤其是部分数据局部有序的情况下，插入法排序效率会更高