数据结构（八）——Java实现七大排序

news2024/12/23 8:01:44

一、插入排序

1.直接插入排序

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

直接插入排序特性总结

1. 元素集合越接近有序，直接插入排序算法的时间效率越高。

2. 时间复杂度：O(N^2) 。

3. 空间复杂度：O(1)，它是一种稳定的排序算法。

4. 稳定性：稳定

2.希尔排序

  public static void shell(int[] array,int gap) {
        for (int i = gap; i < array.length; i++) {
            int tmp = array[i];
            int j = i-gap;
            for (; j >= 0;j-=gap) {
                if(array[j] > tmp) {
                    array[j+gap] = array[j];
                }else {
                    break;
                }
            }
            array[j+gap] = tmp;
        }
    }
    public static void shellSort(int[] array) {
        int gap = array.length;
        while (gap > 1) {
            gap /= 2;
            shell(array,gap);
        }
    }

希尔排序特性总结

1.希尔排序是对直接插入排序的优化。
2.当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。

3. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，因此在好些书中给出的希尔排序的时间复杂度都不固定，如果没有特殊说明，我们通常就取

时间复杂度为O(n^1.3)。
时间复杂度：O(n^1.3)

空间复杂度：O(1)

4. 稳定性：不稳定

二、选择排序

1.直接选择排序

 public static void selectSort(int[] array){
        int i = 0;
        int minindex = i;
        for (i = 0; i < array.length; i++) {
            for (int j = i+1; j <array.length ; j++) {
                if(array[j] < array[minindex]){
                    //更新minindex的值
                    minindex = j;
                }
            }
            //处理两个下标值一样的情况
            if (i != minindex){
                swap(array,minindex,i);
            }
        }
    }
    public static void swap(int[] array,int i,int j){
        int tmp = array[i];
        array[i] = array[j];
        array[j] =tmp;
    }

直接选择排序的特性总结

1. 直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用。

2. 时间复杂度：O(N^2) 。

3. 空间复杂度：O(1) 。

4. 稳定性：不稳定

2.堆排序

ps：排升序要建大堆，排降序建小堆。

 public static void heapSort(int[] array) {//堆排序
        createBigHeap(array);//O(n)
        int end = array.length-1;
        while (end > 0) {
            swap(array,0,end);
            shiftDown(array,0,end);
            end--;
        }
    }
 
    private static void createBigHeap(int[] array) {//创建大根堆
        for (int parent = (array.length-1-1)/2; parent >= 0 ; parent--) {
            shiftDown(array,parent,array.length);
        }
    }
 
    private static void shiftDown(int[] array,int parent,int len) {//向下调整
        int child = (2 * parent) + 1;
        while (child < len) {
            if (child + 1 < len && array[child] < array[child + 1]) {
                child++;
            }
            if (array[child] > array[parent]) {
                swap(array, child, parent);
                parent = child;
                child = 2 * parent + 1;
            } else {
                break;
            }
        }
    }

堆排序特性总结

1. 堆排序使用堆来选数，效率就高了很多。

2. 时间复杂度：O(N*logN) 。

3. 空间复杂度：O(1) 。

4. 稳定性：不稳定

三、交换排序

ps：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。

1.冒泡排序

冒泡排序基本思想就是相邻元素挨个比较，遇到比自己小的就交换，直到最后元素有序。

    public static void bubbleSort(int[] array) {
        //最外层控制的是趟数
        for (int i = 0; i < array.length-1; i++) {
            boolean flg = false;
            for (int j = 0; j < array.length-1-i; j++) {
                if(array[j] > array[j+1]) {
                    swap(array,j,j+1);
                    flg = true;
                }
            }
            if(flg == false) {
                break;
            }
        }
    }

冒泡排序的特性总结

1. 冒泡排序是一种非常容易理解的排序

2. 时间复杂度：O(N^2)

3. 空间复杂度：O(1)

4. 稳定性：稳定

2.快速排序

任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。

1、Hoare法

Hoare法的基本思想就是假设我们选array[0]，作为我们的临时节点tmp，定义两个指针变量left和right，先让right从右往左走，找到第一个小于tmp的元素下标，然后left从前往后遍历，找到第一个大于tmp元素的下标，然后交换这两个下标元素的值，当循环结束后，把我们的tmp和left下标交换，那么得到的结果就是tmp左边元素都比tmp小，tmp右边的元素都比tmp大。


 private static int partitionHoare(int[] array,int left,int right) {//hoare法
        int i = left;
        int pivot = array[left];
        while (left < right) {
            //left < right &&  这个条件不能少 预防后面都比基准大
            while (left < right && array[right] >= pivot) {
                right--;
            }
            //代码走到这里表示right下标的值 小于pivot
            while (left < right && array[left] <= pivot) {
                left++;
            }
            //left下标的值 大于pivot
            swap(array,left,right);
        }
        //交换 和 原来的left
        swap(array,left,i);
        return left;
    }

2、挖坑法

挖坑法的基本思想就是把第一个元素取出来，形成一个坑位，然后定义两个指针left和right，先让right从右往左走，找到第一个比tmp小的元素，如果找到，那么把这个元素放到tmp的位置，同理，left从前往后遍历，找到比tmp大的元素的下标，然后用这个元素覆盖array[right],循环结束以后，将tmp放在array[left]的位置，最后返回left便是我们的基准！


  private static int partition2(int[] array,int left,int right) {//挖坑法,优先使用
        int pivot = array[left];
        while (left < right) {
            //left < right &&  这个条件不能少 预防后面都比基准大
            while (left < right && array[right] >= pivot) {
                right--;
            }
            array[left] = array[right];
            //right下标的值 小于pivot
            while (left < right && array[left] <= pivot) {
                left++;
            }
            array[right] = array[left];
        }
        //交换 和 原来的left
        array[left] = pivot;
        return left;
    }

快速排序总结