排序是数据处理中不时应用的一种重要的演算,排序是数量处理中时常利用的1种首要的演算

排序是我们生活中经常会面对的问题,排序是我们生活中经常会面对的问题

叁、冒泡排序VS急忙排序

代码如下:

BubbleVsQuick.java 

public class BubbleVsQuick {

    public static void main(String[] args) {
        testQuick();
        testBubble();
    }

    /**
     * 测试快速排序耗费的时间
     */
    public static void testQuick() {
        int[] list = new int[10000];
        for (int i = 0; i < 10000; i++) {
            list[i] = (int) (Math.random() * 100000);
        }

        // 快速排序
        long start = System.currentTimeMillis();
        QuickSort.quickSort(list, 0, list.length - 1);
        long end = System.currentTimeMillis();
        System.out.println("快速排序耗费的时间:" + (end - start));
        display(list);
    }

    /**
     * 测试冒泡排序耗费的时间
     */
    public static void testBubble() {
        int[] list = new int[10000];
        for (int i = 0; i < 10000; i++) {
            list[i] = (int) (Math.random() * 100000);
        }

        // 冒泡排序
        long start = System.currentTimeMillis();
        BubbleSort.bubbleSort(list);
        long end = System.currentTimeMillis();
        System.out.println("冒泡排序耗费的时间:" + (end - start));
        display(list);
    }

    /**
     * 遍历打印前10个数
     */
    public static void display(int[] list) {
        System.out.println("********排序之后的前10个数start********");
        if (list != null && list.length > 0) {
            for (int i = 0; i < 10; i++) {
                System.out.print(list[i] + " ");
            }
            System.out.println("");
        }
        System.out.println("********排序之后的前10个数end**********");
        System.out.println("");
    }
}

 

测试结果:

图片 1

足见,快速排序的快慢比冒泡排序越来越快。

 

 

迎接转发,但请保留小说原来出处

本文地址:http://www.cnblogs.com/nnngu/p/8281030.html 

 

2-1、示意图

图片 2

 

排序是我们生存中时时汇合对的难点。同学们做操时会依据从矮到高排列;老师查看上课出勤景况时,会按学生学号顺序点名;高等高校统招考试录取时,会按成绩总分降序依次录取等。排序是数额处理中平时使用的一种重点的演算,它在我们的程序支付中顶住着那多少个重大的剧中人物。

插入排序:

采纳排序:

  一 冒泡排序 
  二 急迅排序

插入排序:

三、冒泡排序VS连忙排序

  柒 合并排序

  伍 直接插入排序 
  六 希尔排序

那篇作品主要计算的是换到排序(即冒泡排序和高效排序),交流排序的骨干考虑是:两两比较待排序成分,假诺发现四个因素的次序相反时即开始展览置换,直到全体因素都不曾反序时停止。作者会从以下多少个方面拓展总括:

一、冒泡排序及算法完结

  叁 直接选拔排序 
  ④ 堆排序

贰、快捷排序及算法完毕

 

 

1-1、示意图

图片 3

 

2-2、代码

马上排序算法的代码完结:

QuickSort.java 

public class QuickSort {
    public static void main(String[] args) {
        int[] list = {6, 1, 2, 7, 9, 3, 4, 5, 10, 8};
        System.out.println("************快速排序************");
        System.out.println("排序前:");
        display(list);

        System.out.println("排序后:");
        quickSort(list, 0, list.length - 1);
        display(list);
    }

    /**
     * 快速排序算法
     */
    public static void quickSort(int[] list, int left, int right) {
        if (left < right) {
            // 分割数组,找到分割点
            int point = partition(list, left, right);

            // 递归调用,对左子数组进行快速排序
            quickSort(list, left, point - 1);
            // 递归调用,对右子数组进行快速排序
            quickSort(list, point + 1, right);
        }
    }

    /**
     * 分割数组,找到分割点
     */
    public static int partition(int[] list, int left, int right) {
        // 用数组的第一个元素作为基准数
        int first = list[left];
        while (left < right) {
            while (left < right && list[right] >= first) {
                right--;
            }
            // 交换
            swap(list, left, right);

            while (left < right && list[left] <= first) {
                left++;
            }
            // 交换
            swap(list, left, right);
        }
        // 返回分割点所在的位置
        return left;
    }

    /**
     * 交换数组中两个位置的元素
     */
    public static void swap(int[] list, int left, int right) {
        int temp;
        if (list != null && list.length > 0) {
            temp = list[left];
            list[left] = list[right];
            list[right] = temp;
        }
    }

    /**
     * 遍历打印
     */
    public static void display(int[] list) {
        System.out.println("********展示开始********");
        if (list != null && list.length > 0) {
            for (int num :
                    list) {
                System.out.print(num + " ");
            }
            System.out.println("");
        }
        System.out.println("********展示结束********");
    }
}

 

测试结果:

图片 4

 

一、冒泡排序及算法达成

二、连忙排序及算法达成 

