JAVA 几种排序算法（附）动画演示_java 冒泡算法动画

几种排序算法的属性对比

一、冒泡排序

特点：效率低，实现简单
原理：将待排序列中最大的数往后冒泡，成为新的序列，重复以上操作直到所有元素排列完成

public class PaiXu {

    public static void main(String []args) {

        maoPao(a);
    }

    /**
    *冒泡排序
    */
    public static void maoPao(int []array){
        int temp;//交换数据
        System.out.println("\n冒泡排序：");
        for(int i=1;i<array.length;i++) {   //只需要比较数组元素个数减一次
            for(int j=0;j<array.length-1;j++) {
                if(array[j]>array[j+1]) {
                    temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                }
            }
            System.out.print("第"+i+"次：");
            for(int i=0;i<array.length;i++) {
                System.out.print(array[i]+" ");
            }
            System.out.println();
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

二、选择排序

特点：效率低，容易实现。
原理：每一趟从待排序序列选择一个最小的元素放到已排好序序列的首位，剩下的位待排序序列，重复上述步骤直到完成排序。

    /**
    *选择排序
    */
    public static void xuanZe(int []array) {
        int index,temp;
        System.out.println("\n选择排序：");
        for(int i=0;i<array.length-1;i++) {
            index=i;//用来记住数组元素的下标
            for(int j=i+1;j<array.length;j++) {
                if(array[index]>array[j]) {
                    index=j;//只对index值改变，不交换元素位置
                }
            }
            if(i!=index) {
                temp=array[index];
                array[index]=array[i];
                array[i]=temp;
            }//一轮排序进行一次数组位置交换
            System.out.print("第"+i+"次：");
            for(int i=0;i<array.length;i++) {
                System.out.print(array[i]+" ");
            }
            System.out.println();
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

有的人在排序时一遇到比已选择的元素大的元素就进行交换，这样交换的次数太多

以上方法采用的是记录该元素的下标，最终只需要将该下标指向的元素和需交换的元素交换即可，这样一轮排序只需要交换一次数组元素的位置

插入排序

特点：效率低，容易实现。
原理：将数组分为两部分，将后部分元素逐一插入前部分有序元素的适当位置

    /**
    *插入排序
    */
    public static void chaRu(int []array) {
        int temp;
        System.out.println("\n插入排序：");
        for(int i=1;i<array.length;i++) {
            int j=i;
            temp = array[i];
            while( j>0 && temp < array[j-1]) {
                array[j] = array[j-1];
                j--;
            }
            array[j] = temp;
            System.out.print("第"+i+"次：");
            show(array);
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

快速排序

特点：高效，时间复杂度为nlogn。
原理：采用分治法的思想：首先设置一个中间值，然后以这个中间值为划分基准将待排序序列分成比该值大和比该值小的两部分，将这两部分再分别进行快速排序
直到序列只剩下一个元素

/**快速排序
     * */
    public static void kuaiSu(int []array,int left,int right){
        if(left < right) {
            int i=left,j=right;
            int pivot = array[left];//选择最左边的元素作为中间值

        /**
         * 分治
         */
        while(i < j) {
            while(i < j && array[j] >= pivot) {
                j--;
            }
            if(i < j) {
                array[i] = array[j];
                i++;
            }
            while(i < j&& array[i] < pivot){
                i++;
            }
            if(i < j) {
                array [j] =array [i];
                j--;
            }
        }
        array [i]=pivot;
        //递归
        kuaiSu(array,left,i-1);
        kuaiSu(array,i+1,right);
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32