Java 常用八大排序

 

JAVA常用八大排序

引用：https://blog.csdn.net/qq_45270751/article/details/121066947

 

1.冒泡排序

2.选择排序

3.插入排序

4.希尔排序

5.堆排序

6.快速排序

7.归并排序

8.计数排序

 

冒泡排序

原理:在无序区间，通过相邻数的比较，将最大的数冒泡到无序区间的最后，持续这个过程，直到数组整体有序。

代码实现

package com.luckylu.sortMethod;

import java.util.Arrays;

public class BubbleSortLesson01 {
    public static void main(String[] args) {
        int[] array1={2,5,8,6,9,4,3,7};
        System.out.println(Arrays.toString(array1));
        bubbleSort(array1); //调用冒泡方法
        System.out.println(Arrays.toString(array1));

    }
//    冒泡方法
    public static void bubbleSort(int[] array){
        // 控制比较的次数,从最大值初步递减，缩小比较范围。
        for (int i = array.length; i >0 ; i--) {
//           比较的数字逐步递增，且执行大数向右移动。
            for (int j = 1; j <i; j++) {
                //比较相邻两个数字的大小
                if (array[j]<array[j-1]){
                    //大数向右移动
                    int tmp = array[j];
                    array[j] = array[j-1];
                    array[j-1] = tmp;
                }
            }
        }
    }
}

执行结果

 

 

代码优化1

假设给定的数组就是有序的 ，利用建立标签，减少排序的搜索的次数。

package com.luckylu.sortMethod;

import java.util.Arrays;

public class BubbleSortLesson02 {
    public static void main(String[] args) {
        int[] array1={2,3,4,5,6,7,9,8};
        System.out.println(Arrays.toString(array1));
        bubbleSort(array1); //调用冒泡方法
        System.out.println(Arrays.toString(array1));

    }
//    冒泡方法优化利用flag减少遍历次数。
    public static void bubbleSort(int[] array){
        // 控制比较的次数,从最大值初步递减，缩小比较范围。
        for (int i = array.length; i >0 ; i--) {
            //
            boolean flag = true;  //定义一个flag 为true
//           比较的数字逐步递增，且执行大数向右移动。
            for (int j = 1; j <i; j++) {
                //比较相邻两个数字的大小
                if (array[j]<array[j-1]){
                    //大数向右移动
                    int tmp = array[j];
                    array[j] = array[j-1];
                    array[j-1] = tmp;
                    flag =false;  //执行比较 布尔值为false
                }
            }
            // 没有执行移动，flag为默认值，表示排序完成。
            if (flag){    
                break; //跳出循环
            }
        }
    }
}

执行结果

代码优化2

假设给定的数组尾部数据是升序的。

package com.luckylu.sortMethod;

import java.util.Arrays;

public class BubbleSortLesson03 {
    public static void main(String[] args) {
        int[] array1={5,3,2,4,7,6,8,9};
        System.out.println(Arrays.toString(array1));
        bubbleSort(array1); //调用冒泡方法
        System.out.println(Arrays.toString(array1));

    }
//    冒泡方法优化 跳过尾端升序数字，不进行扫描，缩短搜索时间
    public static void bubbleSort(int[] array){
        // 控制比较的次数,从最大值初步递减，缩小比较范围。
        for (int i = array.length; i >0 ; i--) {
            // 设置初始值，在完全有序时有效，结束程序
            int sortedIndex = 0;
//           比较的数字逐步递增，且执行大数向右移动。
            for (int j = 1; j <i; j++) {
                //比较相邻两个数字的大小
                if (array[j]<array[j-1]){
                    //大数向右移动
                    int tmp = array[j];
                    array[j] = array[j-1];
                    array[j-1] = tmp;
                    sortedIndex = j;  //记录最后一次移动位置
                }
            }
            // 将最后一次移动位置赋值给i，此时减小了扫描最大值
           i =sortedIndex;
        }
    }
}

执行结果

 

选择排序

原理：每一次从无序区间选出最大（或最小）的一个元素，存放在无序区间的最后（或最前），直到全部待排序的数据元素排完

 

代码实现

package com.luckylu.sortMethod;

import java.util.Arrays;

public class SelectSortLesson01 {
    public static void main(String[] args) {
        int[] array1 = {3,5,9,8,7,6,4,2,1};
        System.out.println(Arrays.toString(array1));
        selectSort(array1);
        System.out.println(Arrays.toString(array1));
    }
    //选择排序,找到最大值，依次放在最后
    public static void selectSort(int[] array) {
        // 控制扫描的数量，递减
        for (int i = array.length-1 ; i > 0; i--) {
            // 定义一个最大值初始下标为0；
            int imax =0;
            for (int j = 1; j <= i; j++) {
                if(array[j]>array[imax]) { 
                    // 判断是下标j值否大于下标0值，是那么最大值的更新下标
                    imax = j;
                }
            }
            int tmp = array[i];
            array[i] = array[imax];
            array[imax] = tmp;
        }
    }
}