急迅排序(Quick Sort)
是对冒泡排序的一种革新格局,在冒泡排序中,实行成分的相比和交流是在紧邻成分之间举行的,成分每一遍调换只好移动三个职位,所以相比较次数和平运动动次数较多,效用绝对较低。而在高速排序中,成分的相比较和沟通是从两端向中档展开的,较大的要素1轮就可知交流到末端的职位,而较小的元素1轮就能调换成前面的地方,成分每趟运动的离开较远,所以相比次数和活动次数较少,速度较快,故称为“连忙排序”。

高效排序的中坚思想是:通过一轮排序将待排序成分分割成独立的两部分,
在那之中有些的有着因素均比另一有个其余装有因素小,然后分别对这两有的的成分继续拓展火速排序,以此达到全部体系变成有序体系。火速排序的最坏时间复杂度为O(n2),平均时间复杂度为O(n*log2n) 
 

一、冒泡排序及算法达成

什么样是冒泡排序呢?冒泡排序是1种不难的排序方法,它的核情绪维是:通过周边五个要素之间的可比和置换,使较大的成分日渐从日前移向后边(升序),就像是水底下的血泡一样逐步发展冒泡,所以被誉为“冒泡”排序。冒泡排序的最坏时间复杂度为O(n2),平均时间复杂度为O(n2)

下边以一张图来展现冒泡排序的全经过,在那之中方括号内为下1轮要排序的要素,方括号前边的第三个成分为本轮排序浮出来的最大要素。

排序是我们生存中平时会见对的题材。同学们做操时会服从从矮到高排列;老师查看上课出勤情状时,会按学生学号顺序点名;高等高校统招考试录取时,会按战绩总分降序依次录取等。排序是数码处理中时常利用的一种重大的运算,它在我们的顺序开发中承受着老大主要的角色。

 

叁、冒泡排序VS急速排序

代码如下:

BubbleVsQuick.java 

public class BubbleVsQuick {

    public static void main(String[] args) {
        testQuick();
        testBubble();
    }

    /**
     * 测试快速排序耗费的时间
     */
    public static void testQuick() {
        int[] list = new int[10000];
        for (int i = 0; i < 10000; i++) {
            list[i] = (int) (Math.random() * 100000);
        }

        // 快速排序
        long start = System.currentTimeMillis();
        QuickSort.quickSort(list, 0, list.length - 1);
        long end = System.currentTimeMillis();
        System.out.println("快速排序耗费的时间:" + (end - start));
        display(list);
    }

    /**
     * 测试冒泡排序耗费的时间
     */
    public static void testBubble() {
        int[] list = new int[10000];
        for (int i = 0; i < 10000; i++) {
            list[i] = (int) (Math.random() * 100000);
        }

        // 冒泡排序
        long start = System.currentTimeMillis();
        BubbleSort.bubbleSort(list);
        long end = System.currentTimeMillis();
        System.out.println("冒泡排序耗费的时间:" + (end - start));
        display(list);
    }

    /**
     * 遍历打印前10个数
     */
    public static void display(int[] list) {
        System.out.println("********排序之后的前10个数start********");
        if (list != null && list.length > 0) {
            for (int i = 0; i < 10; i++) {
                System.out.print(list[i] + " ");
            }
            System.out.println("");
        }
        System.out.println("********排序之后的前10个数end**********");
        System.out.println("");
    }
}

 

测试结果:

图片 5

足见,飞速排序的速度比冒泡排序更加快。

 

 

迎接转发,但请保留小说原来出处

正文地址:http://www.cnblogs.com/nnngu/p/8281030.html 

 

排序分为以下四类共各类排序方法:

  3 直接选取排序 
  ④ 堆排序

联合排序:

那篇著作主要总计的是换到排序(即冒泡排序和急迅排序),沟通排序的主导思想是:两两相比较待排序元素,假使发现四个因素的次序相反时即举办调换,直到全体因素都未曾反序时停止。笔者会从以下多少个方面举行总计:

1-2、代码

冒泡排序算法的代码达成:

BubbleSort.java

public class BubbleSort {
    public static void main(String[] args) {
        int[] list = {36, 28, 45, 13, 67, 37, 18, 56};
        System.out.println("************冒泡排序************");
        System.out.println("排序前:");
        display(list);

        System.out.println("排序后:");
        bubbleSort(list);
        display(list);
    }

    /**
     * 遍历打印
     */
    public static void display(int[] list) {
        System.out.println("********展示开始********");
        if (list != null && list.length > 0) {
            for (int num :
                    list) {
                System.out.print(num + " ");
            }
            System.out.println("");
        }
        System.out.println("********展示结束********");
    }

    /**
     * 冒泡排序算法
     */
    public static void bubbleSort(int[] list) {
        int temp;
        // 做多少轮排序(最多length-1轮)
        for (int i = 0; i < list.length - 1; i++) {
            // 每一轮比较多少个
            for (int j = 0; j < list.length - 1 - i; j++) {
                if (list[j] > list[j + 1]) {
                    // 交换次序
                    temp = list[j];
                    list[j] = list[j + 1];
                    list[j + 1] = temp;
                }
            }
        }
    }
}

 

