直接插入排序

从第二个元素开始，前面的元素已经有序，将第二个元素插入到比自己小的元素的后面，比自己大的元素前面，这样的话，前面两个元素就是有序的，再插入第三个元素。直到插入到最后一个元素。

public void insertSort(int[] arr){
        for(int i = 1; i < arr.length; i++){
            int tmp = arr[i];
            int j;
            for(j = i - 1; j >= 0; j--){
                if(arr[j] > tmp){
                    arr[j + 1] = arr[j];
                } else {
                    arr[j + 1] = tmp;
                    break;
                }
            }
            if(j == -1){
                arr[0] = tmp;
            }
        }
    }

特点：

时间复杂度：o(n ^ 2)
空间复杂度：o(1)
稳定性：稳定

希尔排序

由于直接插入排序对于趋近于有序的排序的排序速度更快，因此希尔排序是在插入排序的基础上进行改造：先将数据分成gap组，再对这gap组元素进行插入排序，然后再减小gap的值，直到gap = 1。这样做的好处是可以更快的使无序的数据挪动到自己大致的位置上。

public void shellSort(int[] arr){
        int gap = arr.length - 1;
        while(gap >= 1){
            shell(arr,gap);
            gap /= 2;
        }
        shell(arr,1);
    }

    public void shell(int[] arr,int gap){
        for(int i = 1; i < arr.length; i++){
            int tmp = arr[i];
            int j;
            for(j = i - gap; j >= 0; j -= gap){
                if(arr[j] > tmp){
                    arr[j + gap] = arr[j];
                } else {
                    break;
                }
            }
            arr[j + gap] = tmp;
        }
    }
    private void swap(int[] arr, int i, int j){
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }

需要注意的是：
希尔排序的快慢取决于选择增量gap的好坏，比较公认的说法是当n取一系列素数时，效果最好。但是不论前面的gap如何取，最后都应该进行一次gap = 1的插入排序

特点

时间复杂度：o(n ^ 1.25) 到o(1.6 * n ^ 1.25)之间
空间复杂度: o(1)
稳定性：不稳定

选择排序

将每一次遍历的最小的元素放到起始位置，然后起始位置++

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

我们还可以对这段代码进行升级，即每次遍历不仅选择出来一个最小值，也选择出来一个最大值。但是需要注意的是，这个代码有一定的缺陷：当最大值和left重合的时候，我们的left先和min交换，倘若这时再用max和right交换，这时就把最小值交换到right了，因此写进阶版本的代码时，我们应该if判断一下是否max == left，如果相等就让max = min，这样的话在left和min交换后，min下标的值就是max，再让right和max交换就对了

public void selectSortPro(int[] arr){
        int left = 0;
        int right = arr.length - 1;
        while(left < right){
            int min = left;
            int max = left;
            for(int i = min + 1; i <= right; i++){
                if(arr[i] < arr[min]){
                    min = i;
                }
                if(arr[i] > arr[max]){
                    max = i;
                }
            }
            swap(arr,min,left);
            if(left == max){
                max = min;
            }
            swap(arr,max,right);
            left++;
            right--;
        }
    }

特点

时间复杂度：o(n ^ 2)
空间复杂度：o(1)
稳定性：不稳定

堆排序

推荐结合前面的优先级队列（堆）的blog进行阅读
当我们排升序时，我们建一个大堆，由于是大堆，因此root节点的值一定是最大值。我们将root节点的值和最后一个节点的值进行交换，这样最后一个节点的值就是有序的。然后再对root进行向下调整，使堆重新变成一个大堆。再对倒数第二个节点进行上面的操作，直到交换到root节点

public void heapSort(int[] arr){
        createBigHeap(arr);
        int end = arr.length - 1;
        while(end > 0){
            swap(arr,end,0);
            shiftDown(arr,0,end);
            end--;
        }
    }

    private void createBigHeap(int[] arr){
        for (int i = (arr.length - 2) / 2; i >= 0 ; i--) {
            shiftDown(arr,i,arr.length);
        }
    }

    private void shiftDown(int[] arr,int parent, int len){
        int child = 2 * parent + 1;
        while(child < len){
            if(child + 1 < len && arr[child] < arr[child + 1]){
                child++;
            }
            if(arr[child] > arr[parent]){
                swap(arr,child,parent);
                parent = child;
                child = 2 * parent + 1;
            } else {
                break;
            }
        }
    }

