常见的五种排序算法

1.选择排序

具体算法描述如下：

1.找到数组中最小的那个元素

2.将它和数组的第一个元素交换位置(如果第一个元素就是最小元素那么它就 和自己交换)

3.在剩下的元素中找到最小的元素，将它与数组的第二个元素交换位置

4.如此往复，直到将整个数组排序

动图演示：

代码实现：

	public static void SelectSort(int[] arr){
		for(int i=0;i<arr.length-1;i++){
			int min = i;//选择待排序数列中最小数的下标
			for(int j=i+1;j<arr.length-1;j++){
				if(arr[min]>arr[j]){
					min = j;
				}
			}
			if(min!=i){
				int temp = arr[i];
				arr[i] = arr[min];
				arr[min] = temp;
			}
		}
	}

2.插入排序

具体算法描述如下：

1.从第一个元素开始，该元素可以认为已经被排序

2.取出下一个元素，在已经排序的元素序列中从后向前扫描

3.如果该元素（已排序）大于新元素，将该元素移到下一位置

4.重复步骤 3，直到找到已排序的元素小于或者等于新元素的位置
将新元素插入到该位置后

5.重复步骤 2 ~ 5，直至最后一个元素。

动图演示：

代码实现：

public class InsertSort {
    private static void insertSort(int[] arr) {
      int j; // 已排序列表下标
      int t; // 待排序元素
      for (int i = 1; i < arr.length; i++) {
        if (arr[i] < arr[i - 1]) {
          t = arr[i]; // 赋值给待排序元素
          for (j = i - 1; j >= 0 && arr[j] > t; j--) {
            arr[j + 1] = arr[j]; // 从后往前遍历已排序列表，逐个和待排序元素比较，如果已排序元素较大，则将它后移
          }
          arr[j + 1] = t; // 将待排序元素插入到正确的位置
        }
      }
    }

3.冒泡排序

具体算法描述如下：

1.比较相邻的元素。如果第一个比第二个大，就交换他们两个。

2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

3.针对所有的元素重复以上的步骤，除了最后一个。

4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

动图演示：

代码实现：

public class BubbleSort {
    public static void sort(int[] arr) {
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = 0; j < arr.length - i - 1; j++) {
                //如果当前元素比后一位元素大 交换位置
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }

代码优化

假如从开始的第一对到结尾的最后一对，相邻的元素之间都没有发生交换的操作，这意味着右边的元素总是大于等于左边的元素，此时的数组已经是有序的了，我们无需再对剩余的元素重复比较下去了。

public class BubbleSort {
    public static int[] bubbleSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return arr;
        }
        int n = arr.length;
        for (int i = 0; i < n; i++) {
            boolean flag = true;
            for (int j = 0; j < n -i - 1; j++) {
                if (arr[j + 1] < arr[j]) {
                    flag = false;
                    int t = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = t;
                }
            }
            //一趟下来是否发生位置交换
            if(flag)
                break;
        }
        return arr;
    }
}

4.归并排序

具体算法描述如下：

1.申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列

2.设定两个指针，最初位置分别为两个已经排序序列的起始位置

3.比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置

4.重复步骤 3 直到某一指针到达序列尾

5.将另一序列剩下的所有元素直接复制到合并序列尾

动图演示：

代码实现：

public static void mergeSort(int[] arrays, int left, int right) {
    // 如果数组还可以拆分
    if (left < right) {
        //数组的中间位置
        int middle = (left + right) / 2;
        //拆分左边数组
        mergeSort(arrays, left, middle);
        //拆分右边数组
        mergeSort(arrays, middle + 1, right);
        //合并
        merge(arrays, left, middle, right);
    }
}


/**
 * 合并数组
 */
public static void merge(int[] arr, int left, int middle, int right) {
    //申请合并空间 大小为两个已经排序序列之和
    int[] temp = new int[right - left + 1];
    //i 和 j为两个已经排好序的数组的起始位置
    int i = left;
    int j = middle + 1;
    int k = 0;
    //排序
    while (i <= middle && j <= right) {
        //将比较小的数组放入合并空间
        if (arr[i] < arr[j]) {
            temp[k++] = arr[i++];
        } else {
            temp[k++] = arr[j++];
        }
    }
    //将左边剩余元素写入合并空间
    while (i <= middle) {
        temp[k++] = arr[i++];
    }
    //将右边剩余的元素写入合并空间
    while (j <= right) {
        temp[k++] = arr[j++];
    }
    //将排序后的数组写回原来的数组
    for (int l = 0; l < temp.length; l++) {
        arr[l + left] = temp[l];
    }

}

非递归式的归并排序

public class MergeSort {
    // 非递归式的归并排序
    public static int[] mergeSort(int[] arr) {
        int n = arr.length;
        // 子数组的大小分别为1，2，4，8...
        // 刚开始合并的数组大小是1，接着是2，接着4....
        for (int i = 1; i < n; i += i) {
            //进行数组进行划分
            int left = 0;
            int mid = left + i - 1;
            int right = mid + i;
            //进行合并，对数组大小为 i 的数组进行两两合并
            while (right < n) {
                // 合并函数和递归式的合并函数一样
                merge(arr, left, mid, right);
                left = right + 1;
                mid = left + i - 1;
                right = mid + i;
            }
            // 还有一些被遗漏的数组没合并，千万别忘了
            // 因为不可能每个字数组的大小都刚好为 i
            if (left < n && mid < n) {
                merge(arr, left, mid, n - 1);
            }
        }
        return arr;
    }
}

5.快速排序

具体算法描述如下：

1.从数列中挑出一个元素，称为“基准”（pivot），

2.重新排序数列，所有比基准值小的元素摆放在基准前面，所有比基准值大的元素摆在基准后面（相同的数可以到任何一边）。在这个分割结束之后，该基准就处于数列的中间位置。这个称为分割（partition）操作。

3.递归地把小于基准值元素的子数列和大于基准值元素的子数列排序。

递归到最底部时，数列的大小是零或一，也就是已经排序好了。这个算法一定会结束，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。

动图演示：

代码实现：

public static void sort(int[] arr, int head, int tail) {
   if (head >= tail || arr == null || arr.length <= 1) {
       return;
   }
   //设置数组的起始位置 i 结束位置j 基准 pivot 为数组的中间
   int i = head, j = tail, pivot = arr[(head + tail) / 2];
   while (i <= j) {
       //当数组小于基准 循环结束后 相当于i所处的位置的值为大于基准的元素
       while (arr[i] < pivot) {
           ++i;
       }
       //当数组大于基准 循环结束后 相当于j所处的位置的值为小于于基准的元素
       while (arr[j] > pivot) {
           --j;
       }
       //如果i<j 那么则将交互i j对应位置的值
       if (i < j) {
           int t = arr[i];
           arr[i] = arr[j];
           arr[j] = t;
           //将指针继续移动
           ++i;
           --j;
       } else if (i == j) {
		//如果i=j 那么说明本次排序已经结束 将i++ 如果这里不使用i++ ,
		//那么后面的sort(arr,i,tail)将改为arr(arr,i+1,tail)
           ++i;
       }
   }
   //继续将数组分割
   sort(arr, head, j);
   sort(arr, i, tail);
}