常见的排序算法Java实现【堆排序、快排、归并排序、选择排序、交换排序、冒泡排序】

常见的排序算法Java实现【堆排序、快排、归并排序、选择排序、交换排序、冒泡排序】

（测试过，可以使用）

import java.util.Arrays;

/**
 * @author: wyf
 * @date:2022/3/8 14:11
 */
public class PaiXu {
    //堆排序 时间复杂度O(nlogn) 空间复杂度 O(1)
    public static void heapSort(int[] nums){
        int len = nums.length;
        //构建大顶堆
        for(int i = len / 2 - 1; i >= 0; i--){
            adjustHeap(nums, i, len);
        }
        //交换节点，调整堆
        for(int j = len - 1; j > 0 ; j--){
            swap(nums, 0, j);
            adjustHeap(nums,0,j);
        }
    }
    //调整堆结构
    public static void adjustHeap(int[] nums, int index, int len){
        int temp = nums[index];
        int i = index;
        for(int k = 2 * index + 1; k < len; k = k * 2 + 1){
            if(k + 1 < len && nums[k] < nums[k + 1]){
                k++;
            }
            if(nums[k] > temp){
                nums[i] = nums[k];
                i = k;
            } else {
                break;
            }
        }
        nums[i] = temp;
    }
    public static void swap(int[] nums, int i, int j){
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }

    //快排 平均时间复杂度 O(nlogn) 空间复杂度 O(1)，最坏时间复杂度O(n^2)
    public static void quick(int[] nums){
        int len = nums.length;
        quickSort(nums, 0, len - 1);
    }
    public static void quickSort(int[] nums, int i, int j){
        int l = i, r = j;
        if(l >= r) return ;
        int temp = nums[l];
        while(l < r){
            while(l < r && nums[r] >= temp){
                r--;
            }
            nums[l] = nums[r];
            while(l < r && nums[l] <= temp){
                l++;
            }
            nums[r] = nums[l];
        }
        nums[l] = temp;
        quickSort(nums, i, l - 1);
        quickSort(nums, l + 1, j);
    }
    //归并排序 时间复杂度O(nlogn) O(n)
    public static void mergeSort(int[] nums){
        int len = nums.length;
        int[] temp = new int[len];  //创建一个辅助数组，防止频繁建立数组
        partition(nums, temp, 0, len - 1);
    }
    public static void partition(int[] nums, int[] temp, int left, int right){
        if(left < right){
            int mid = (right - left) / 2 + left;
            partition(nums, temp, left, mid); //对左半部分进行归并排序
            partition(nums, temp, mid + 1, right);//对右半部分进行归并排序
            merge(nums,temp, left, mid, right); //合并左右部分
        }
    }
    public static void merge(int[] nums, int[] temp, int left, int mid, int right){
        int i = left;
        int j = mid + 1;
        int t = 0;
        while(i <= mid && j <= right){
            if(nums[i] <= nums[j]){
                temp[t++] = nums[i++];
            } else {
                temp[t++] = nums[j++];
            }
        }
        while(i <= mid){
            temp[t++] = nums[i++];
        }
        while(j <= right){
            temp[t++] = nums[j++];
        }
        t = 0;
//        for(int k = left; k <= right; k++){
//            nums[k] = temp[t++];
//        }
        while(left <= right){
            nums[left++] = temp[t++];
        }
    }

    //交换排序
    public static void exchangeSort(int[] nums){
        int len = nums.length;
        for(int i = 0; i < len; i++){
            for(int j = i + 1; j < len; j++){
                if(nums[i] > nums[j]){
                    swap(nums, i, j);
                }
            }
        }
    }
    //冒泡排序
    public static void bubbleSort(int[] nums){
        int len = nums.length;
        for(int i = 0; i < len; i++){
            int flag = 0;
            for(int j = 0; j < len - i - 1; j++){
                if(nums[j + 1] < nums[j]){
                    swap(nums, j, j + 1);
                    flag = 1;
                }
            }
            if(flag == 0){
                break;
            }
        }
    }
    //选择排序
    public static void selectSort(int[] nums){
        int len = nums.length;
        int min = 0;
        for(int i = 0; i < len; i++){
            for(int j = i + 1; j < len; j++){
                if(nums[min] > nums[j]){
                    min = j;
                }
            }
            swap(nums, i, min);
        }
    }
    //插入排序
    public static void insertSort(int[] nums){
        int len = nums.length;
        for(int i = 0; i < len; i++){
            //寻找nums[i]的插入位置
            for(int j = i; j > 0; j--){
                if(nums[j] < nums[j - 1]){
                    swap(nums, j, j - 1);
                } else {
                    break;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] nums = {1,2,5,7,5,8,0,3};
        mergeSort(nums);
        System.out.println(Arrays.toString(nums));
    }
}