特点

时间复杂度：o(n * log n)
空间复杂度：o(1)
稳定性：不稳定

冒泡排序

在C语言blog中就有讲解，可以去参考一下
冒牌排序就是将相邻的两个元素进行比较，如果前面的元素较大就将其和后一个进行交换，这样的话第一次下来最后一个元素的值一定是最大值。我们第二趟就可以省略最后一个位置，这样倒数第二个位置也有序了，直到排到第一个位置

public void bubbleSort(int[] arr){
        for (int i = 0; i < arr.length - 1; i++) {
            boolean flg = false;
            for (int j = 0; j < arr.length - i - 1; j++) {
                if(arr[j] > arr[j + 1]){
                    swap(arr,j + 1,j);
                    flg = true;
                }
            }
            if(!flg){
                return;
            }
        }
    }

特点

时间复杂度：o (n ^ 2)
空间复杂度：o (1)
稳定性：稳定

快速排序

以任意位置为基准，将比基准小的都交换到左侧，比基准大的都交换到右侧，然后再分别递归左侧和右侧，重复上述的操作，直到所有元素都排列到相应的位置上。

public void quickSort(int[] arr){
        quick(arr, 0, arr.length - 1);
    }
    private void quick(int[] arr, int left, int right){
        if(left >= right){
            return;
        }

        int key = partitionHoare(arr,left,right);
        quick(arr,left,key - 1);
        quick(arr,key + 1,right);
    }

    private int partitionHoare(int[] arr, int left, int right){
        int key = left;
        while(left < right){
            while(right > left && arr[right] >= arr[key]){
                right--;
            }
            while(left < right && arr[left] <= arr[key]){
                left++;
            }
            swap(arr,left,right);
        }
        swap(arr,left,key);
        return left;
    }

以上代码需要注意的是，需要先走right，直到right找到比基准小的值。然后再让left走直到找到比基准大的值，然后交换left和right的值，直到left和right相遇，交换基准和left的值。
需要注意的是：
我们应该先走right，再走left，因为如果先走left的话，当left和right相遇时的坐标有可能是大于基准值的，这样的话会交换到基准值的左边来，因此右边先走，left和right相遇的时候的该坐标的值一定是小于基准值的

我们也可以通过栈来实现非递归的快速排序

public void quickSortByStack(int[] arr){
        Stack<Integer> s = new Stack<>();
        int left = 0;
        int right = arr.length - 1;
        int pivot = 0;
        s.push(left);
        s.push(right);
        while(!s.isEmpty()){
            right = s.pop();
            left = s.pop();
            pivot = partitionHoare(arr,left,right);
            if(pivot > left + 1){
                s.push(left);
                s.push(pivot - 1);
            }
            if(pivot < right - 1){
                s.push(pivot + 1);
                s.push(right);
            }
        }
    }

我们寻找基准值的方法叫做hoare法，还有以下两种方法

挖坑法

private static int partition(int[] array, int left, int right) { 
	int i = left;
	int j = right;
	int pivot = array[left];
	while (i < j) {
		while (i < j && array[j] >= pivot) {
			j--; 
		}
		array[i] = array[j];
		while (i < j && array[i] <= pivot) { 
			i++;
		}
		array[j] = array[i]; 
	}
	array[i] = pivot;
	return i;
}

前后指针法

private static int partition(int[] array, int left, int right) { 
	int d = left + 1;
	int pivot = array[left];
	for (int i = left + 1; i <= right; i++) {
		if (array[i] < pivot) { 
			swap(array, i, d); 
			d++;
		} 
	}
	swap(array, d - 1, left); 
	return d - 1;
}

特点

时间复杂度：o(n * logN)
空间复杂度：o(logN)
稳定性：不稳定

归并排序

其主要思想是分治法，通过合并两个有序的数组，从而使整个数组有序，而得到两个有序的数组的方式是将数组拆分成若干个小的碎片，直到拆分成单个元素，这样的话可以将它们自身看作是有序的数组，那么每两个小碎片就可以合并成一个有序的数组，再对合并后的小数组进行同样的操作，直到重新整合成最终的一个大的数组。