实现结果

 

优化代码

原理:首先在未排序序列中找到最小元素，存放到排序序列的起始位置，然后再从剩余未排序元素中继续寻找最小元素，然后放到已排序序列的末尾。

package com.luckylu.sortMethod;

import com.sun.scenario.effect.impl.sw.java.JSWColorAdjustPeer;

import java.util.Arrays;

public class SelectSortLesson02 {
        public static void main(String[] args) {
            int[] array1 = {3,8,9,5,7,6,4,2,1};
            System.out.println(Arrays.toString(array1));
            selectSort(array1);
            System.out.println(Arrays.toString(array1));
        }
    public static void selectSort(int[] array){
        int left = 0; //  左区间
        int right = array.length-1;  // 右区间
        while (left<right){
            int imin= left;  // 记录最小值的下标
            int imax = left;  // 记录最大值的下标

            for (int i = left; i<=right ; i++) {

                if (array[i] < array[imin]) {
                    imin = i; //更新最小值下标
                }
                if (array[i] > array[imax]) {
                    imax = i;  //更新最大值下标
                }
            }
            // 交换最小值，调用下面的交换方法
            swap(array,left,imin);
            // 例：最小值交换完成，2-8已经交换，再次更新imax值，避免执行最大值交换时，2-8再次交换。
            if (imax == left){
                imax=imin;
            }
            //  交换最大值，调用下面交换方法
            swap(array,right,imax);
            //调整排序区间
            left++;
            right--;
        }
    }
    //常用交换位置的方法
    public static void swap(int[] array ,int i ,int j){
        int tmp =array[i];
        array[i] =array[j];
        array[j]=tmp;
    }
}

实现结果

 

插入排序

原理:每次选择无序区间的第一个元素，在有序区间内选择合适的位置插入

代码实现

package com.luckylu.sortMethod;

import java.util.Arrays;

public class SelectSortLesson03 {
    public static void main(String[] args) {
        int[] array1 = {3,8,9,5,7,6,4,2,1};
        System.out.println(Arrays.toString(array1));
        selectSort(array1);
        System.out.println(Arrays.toString(array1));
    }
    public static void selectSort(int[] array){
        for (int i = 1; i < array.length ; i++) {
            int insertIndex = i;  //下标
            int insertValue = array[i];  //临时值
            while (insertIndex > 0 && insertValue < array[insertIndex-1]){
                array[insertIndex]=array[insertIndex-1];
                insertIndex--;
            }
            array[insertIndex]= insertValue;  //替换
        }
    }
}

 

实现结果

 

希尔排序

希尔排序是对直接插入排序的优化 ,希尔排序法又称缩小增量法。

原理:插入排序是步长位1的排序，希尔排序是步长不断缩小直到步长1的排序。

代码实现

package com.luckylu.sortMethod;

import java.util.Arrays;

public class ShellSortLesson {
    public static void main(String[] args) {
        int[] array1 = {3,8,9,5,7,6,4,2,1};
        System.out.println(Arrays.toString(array1));
        shellSort(array1);
        System.out.println(Arrays.toString(array1));
        }

    public static void shellSort(int[] array) {
        // 步长gap ,gap = array.length/2 间隔几个元素进行排序；gap/=2 实现二叉树；
        for (int gap = array.length/2; gap >0 ; gap/=2) {
            //步长位gap的 插入排序
            for (int i = gap; i <array.length ; i++) {
                int insertIdex = i;
                int insertValue = array[i];
                while (insertIdex-gap>=0 && insertValue<array[insertIdex-gap]){
                    array[insertIdex]=array[insertIdex-gap];
                    insertIdex-=gap;
                };
                array[insertIdex]=insertValue;
            }
        }
    }
}

 

 

实现结果

 

 

堆排序

原理:指利用堆这种数据结构所设计的一种排序算法。堆是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

 

代码实现

 

 

实现结果

 

 

快速排序

原理:从待排序区间选择一个数，作为基准值 , 遍历整个待排序区间，将比基准值小的（可以包含相等的）放到基准值的左边，将比基准值大的（可 以包含相等的）放到基准值的右边 , 采用分治思想，对左右两个小区间按照同样的方式处理，直到小区间的长度 == 1，代表已经有序，或者小区间 的长度 == 0，代表没有数据

代码实现

 

 

实现结果

 

 

归并排序

原理:将已有序的子序列合并，得到完全有序的序列,即先使每个子序列有序，再使子 序列段间有序

代码实现

 

 

实现结果

 

 

计数排序

原理：计数排序是一种牺牲内存空间来换取低时间的排序算法，同时它也是一种不基于比较的算法。这里的不基于比较指的是数组元素之间不存在比较大小的排序算法

代码实现

 

 

实现结果