三类排序算法总结

插入排序

直接插入排序

import java.util.*;
//直接插入排序
public class Solution {
    public int[] MySort (int[] arr) {
        int n = arr.length;
        for(int i=1;i<n;i++){
            int temp = arr[i];
            int j = i-1;
            while(j>=0 && arr[j]>temp){
                arr[j+1] = arr[j];
                j--;
            }
            arr[j+1] = temp;
        }
        return arr;
    }
}

折半插入法排序

import java.util.*;
//折半插入法
public class Solution {
    public int[] MySort (int[] arr) {
        int n = arr.length;
        for(int i=1;i<n;i++){
            int j = i-1;
            int temp = arr[i];
            int idx = BinarySearch(arr,0,j,temp);
            while(j>=idx){
                arr[j+1] = arr[j];
                j--;
            }
            arr[idx] = temp;
        }
        return arr;
    }
    public int BinarySearch(int[] arr, int low, int high, int temp){
        if(low > high){
            return low;
        }
        int mid = (low+high)/2;
        if(arr[mid] > temp){
            return BinarySearch(arr,low,mid-1,temp);
        }else if(arr[mid] < temp){
            return BinarySearch(arr,mid+1,high,temp);
        }else{
            return mid+1;
        }
    }
}

希尔排序法

import java.util.*;
//希尔排序
public class Solution {
    public int[] MySort (int[] arr) {
        int n = arr.length;
        for(int gap=n/2; gap>0;gap/=2){  //5 2 1;遍历间隔长度
            for(int i=gap;i<n;i+=gap){   //类似直接插入排序，只是间隔长度由1->gap;
                int j = i-gap;
                int temp = arr[i];
                while(j>=0 && arr[j] > temp){
                    arr[j+gap] = arr[j];
                    j-=gap;
                }
                arr[j+gap] = temp;
            }
        }
        return arr;
    }
}

交换排序

起泡排序

import java.util.*;
//冒泡排序;每次确定最大的数值；和数组原始序列有关；最好情况O(n),最坏情况O(n^2)
public class Solution {
    public int[] MySort (int[] arr) {
        int n = arr.length;
        for(int i=n-1;i>0;i--){
            int flag = 0;
            for(int j=1;j<=i;j++){
                if(arr[j-1] > arr[j]){
                    int temp = arr[j-1];
                    arr[j-1] = arr[j];
                    arr[j] = temp;
                    flag = 1;
                }
            }
            if(flag == 0){
                break;
            }
        }
        return arr;
    }
}

快速排序

import java.util.*;
//快速排序算法
public class Solution {
    public int[] MySort (int[] arr) {
        int n = arr.length;
        QuickSort(arr,0,n-1);
        return arr;
    }
    public void QuickSort(int[] arr, int low, int high){
        //递归跳出的条件
        if(low >= high){
            return;
        }

        int temp = arr[low];
        int i = low;
        int j = high;
        while(i<j){//整个数组找完
            //从后往前找的一次
            while(j>i && arr[j]>=temp){
                j--;
            }
            if(j>i){
                arr[i] = arr[j];
                i++;
            }
            //从前往后找的一次
            while(i<j && arr[i]<temp){
                i++;
            }
            if(i<j){
                arr[j] = arr[i];
                j--;
            }
        }
        arr[i] = temp;

        //以temp下标i分开的两段调用递归
        QuickSort(arr,low,i-1);
        QuickSort(arr,i+1,high);
    }
}

选择排序

简单选择排序

import java.util.*;
//简单选择排序，从i+1-n找到最小的和i交换
public class Solution {
    public int[] MySort (int[] arr) {
        int n = arr.length;
        for(int i=0;i<n;i++){
            int minidx = i;
            for(int j=i+1;j<n;j++){
                if(arr[minidx] > arr[j]){
                    minidx = j;
                }
            }
            int temp = arr[i];
            arr[i] = arr[minidx];
            arr[minidx] = temp;
        }
        return arr;
    }
}

堆排序

import java.util.*;
//堆排序， 第一个非叶子节点 n/2-1; 左子树 i*2+1; 右子树：i*2+2;
public class Solution {
    public int[] MySort (int[] arr) {
        int n = arr.length;
        for(int i=n/2-1;i>=0;i--){
            Sift(arr,i,n-1);
        }
        for(int i=n-1;i>=1;i--){
            int temp = arr[0];
            arr[0] = arr[i];
            arr[i] = temp;
            Sift(arr,0,i-1);
        }
        return arr;
    }
    public void Sift(int[] arr, int low, int high){
        int i = low;
        int j = i * 2 + 1;
        int temp = arr[i];
        while(j <= high){
            if(j<high && arr[j] < arr[j+1]){
                j++;
            }
            if(arr[j] > temp){
                arr[i] = arr[j];
                i = j;
                j = 2*i+1;
            }else{
                break;
            }
        }
        arr[i] = temp;
    }

}