public void mergeSort(int[] arr){
   mergeSortChild(arr,0,arr.length - 1);
}
private static void mergeSortChild(int[] arr,int left, int right){
    if(left >= right){
        return;
    }
    int mid = (left + right) / 2;
    mergeSortChild(arr,left,mid);
    mergeSortChild(arr,mid + 1, right);

    merge(arr, left, right, mid);
}

private static void merge(int[] arr, int left, int right, int mid){
    int[] tmp = new int[right - left + 1];
    int s1 = left;
    int s2 = mid + 1;
    int e1 = mid;
    int e2 = right;
    int k = 0;
    while(s1 <= e1 && s2 <= e2){
        if(arr[s1] < arr[s2]){
            tmp[k] = arr[s1];
            k++;
            s1++;
        } else {
            tmp[k] = arr[s2];
            k++;
            s2++;
        }
    }
    while(s1 <= e1){
        tmp[k] = arr[s1];
        k++;
        s1++;
    }
    while(s2 <= e2){
        tmp[k] = arr[s2];
        k++;
        s2++;
    }
    for (int i = 0; i < k; i++) {
        arr[i + left] = tmp[i];
    }
}

还有一种非递归实现的方法

public void mergeSortNonRecursive(int[] arr){
   int gap = 1;
   while(gap < arr.length){
       for(int i = 0; i < arr.length; i += (gap * 2)){
           int s1 = i;
           int e1 = s1 + gap - 1;
           if(e1 >= arr.length){
               break;
           }
           int s2 = e1 + 1;
           if(s2 >= arr.length){
               s2 = arr.length - 1;
           }
           int e2 = s2 + gap - 1;
           if(e2 > arr.length){
               e2 = arr.length - 1;
           }
           merge(arr,s1,e2,e1);
       }
       gap *= 2;
   }
}

特点

时间复杂度：o(n * logN)
空间复杂度：o(n)
稳定性：稳定

一般我们对海量数据（多到需要存储在硬盘上）采取归并排序

各大排序横向对比

排序方法	最好	平均	最坏	空间复杂度	稳定性
冒泡排序	O(n)	O(n ^ 2)	O(n ^ 2)	O(1)	稳定
插入排序	O(n)	O(n ^ 2)	O(n ^ 2)	O(1)	稳定
选择排序	O(n ^ 2)	O(n ^ 2)	O(n ^ 2)	O(1)	不稳定
希尔排序	O(n)	O(n ^ 1.3)	O(n ^ 2)	O(1)	不稳定
堆排序	O(n log(n))	O(n log(n))	O(n log(n))	O(1)	不稳定
快速排序	O(n log(n))	O(n log(n))	O(n ^ 2)	O(log(n)) ~ O(n)	不稳定
归并排序	O(n log(n))	O(n log(n))	O(n log(n))	O(n)	稳定

其他非比较排序

计数排序

和哈希表类似，统计整个数组的最大值和最小值，计算所需要开辟的空间的大小，该空间需要满足能够将所有数组中的元素所对应的值全部记录，然后用这个数组的下标和原数组的每个元素的值一一对应，最后通过映射再用一个新的数组将该数组映射的原数组的值统计出来，最后将其拷贝回原数组

public void countSort(int[] arr){
   int max = arr[0];
   int min = arr[0];
   for (int i = 0; i < arr.length; i++) {
       if(arr[i] > max){
           max = arr[i];
       }
       if(arr[i] < min){
           min = arr[i];
       }
   }
   int size = arr.length;
   int[] tmp = new int[max - min + 1];
   int[] ret = new int[size];
   for (int i = 0; i < arr.length; i++) {
       tmp[arr[i] - min]++;
   }
   int i = 0,j = 0;
   while(i < tmp.length){
       if(tmp[i] > 0){
           ret[j] = i + min;
           tmp[i]--;
           j++;
       } else {
           i++;
       }
   }
   for (int k = 0; k < arr.length; k++) {
       arr[k] = ret[k];
   }
}