java常用排序方法

1.交换排序

【序列中任意两个元素进行比较，根据比较结果来交换各自在序列中的位置，以此达到排序的目的】

1.1冒泡排序

（以升序排序为例）

1. 从第一个元素开始，比较相邻的两个元素。如果第一个比第二个大，则进行交换。

2. 轮到下一组相邻元素，执行同样的比较操作，再找下一组，直到没有相邻元素可比较为止，此时最后的元素应是最大的数。

3. 除了每次排序得到的最后一个元素，对剩余元素重复以上步骤，直到没有任何一对元素需要比较为止

public void numberUP(int[] arr) {

    if(arr == null) {
        throw new NullPoniterException();
    }
    if(arr.length < 2) {
        return;
    }
    int temp = 0;
    for(int i = 0; i < arr.length - 1; i++) {
        for(int j = 0; j < arr.length - i - 1; j++) {
            if(arr[j] > arr[j + 1]) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

1.2 快速排序

先把待排序的数组拆成左右两个区间，左边都比中间的基准数小，右边都比基准数大。接着左右两边各自再做同样的操作，完成后再拆分再继续，一直到各区间只有一个数为止

public class QuickSort {
    public static void main(String[] args) {
        int[] arr = {5, 2, 8, 3, 1}; // 要进行排序的数组
        
        quicksort(arr); // 调用快速排序函数对数组进行排序
        
        System.out.println("排序后的结果为：");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
    
    private static void quicksort(int[] arr) {
        if (arr == null || arr.length <= 1) {
            return;
        }
        
        int pivotIndex = partition(arr, 0, arr.length - 1); // 获取基准元素所在位置
        
        quicksort(Arrays.copyOfRange(arr, 0, pivotIndex)); // 对左侧子数组进行排序
        quicksort(Arrays.copyOfRange(arr, pivotIndex + 1, arr.length)); // 对右侧子数组进行排序
    }
    
    private static int partition(int[] arr, int low, int high) {
        int pivot = arr[low]; // 选择第一个元素作为基准值
        while (low < high) {
            while (low < high && arr[high] >= pivot) {
                --high;
            }
            
            swap(arr, low, high); // 将比基准小的元素移到前面
            
            while (low < high && arr[low] <= pivot) {
                ++low;
            }
            
            swap(arr, low, high); // 将比基准大的元素移到后面
        }
        
        return low; // 返回基准元素所在位置
    }
    
    private static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

2.插入排序

2.1 直接插入排序

将一个记录插入到已经排好序的有序表中，使得被插入数的序列同样是有序的

public void insertSort(int[] arr) {
    // 遍历所有数字
    for(int i = 1; i < arr.length - 1; i++) {
        // 当前数字比前一个数字小
        if(arr[i] < arr[i - 1]) {
            int j;
            // 把当前遍历的数字保存起来
            int temp = arr[i];
            for(j = i - 1; j >= 0 && arr[j] > temp; j--) {
                // 前一个数字赋给后一个数字
                arr[j + 1] = arr[j];
            }
            // 把临时变量赋给不满足条件的后一个元素
            arr[j + 1] = temp;
        }
    }
}

2.2 希尔排序 （缩小增量排序）

把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至 1 时，整个文件恰被分成一组，算法便终止。

2.2.1算法过程

       1）通过数组的长度/2得到第一趟排序的增量，按照增量进行分组。
  2）每个分组使用直接插入排序进行位置的交换
  3）通过第一趟排序的增量/2得到第二次排序的增量，向上取整，在按照增量进行分组。
  4）每个分组使用直接插入排序进行位置的交换
  5）直到得到的增量为1时，进行的直接插入排序的结果为希尔排序的结果。