排序概念
排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。
平时的上下文中，如果提到排序，通常指的是排升序（非降序）。
通常意义上的排序，都是指的原地排序(in place sort)。
稳定性
如果当前这个排序，在排序的过程中，没有发生跳跃式的交换，那么就是稳定的排序。
排序分类
插入排序
直接插入排序
import java.lang.reflect.Array;
import java.util.Arrays;
/**
* 时间复杂度：最坏无序情况下o(n^2)，最好情况下o(n)
* 越有序越快 而且直接插入排序也会用到一些排序的优化上
* 空间复杂度O(1)
*/
public class insertSort {
public static void main(String[] args) {
int[] array = {10, 3, 2, 7, 19, 78, 65, 127};
for (int i =1;i<array.length;i++) {//遍历数组
int tmp = array[i];
int j = i - 1;
for (; j >= 0; j--) {//遍历i前面所有的值
//如果这里是一个大于等于号就不稳定了
if (array[j] >tmp){
array[j+1] =array[j];
}else{
break;
}
}
array[j+1] = tmp;//跳出循环
}
System.out.println(Arrays.toString(array));
}
}
希尔排序
希尔排序法又称缩小增量法。希尔排序法的基本思想是：先选定一个整数，把待排序文件中所有记录分成个组，所有
距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工作。当到达=1时，
所有记录在统一组内排好序。
- 希尔排序是对直接插入排序的优化。
- 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很
快。这样整体而言，可以达到优化的效果
代码`
import java.util.Arrays;
public class shellSort {
public static void shell(int[] array ,int gap){
for (int i = gap;i <array.length;i++){
int tmp = array[i];
int j = i - gap;
for (;j >= 0;j = j -gap){
if (array[j] > tmp){
array[j + gap] = array[j];
}else{
break;
}
}
array[j+gap] = tmp;
}
}
public static void main(String[] args) {
int[] array = {10, 3, 2, 7, 19, 78, 65, 127};
int[] drr = {5,3,1};
for (int i = 0; i < drr.length; i++){
shell(array,drr[i]);
}
System.out.println(Arrays.toString(array));
}
}
选择排序
选择排序
思路
每一次从无序区间选出最大（或最小）的一个元素，存放在无序区间的最后（或最前），直到全部待排序的数据元素
排完 。
代码
import java.lang.reflect.Array;
import java.util.Arrays;
/**
* 选择排序
* 时间复杂度o(n^2)
*/
public class selectSort {
public static void main(String[] args) {
int[] array = {10, 3, 2, 7, 19, 78, 65, 127};
for (int i = 0; i < array.length - 1; i++) {
for (int j = i+1 ; j < array.length ; j++) {
if (array[j] < array[i]){
int tmp = array[i];
array[i] = array[j];
array[j] = tmp;
}
}
}
System.out.println(Arrays.toString(array));
}
}
堆排序
堆的详细实现可见博客：java -堆的实现及Top-k问题及第k 小的问题
import java.util.Arrays;
public class heapSort {
public static void adjustDown(int[] array,int parent,int len){
int child = 2*parent+1;
while (child < len){
if (child +1 <len && array[child] <array[child+1]){
child++;
}
//child下标一定是孩子最大值
if(array[child] > array[parent]){
int tmp = array[child];
array[child] = array[parent];
array[parent] = tmp;
parent =child;
child = 2*parent+1;
}else {
break;
}
}
}
//时间复杂度nlogn
public static void createBigHeap(int[] array){
for(int i = (array.length-1-1)/2;i>=0;i--){
adjustDown(array,i,array.length);
}
}
/**
* 时间复杂度：不管是做好还是最坏都是o(nlogn)
* 空间复杂度：o(1)
* @param array
*/
public static void headSort(int[] array){
createBigHeap(array);
int end = array.length-1;
while(end > 0){
int tmp = array[0];
array[0] = array[end];
array[end] = tmp;
adjustDown(array,0,end);
end--;
}
}
public static void main(String[] args) {
int[] array = {10, 3, 2, 7, 19, 78, 65, 127};
headSort(array);
System.out.println(Arrays.toString(array));
}
}
交换排序
冒泡排序
描述
在无序区间，通过相邻数的比较，将最大的数冒泡到无序区间的最后，持续这个过程，直到数组整体有序
稳定性：稳定
代码
import java.util.Arrays;
/**
时间复杂度：o(n^2)
**/
public class bubbleSort {
public static void main(String[] args) {
int[] array = {10, 3, 2, 7, 19, 78, 65, 127};
for (int i = 0;i <array.length; i++){
for (int j = 0; j < array.length-i-1;j++){
if (array[j] > array[j+1]){
int tmp = array[j];
array[j] = array[j+1];
array[j+1] = tmp;
}
}
}
System.out.println(Arrays.toString(array));
}
}
快速排序
核心思想
- 从待排序区间选择一个数，作为基准值(pivot)；
- Partition: 遍历整个待排序区间，将比基准值小的（可以包含相等的）放到基准值的左边，将比基准值大的（可
以包含相等的）放到基准值的右边；- 采用分治思想，对左右两个小区间按照同样的方式处理，直到小区间的长度 == 1，代表已经有序，或者小区间的长度 == 0，代表没有数据。
补充
时间复杂度：最好情况o(nlogn)（递归的时间复杂度 = 递归的次数*当前遍历的次数） 最坏情况o(n^2)(有序情况下）
空间复杂度o(log n)
稳定性: 不稳定
分治思想什么时候效率最高：待排序序列均匀划分
代码
import java.util.Arrays;
public class quickSort {
public static int pivot(int[] array,int start, int end){
int tmp = array[start];
while (start < end){
while (start < end && array[end] >= tmp){
end--;
}
array[start] = array[end];
while (start < end && array[end] <= tmp){
start++;
}
array[end] = array[start];
}
array[start] = tmp;
return start;
}
public static void quick(int[] array ,int low ,int high){
if (low < high){
int piv = pivot(array, low, high);
quick(array, low, piv-1);
quick(array,piv+1,high);
}
}
public static void main(String[] args) {
int[] array = {10, 3, 2, 7, 19, 78, 65, 127};
quick(array, 0,array.length-1);
System.out.println(Arrays.toString(array));
}
}
快排的优化：三叔取中法。
归并排序
原理：
归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and
Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
import java.util.Arrays;
public class mergeSort {
/**
* 稳定性：稳定的排序
* 时间复杂度：O(nlogn)
* 空间复杂度：O(n)
* @param array
* @param low
* @param high
*/
public static void mergeSortInternal(int[] array,int low,int high){
if (low >= high) return;;
int mid = (low +high)/2;
mergeSortInternal(array,low,mid);
mergeSortInternal(array,mid+1,high);
//合并的操作
merge(array,low,mid,high);
}
public static void merge(int[] array,int low,int mid,int high){
int s1 = low;
int s2 = mid+1;
int[] tmp = new int[high -low +1];
int k = 0;
while(s1 <= mid && s2<=high){
if(array[s1] <= array[s2]){
tmp[k++] = array[s1++];
}else{
tmp[k++] = array[s2++];
}
}
while(s1 <= mid){
tmp[k++] = array[s1++];
}
while (s2 <= high){
tmp[k++] = array[s2++];
}
for (int i = 0;i < tmp.length;i++){
array[i +low] = tmp[i];
}
}
public static void main(String[] args) {
int[] array = {10, 3, 2, 7, 19, 78, 65, 127};
mergeSortInternal(array,0,array.length-1);
System.out.println(Arrays.toString(array));
}
}
海量数据的排序问题
外部排序：排序过程需要在磁盘等外部存储进行的排序
前提： 内存只有 1G，需要排序的数据有 100G
因为内存中因为无法把所有数据全部放下，所以需要外部排序，而归并排序是最常用的外部排序
- 先把文件切分成 200 份，每个 512 M
- 分别对 512 M 排序，因为内存已经可以放的下，所以任意排序方式都可以3. 进行 200 路归并，同时对 200 份有序文件做归并过程，最终结果就有序了
284
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