测试结果:

图片 6

 

排序分为以下四类共多样排序方法:

2、急忙排序及算法实现

联合排序:

  壹 冒泡排序 
  贰 飞快排序

换来排序:

三、冒泡排序VS快速排序

1-1、示意图

图片 7

 

交换排序:

1-2、代码

冒泡排序算法的代码实现:

BubbleSort.java

public class BubbleSort {
    public static void main(String[] args) {
        int[] list = {36, 28, 45, 13, 67, 37, 18, 56};
        System.out.println("************冒泡排序************");
        System.out.println("排序前:");
        display(list);

        System.out.println("排序后:");
        bubbleSort(list);
        display(list);
    }

    /**
     * 遍历打印
     */
    public static void display(int[] list) {
        System.out.println("********展示开始********");
        if (list != null && list.length > 0) {
            for (int num :
                    list) {
                System.out.print(num + " ");
            }
            System.out.println("");
        }
        System.out.println("********展示结束********");
    }

    /**
     * 冒泡排序算法
     */
    public static void bubbleSort(int[] list) {
        int temp;
        // 做多少轮排序(最多length-1轮)
        for (int i = 0; i < list.length - 1; i++) {
            // 每一轮比较多少个
            for (int j = 0; j < list.length - 1 - i; j++) {
                if (list[j] > list[j + 1]) {
                    // 交换次序
                    temp = list[j];
                    list[j] = list[j + 1];
                    list[j + 1] = temp;
                }
            }
        }
    }
}

 

测试结果:

图片 8

 

2-1、示意图

图片 9

 

  7 合并排序

二、迅速排序及算法完毕 

敏捷排序(Quick Sort)
是对冒泡排序的一种革新格局,在冒泡排序中,实行成分的相比较和交流是在左近成分之间开始展览的,成分每一遍沟通只好移动一个职位,所以比较次数和活动次数较多,功能相对较低。而在便捷排序中,成分的比较和沟通是从两端向中档举行的,较大的成分一轮就可知调换成后边的职位,而较小的因素壹轮就能交流来眼下的地方,成分每趟运动的离开较远,所以比较次数和移动次数较少,速度较快,故称为“火速排序”。

赶快排序的主干思索是:通过1轮排序将待排序成分分割成独立的两片段,
个中壹些的保有因素均比另一部分的保有因素小,然后分别对那两某个的因素继续拓展火速排序,以此达到全体类别变成有序体系。火速排序的最坏时间复杂度为O(n2),平均时间复杂度为O(n*log2n) 
 

一、冒泡排序及算法实现

什么是冒泡排序呢?冒泡排序是1种简单的排序方法,它的主导思念是:通过相近两个成分之间的相比和交换,使较大的因素日渐在此之前方移向前面(升序),仿佛水底下的气泡1样日益进化冒泡,所以被称之为“冒泡”排序。冒泡排序的最坏时间复杂度为O(n2),平均时间复杂度为O(n2)

上边以一张图来显示冒泡排序的全经过,在这之中方括号内为下一轮要排序的因素,方括号前面的首先个因素为本轮排序浮出来的最大要素。

2-2、代码

登时排序算法的代码实现:

QuickSort.java 

public class QuickSort {
    public static void main(String[] args) {
        int[] list = {6, 1, 2, 7, 9, 3, 4, 5, 10, 8};
        System.out.println("************快速排序************");
        System.out.println("排序前:");
        display(list);

        System.out.println("排序后:");
        quickSort(list, 0, list.length - 1);
        display(list);
    }

    /**
     * 快速排序算法
     */
    public static void quickSort(int[] list, int left, int right) {
        if (left < right) {
            // 分割数组,找到分割点
            int point = partition(list, left, right);

            // 递归调用,对左子数组进行快速排序
            quickSort(list, left, point - 1);
            // 递归调用,对右子数组进行快速排序
            quickSort(list, point + 1, right);
        }
    }

    /**
     * 分割数组,找到分割点
     */
    public static int partition(int[] list, int left, int right) {
        // 用数组的第一个元素作为基准数
        int first = list[left];
        while (left < right) {
            while (left < right && list[right] >= first) {
                right--;
            }
            // 交换
            swap(list, left, right);

            while (left < right && list[left] <= first) {
                left++;
            }
            // 交换
            swap(list, left, right);
        }
        // 返回分割点所在的位置
        return left;
    }

    /**
     * 交换数组中两个位置的元素
     */
    public static void swap(int[] list, int left, int right) {
        int temp;
        if (list != null && list.length > 0) {
            temp = list[left];
            list[left] = list[right];
            list[right] = temp;
        }
    }

    /**
     * 遍历打印
     */
    public static void display(int[] list) {
        System.out.println("********展示开始********");
        if (list != null && list.length > 0) {
            for (int num :
                    list) {
                System.out.print(num + " ");
            }
            System.out.println("");
        }
        System.out.println("********展示结束********");
    }
}

 

测试结果:

图片 10

 

选拔排序:

  5 直接插入排序 
  六 希尔排序