小懂常见排序

1.冒泡

时间复杂度：  空间复杂度：O(1)  稳定性 :稳定

public class BubbleSort{
    public static void bubbleSort(int[] arr){
        if (arr == null || arr.length < 2) {
			return;
		}
        for(int i=arr.length-1;i>0;i--){
            for(int j=0;j<i;j++){
                if(arr[j]>arr[j+1]){
                    swap(arr,j,j+1);
                }
    
            }

        }
    }
}

逐次找出最大数放在末尾。

2.选择排序

时间： ，空间O(1)，稳定性：稳

public static void selectionSort(int[] arr){
    if (arr == null || arr.length < 2) {
        return;
    }
    for(int i=0;i<arr.length-1;i++){
        int minindex=i;
        for(int j=i+1;j<arr.length;j++){
            minindex=arr[j]<arr[minindex]?j:minindex;
        }
        swap(arr,i,minindex;)

    }

}

每次选出一个最小数放在前面。与冒泡不同，选出最小数后在swap。

3.插入排序

时间： ，空间O(1)，稳定性：稳

public static void insertSort(int[] arr){
    if(arr==null || arr.length<2){
        return;
    for(int i=1;i<arr.length-1;i++){
        for(int j=i-1;j>=0 && arr[j]>arr[j+1];j--){
            swap(arr,j,j+1)
        }
    }
}

前n个排好序，第n+1个数插入进行排序。

4.归并排序

时间： ，空间O(N)，稳定性：稳

public static void Mergesort(int [] arr){
    if(arr==null || arr.length<2){
        return;
    }
    mergesort(arr,0,arr.length-1);
}
public static void mergesort(int[] arr,int l,int r){
    if(l==r){
        return;
    }
    int mid=l+((r-l)>>1);
    Mergesort(arr,l,mid);
    Mergesort(arr,mid+1,r);
    merge(arr,l,mid,r);
}
public static void merge(int[] arr,int l,int mid, int r){
    int[] help=new int[r-1+1];
    int p1=l;
    int p2=mid+1;
    int i=0;
    while(p1<=m && p2<=r){
        help[i++]=arr[p1]<arr[p2]?arr[p1++]:arr[p2++];
    }
    while(p1<=m){
        help[i++]=arr[p1++];
    }
    while(p2<=r){
        help[i+=]=arr[p2++];
    }
    for(i=0;i<help.length;i++){
        arr[l+i]=help[i];
    }
}

分一半，两边排好序，合并。

4.快速排序

时间： ，空间O(N)，稳定性：稳

public static void QuickSort(int[] arr){
    if(arr==null || arr.length<2){
        return;
    }
    quickSort(arr,0,arr.length-1);
}
public static void quickSort(int[] arr,int l,int r){
    if(l<r){
        swap(arr,l+(int)(Math.random()*(r-l+1)),r);
        int[] p =partition(arr,l,r);
        quickSort(arr,l,p[0]-1);
        quickSort(arr,p[1]+1,r);
    }  
}
public static int[] partition(int[] arr,int l, int r){
    int less=l-1;
    int more=r;
    while(l<more){
        if(arr[l]<arr[r]){
            swap(arr,++less,l++); //属于 小于区
        }else if(arr[l>arr[r]]){
            swap(arr,--more,l);//属于大于区
        }else {
            l++;  //属于 等于区
        }
    }
    swap(arr,more,r); //分区点放回中间
    return new int[]{less+1,more};//等于区的两个边界
}

随机确定一个数作为分区点，一趟排序将数据分成三部分，递归重复。

5.堆排序

时间： ，空间O(1)，稳定性：稳

public static void heapSort(int[] arr) {
		for(int i=0;i<arr.length;i++) {
			heapInsert(arr,i); //建堆
		}
		int size=arr.length;
		swap(arr,0,--size);
		while(size>0) {
			heapify(arr,0,size);
			swap(arr,0,--size);
		
	}
	}
	//向上调整，当前插入值大于父结点，交换。
	public static void heapInsert(int[] arr, int index) {
		while(arr[index] > arr[(index-1)/2]) {
			swap(arr,index,(index-1)/2);
			index=(index-1)/2;
			}
		}
	
	public static void  heapify(int[] arr,int index,int size) {
		int left=index*2+1;
		while(left<size) {
			int larget=left+1<size &&arr[left+1]>arr[left]?left+1:left; //子节点中最大值的索引
			larget=arr[larget]>arr[index]?larget:index; //子节点与父结点最大值的索引
			if(larget==index) { //若index为最大值  则不需要调整了
				break;
			}
			swap(arr,index,larget); //调整
			index=larget;
			left=index*2+1;//接着调整
		}
	}

主要两个步骤 heapInsert 向上调整堆，插入值与父节点比较，大于则交换。heapify向下调整堆，与子结点比较，小于则交换。