常见的数组排序算法(冒泡排序/选择排序/插入排序/快速排序)

naoguaziteng

已于 2022-05-02 19:01:08 修改

阅读量534

点赞数

分类专栏： JAVASE基础知识文章标签： java 算法排序

于 2022-05-02 19:00:16 首次发布

本文链接：https://blog.csdn.net/naoguoteng/article/details/124543537

版权

JAVASE基础知识专栏收录该内容

77 篇文章 29 订阅

订阅专栏

本文深入解析了四种基本排序算法——冒泡排序、选择排序、插入排序和快速排序。通过代码实现详细展示了每种算法的工作原理，帮助读者理解其核心思想和应用场景。这些排序算法是计算机科学的基础，对于提升编程能力至关重要。

摘要由CSDN通过智能技术生成

public class ArrayTest {
    public static void main(String[] args) {
       
        int[] arr={33,99,76,34,22,78,59,11};
        //冒泡排序
        maoPao(arr);     //调用方法
      
    }

public static void maoPao(int[] arr) {
        for (int j = arr.length-1; j >0 ; j--) {    //每比较一轮后,就会出现一个最大值,下一轮就会少比较一次
        for (int i = 0; i < arr.length-1; i++) {
            if (arr[i]>arr[i+1]){     //将值大的往后排
                int a=arr[i];
                arr[i]=arr[i+1];
                arr[i+1]=a;
            }
        }
        }
        System.out.println(Arrays.toString(arr));   //输出数组
    }
}
//结果:[11, 22, 33, 34, 59, 76, 78, 99]

2.选择排序

从0索引处开始，拿一个元素，跟他后面的元素挨个比较，小的往前放，经过一轮比较，最小的元素就出现在了最前面。

代码实现:

public class ArrayTest {
    public static void main(String[] args) {
        int[] arr={33,99,76,34,22,78,59,11};
        
        //选择排序
        ArrayUtils.xuanZe(arr);
    }
public static void xuanZe(int[] arr) {
        for (int i = 0; i < arr.length; i++) {     //每次选择的数的索引
            for (int j = i+1; j < arr.length; j++) {
                if (arr[i]>arr[j]){
                    int a=arr[i];
                    arr[i]=arr[j];
                    arr[j]=a;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

3.插入排序

将后面的元素，插入到之前的有序列表中，然后比较使之仍保持保持有序。

代码实现:

public class InsertTest {
    public static void main(String[] args) {
        
        int[] arr={33,99,76,34,22,78,59,11};
        insert(arr);
    }

    private static void insert(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            for (int j = i; j >0; j--) {      //每假如新元素后都需要往前挪进行比较
                if (arr[j]<arr[j-1]){
                    int a=arr[j];
                    arr[j]=arr[j-1];
                    arr[j-1]=a;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

4.快速排序

挖坑填数法:

将基准数挖出形成第一个坑。
由后向前找比他小的数，找到后挖出此数填到前一个坑中。
由前向后找比他大或等于的数，找到后也挖出此数填到前一个坑中。
再重复执行2，3两步骤。例如对 5391672408 进行排序

元素	5	3	9	1	6	7	2	4	0	8
坑位	坑位1		坑位3		坑位5	坑位7	坑位6	坑位4	坑位2
	0	3	4	1	2	5	7	6	9	8

代码实现:

public class QuickTest {
    public static void main(String[] args) {
       
        int[] arr={5,3,9,1,6,7,2,4,0,8};
        quick(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));
    }

    private static void quick(int[] arr,int start,int end) {
        if (start<end) {
           //分成左右两区，对左右两区进行递归调用
            //找出基准数，所在的索引位置。
            int index = getIndex(arr, start, end);
            //对左右两区进行递归调用

            //对左区递归
            quick (arr, start, index - 1);
            //对右区进行递归
            quick (arr, index + 1, end);
        }

    //挖坑填数
    // 1.将基准数挖出形成第一个坑。
    // 2.由后向前找比他小的数，找到后挖出此数填到前一个坑中。
    // 3.由前向后找比他大或等于的数，找到后也挖出此数填到前一个坑中。
    // 4.再重复执行2，3两步骤。
    private static int getIndex(int[] arr, int start, int end) {
        int i = start;
        int j = end;
        //定义一个基准数 小明
        int x = arr[i]; //1.将基准数挖出形成第一个坑。
      
        //2.由后向前找比他小的数，找到后挖出此数填到前一个坑中。
        while (i < j) {
            while (i < j && arr[j] > x) {
                j--;
            }
            //填坑
            if (i < j) {
                arr[i] = arr[j];
                i++; //顺便自增一下
            }
            // 3.由前向后找比他大或等于的数，找到后也挖出此数填到前一个坑中。
            while (i < j && arr[i] <= x) {
                i++;
            }
            //填坑
            if (i < j) {
                arr[j] = arr[i];
                j--; //顺便自减一下
            }
        }
        //把基准数填到最后一个坑  最后 i和j 相等
        arr[i] = x;

        return i;
    }
}

(小编也在努力学习更多哟!以后会继续分享的啦!!!)

希望对友友们有所帮助!!!!