1.直接插入排序:
原理:
整个区间被分为 1. 有序区间;
2. 无序区间 每次选择无序区间的第一个元素,在有序区间内选择合适的位置插入。
代码如下
//直接插入排序
public static void insertSort(int[] array){
for(int i = 1; i < array.length; i++){
int j = i-1;
int tmp = array[i];
for(; j >= 0; j--){
if(array[j] > tmp){
array[j+1] = array[j];
}else{
break;
}
}
array[j+1] = tmp;
}
}
2.希尔排序:
原理:
希尔排序法又称缩小增量法。希尔排序法的基本思想是:先选定一个整数,把待排序文件中所有记录分成个组,所有距离为的记录分在同一组内,并对每一组内的记录进行排序。然后重复上述分组和排序的工作。当到达=1时,所有记录在统一组内排序。
- 希尔排序是对直接插入排序的优化。
- 当gap > 1时都是预排序,目的是让数组更接近于有序。gap == 1时,数组已经接近有序的了,这样就会很快。这样整体而言,可以达到优化的效果。我们实现后可以进行性能测试的对比。
代码如下:
//希尔排序
public static void sellSort(int[] array){
int[] arr = {5,3,1};
for(int i = 0; i < arr.length; i++){
sell(array,arr[i]);
}
}
public static void sell(int[] array, int gap){
for(int i = gap; i < array.length; i++){
int tmp = array[i];
int j = i-gap;
for(; j >= 0; j -= gap){
if(array[j] > tmp ){
array[j+gap] = array[j];
}else{
break;
}
}
array[j+gap] = tmp;
}
}
3.直接选择排序:
原理:
每一次从无序区间选出最大(或最小)的一个元素,存放在无序区间的最后(或最前),直到全部待排序的数据元素排完 。
//直接选择排序
public static void selectSort(int[] array){
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;
}
}
}
}
4.冒泡排序:
原理:
无序区间,通过相邻数的比较,将最大的数冒泡到无序区间的最后,持续这个过程,直到数组整体有序。
代码如下:
//冒泡排序
public static void bubbleSort(int[] array){
for(int i = 0; i < array.length-1; i++){
boolean flag = true;
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;
flag = false;
}
}
if(flag){
break;
}
}
}
5.快速排序:
原理:(分治思想)
- 从待排序区间选择一个数,作为基准值(pivot);
- Partition: 遍历整个待排序区间,将比基准值小的(可以包含相等的)放到基准值的左边,将比基准值大的(可以包含相等的)放到基准值的右边;
- 采用分治思想,对左右两个小区间按照同样的方式处理,直到小区间的长度 为1,代表已经有序,或者小区间的长度 为 0,代表没有数据。
代码如下:
//快排(可优化)(分治思想)
public static void quickSort(int[] array, int low, int high){
if(low < high){ // if(low > high)return;
int piv = pivot(array,low,high);
quickSort(array,low,piv-1);
quickSort(array,piv+1,high);
}
}
public static int pivot(int[] array, int start, int end){
int tmp =arr[start];
while(start < end ){
while(start < end && arr[end] >= tmp ){
end--;
}
arr[start] = arr[end];
while(start < end && arr[start] <= tmp){
start++;
}
arr[end] = arr[start];
}
arr[start] = tmp;
return start;
}
非递归代码如下:
//快排--》非递归
public static void quickSortNor(int[] array){
Stack<Integer> stack = new Stack<>();
int low = 0;
int high = array.length-1;
int piv = pivot(array,low,high);
if(piv > low + 1) {
stack.push(low);
stack.push(piv-1);
}
if(piv < high-1) {
stack.push(piv+1);
stack.push(high);
}
while (!stack.empty()) {
high = stack.pop();
low = stack.pop();
piv = pivot(array, low, high);//
if (piv > low + 1) {
stack.push(low);
stack.push(piv - 1);
}
if (piv < high - 1) {
stack.push(piv + 1);
stack.push(high);
}
}
}
6.归并排序:
原理:
归并排序(MERGE-SORT)是建立在归并操作上的一种有效的排序算法,该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使子序列段间有序。若将两个有序表合并成一个有序表,称为二路归并。
代码如下:
//归并排序
public static void mergeSort(int[] array,int low,int high){
if(low >= high){
return;
}
int mid = (low+high)/2;// =(low+high)>>>1; 无符号右移;
mergeSort(array,low,mid);
mergeSort(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[] ret = new int[high-low+1];
int i = 0;
while(s1 <= mid && s2 <= high){
if(array[s1] <= array[s2]){
ret[i++] = array[s1++];
}else{
ret[i++] = array[s2++];
}
}
while(s1 <= mid){
ret[i++] = array[s1++];
}
while(s2 <= high){
ret[i++] = array[s2++];
}
for(int j = 0; j < ret.length; j++){
array[j+low] = ret[j];
}
}
非递归代码如下:
//非递归归并排序
public static void mergeSortNor(int[] array) {
for (int i = 1; i < array.length; i*=2) {
merge(array,i);
}
}
public static void merge(int[] array,int gap) {
int s1 = 0;
int e1 = s1+gap-1;
int s2 = e1+1;
int e2 = s2+gap-1 < array.length ? s2+gap-1 : array.length-1;
int[] tmp = new int[array.length];
int k = 0;//下标
//当有两个归并段的时候
while (s2 < array.length) {
//当有两个归并段 且 这两个段内都要数据
while (s1 <= e1 && s2<= e2) {
if(array[s1] <= array[s2]) {
tmp[k++] = array[s1++];
}else{
tmp[k++] = array[s2++];
}
}
while (s1 <= e1) {
tmp[k++] = array[s1++];
}
while (s2 <= e2){
tmp[k++] = array[s2++];
}
//从这里开始的时候,每个下标都可能越界
s1 = e2+1;//
e1 = s1+gap-1;
s2 = e1+1;
e2 = s2+gap-1 < array.length ? s2+gap-1 : array.length-1;
}
//退出上面循环后,
// 那么把s1段内的数据给拷贝下来,因为 有可能e1已经越界了
while (s1 < array.length) {
tmp[k++] = array[s1++];
}
for (int i = 0; i < tmp.length; i++) {
array[i] = tmp[i];
}
}
7.堆排:
原理:
基本原理也是选择排序,只是不在使用遍历的方式查找无序区间的最大的数,而是通过堆来选择无序区间的最大的数。
注意: 排升序要建大堆;排降序要建小堆。
代码如下:
//堆排
public static void heapSort(int[] array){
creatHeap(array);
for(int i = 0; i < array.length-1; i++){
int tmp = array[0];
array[0] = array[array.length-1-i];
array[array.length-1-i] = tmp;
adjustDown(array,array.length-1-i,0);
}
}
public static void creatHeap(int[] array){
for(int i = (array.length-1-1)/2; i >=0; i--){
adjustDown(array,array.length,i);
}
}
public static void adjustDown(int[] array,int len, int parent){
int child = 2*parent+1;
while(child < len){
if(child+1 < len && array[child+1] > array[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;
}
}
}
性能分析:
排序方法 | 最好 | 平均 | 最坏 | 空间复杂度 | 稳定性 |
---|---|---|---|---|---|
冒泡排序 | 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^2) | O(log(n))~O(n) | 不稳定 |
堆排序 | O(n*log(n)) | O(n*log(n)) | O(n*log(n)) | O(1) | 不稳定 |
归并排序 | O(n*log(n)) | O(n*log(n)) | O(n*log(n)) | O(n) | 稳定 |