排序算法模板

排序算法

算法	时间复杂度	最好	最坏	稳定性	空间
插入排序	O(n^2)	O(n)	O(n^2)	稳定
冒泡排序	O(n^2)	O(n)	O(n^2)	稳定
归并排序	O(nlogn)	O(nlogn)	O(nlogn)	稳定	O(n)
堆排序	O(nlogn)	O(nlogn)	O(nlogn)	不稳定
快速排序	O(nlogn)	O(nlogn)	O(n^2)	不稳定

1、归并排序

public void merge(int[] array,int left,int mid,int right){
        int [] arr = new int [right-left+1];
        int pos = 0; // 临时数组的位置
        // 直接选择排序
        int i = left;
        int j = mid+1;
        while(i<=mid && j<=right){
            if(array[i] <= array[j]){
                // 前面的小于后面的
                arr[pos++] = array[i++];
            }else{
                // 后面的小于前面的
                arr[pos++] = array[j++];
            }
        }
        // 将剩余的全部加到临时数组后面
        while(i<=mid){
            arr[pos++] = array[i++];
        }
        while(j<=right){
            arr[pos++] = array[j++];
        }
        // 用临时数组替换原数组
        for(int n = left;n<=right;n++){
            array[n] = arr[n-left];
        }
    }
	// 归并排序
    public void mergeSort(int left,int right, int [] array){
        if(left >= right) return;
        int mid = (left + right) / 2;
        mergeSort(left,mid,array);
        mergeSort(mid+1,right,array);   
        merge(array,left,mid,right);
    }

2、堆排序

• 使用优先队列实现

// 大根堆
PriorityQueue<Integer> q = new PriorityQueue<>((Integer o1,Integer o2)->{return o2 - o1;});

• 堆排序模板

public void heapSort(int[] tree) {
    // n是数组长度
    // tree是初始数组
    int n = tree.length;
    buildHeap(tree); // 建造初始堆
    for(int i = n-1;i >= 0;i--) {
        swap(tree,0,i);// 把最大的放最后面
        heapify(tree, 0, i);// 调整
    }
}
//构建最大堆
private void buildHeap(int[] tree) {
    // 保证顶部一定是最大值，但总体不一定是有序的，需要再次遍历调整
    int lastNode = tree.length-1;
    int parent = (lastNode-1)/2; // 二叉树左节点为父节点的二倍
    //从下往上构建
    for(int i = parent;i >= 0;i--) {
        heapify(tree,i,tree.length);
    }
}

//在左子节点，右子节点中找出最大值与父节点替换，形成局部最大堆
private void heapify(int[] tree, int i, int n) {
    int max = i;
    int left = 2*i+1; // 加一是因为i是从0开始的
    int right = 2*i+2;
    if(left<n && tree[left]>tree[max]) {
        max = left;
    }
    if(right<n && tree[right]>tree[max]) {
        max = right;
    }
    if(max!=i) {
        swap(tree,i,max);
        heapify(tree,max,n);
    }
}
//交换
private void swap(int[] a, int i, int j) {
    int temp = a[i];
    a[i] = a[j];
    a[j] = temp;
}

3、快排

public void quickSort(int left,int right,int [] array){
        if(left >= right) return;
        
        int i = left-1;
        int j = right+1;
        int x = array[left];
        while(i<j){
            do i++; while(array[i] < x);
            do j--; while(array[j] > x);
            if(i < j){
                int tmp = array[i];
                array[i] = array[j];
                array[j] = tmp;
            }
        }
        quickSort(left,j,array);
        quickSort(j+1,right,array);
    }

4、冒泡算法

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

5、插入排序

public static void sort(int[] arrays) {
    int temp = 0;
    for(int i = 1; i <= arrays.length - 1; i++) {
        for(int j = i; j > 0; j--) {
            if(arrays[j - 1] > arrays[j]) {
                temp = arrays[j];
                arrays[j] = arrays[j - 1];
                arrays[j - 1] = temp; 
            }else {
                //不满足条件结束循环即可
                break;
            }
        }
    }
}