zoukankan      html  css  js  c++  java
  • java数据结构和算法-------第三章

    ---恢复内容开始---

    第三章  简单排序

    这一章将介绍三种基础的排序算法,冒泡,选择,插入排序。这三种排序的所有操作归结起来就是两步:比较和交换

    冒泡排序

    永远只比较相邻的两个元素,大的就放到右边,第一次冒泡完最大的元素一定在序列的最右端。第一趟冒泡进行了N-1次比较,第二趟是N-2次,以此类推。。所以冒泡算法的时间复杂度是O(N^2)。

    void bubbleSort(int a[])

    {

       for(int i=0;i<a.length;i++)

           for(int j=i;j<a.length;j++)//我这样排序出问题啦,这样写代码默认每一趟排序最小的在最左边,显然不是。

               if(a[j]>a[j+1])

                   swap(a[j],a[j+1]);

    }

    冒泡排序只能保证每一次排序最大的在最右边。因此需要修改代码。

    void bubbleSort(int a[])

    {

       for(int i=a.length-1;i>1;i--)

           for(int j=0;j<i;j++)//无论何时,看到一个循环嵌套在另外一个循环中时,时间复杂度均为N^2级

               if(a[j]>a[j+1])

                   swap(a[j],a[j+1]);

    }

    选择排序

    选择排序(选最小的来比较)是改进了的冒泡排序,它将交换次数从N的平方降到了N,但是不幸的是比较次数仍然为N的平方。

    选择排序和冒泡排序很类似,只是每一趟排序,不再是相邻的两个数比较,而是和上一趟的最小数比较,小的又被设置为比较的基准。所以交换次数是N。

    代码如下:

    void public selectionSort(int a[])

    {  

        for(int i=0;i<a.length;i++)

           {

            min=a[i];

            for(int j=i;j<a.length;j++)

               if(a[j]<min)//每次比较的都是上一次的最小

              min=a[j];

             swap(a[i],min);

            }

    }

    插入排序

    插入排序是本章中所有排序中最快的一种排序方式,但是比较麻烦。该排序算法的前提是局部有序

    ---恢复内容结束---

    第三章  简单排序

    这一章将介绍三种基础的排序算法,冒泡,选择,插入排序。这三种排序的所有操作归结起来就是两步:比较和交换

    冒泡排序

    永远只比较相邻的两个元素,大的就放到右边,第一次冒泡完最大的元素一定在序列的最右端。第一趟冒泡进行了N-1次比较,第二趟是N-2次,以此类推。。所以冒泡算法的时间复杂度是O(N^2)。

    void bubbleSort(int a[])

    {

       for(int i=0;i<a.length;i++)

           for(int j=i;j<a.length;j++)//我这样排序出问题啦,这样写代码默认每一趟排序最小的在最左边,显然不是。

               if(a[j]>a[j+1])

                   swap(a[j],a[j+1]);

    }

    冒泡排序只能保证每一次排序最大的在最右边。因此需要修改代码。

    void bubbleSort(int a[])

    {

       for(int i=a.length-1;i>1;i--)

           for(int j=0;j<i;j++)//无论何时,看到一个循环嵌套在另外一个循环中时,时间复杂度均为N^2级

               if(a[j]>a[j+1])

                   swap(a[j],a[j+1]);

    }

    选择排序

    选择排序(选最小的来比较)是改进了的冒泡排序,它将交换次数从N的平方降到了N,但是不幸的是比较次数仍然为N的平方。

    选择排序和冒泡排序很类似,只是每一趟排序,不再是相邻的两个数比较,而是和上一趟的最小数比较,小的又被设置为比较的基准。所以交换次数是N。

    代码如下:

    void public selectionSort(int a[])

    {  

        for(int i=0;i<a.length;i++)

           {

            min=a[i];

            for(int j=i;j<a.length;j++)

               if(a[j]<min)//每次比较的都是上一次的最小

              min=a[j];

             swap(a[i],min);

            }

    }

    插入排序

    插入排序是本章中所有排序中最快的一种排序方式,但是比较麻烦。该排序算法的前提是局部有序

    ---恢复内容开始---

    第三章  简单排序

    这一章将介绍三种基础的排序算法,冒泡,选择,插入排序。这三种排序的所有操作归结起来就是两步:比较和交换

    冒泡排序

    永远只比较相邻的两个元素,大的就放到右边,第一次冒泡完最大的元素一定在序列的最右端。第一趟冒泡进行了N-1次比较,第二趟是N-2次,以此类推。。所以冒泡算法的时间复杂度是O(N^2)。

    void bubbleSort(int a[])

    {

       for(int i=0;i<a.length;i++)

           for(int j=i;j<a.length;j++)//我这样排序出问题啦,这样写代码默认每一趟排序最小的在最左边,显然不是。

               if(a[j]>a[j+1])

                   swap(a[j],a[j+1]);

    }

    冒泡排序只能保证每一次排序最大的在最右边。因此需要修改代码。

    void bubbleSort(int a[])

    {

       for(int i=a.length-1;i>1;i--)

           for(int j=0;j<i;j++)//无论何时,看到一个循环嵌套在另外一个循环中时,时间复杂度均为N^2级

               if(a[j]>a[j+1])

                   swap(a[j],a[j+1]);

    }

    选择排序

    选择排序(选最小的来比较)是改进了的冒泡排序,它将交换次数从N的平方降到了N,但是不幸的是比较次数仍然为N的平方。

    选择排序和冒泡排序很类似,只是每一趟排序,不再是相邻的两个数比较,而是和上一趟的最小数比较,小的又被设置为比较的基准。所以交换次数是N。

    代码如下:

    void public selectionSort(int a[])

    {  

        for(int i=0;i<a.length;i++)

           {

            min=a[i];

            for(int j=i;j<a.length;j++)

               if(a[j]<min)//每次比较的都是上一次的最小

              min=a[j];

             swap(a[i],min);

            }

    }

    插入排序

    插入排序是本章中所有排序中最快的一种排序方式,但是比较麻烦。该排序算法的前提是局部有序

    ---恢复内容结束---

    第三章  简单排序

    这一章将介绍三种基础的排序算法,冒泡,选择,插入排序。这三种排序的所有操作归结起来就是两步:比较和交换

    冒泡排序

    永远只比较相邻的两个元素,大的就放到右边,第一次冒泡完最大的元素一定在序列的最右端。第一趟冒泡进行了N-1次比较,第二趟是N-2次,以此类推。。所以冒泡算法的时间复杂度是O(N^2)。

    void bubbleSort(int a[])

    {

       for(int i=0;i<a.length;i++)

           for(int j=i;j<a.length;j++)//我这样排序出问题啦,这样写代码默认每一趟排序最小的在最左边,显然不是。

               if(a[j]>a[j+1])

                   swap(a[j],a[j+1]);

    }

    冒泡排序只能保证每一次排序最大的在最右边。因此需要修改代码。

    void bubbleSort(int a[])

    {

       for(int i=a.length-1;i>1;i--)

           for(int j=0;j<i;j++)//无论何时,看到一个循环嵌套在另外一个循环中时,时间复杂度均为N^2级

               if(a[j]>a[j+1])

                   swap(a[j],a[j+1]);

    }

    选择排序

    选择排序(选最小的来比较)是改进了的冒泡排序,它将交换次数从N的平方降到了N,但是不幸的是比较次数仍然为N的平方。

    选择排序和冒泡排序很类似,只是每一趟排序,不再是相邻的两个数比较,而是和上一趟的最小数比较,小的又被设置为比较的基准。所以交换次数是N。

    代码如下:

    void public selectionSort(int a[])

    {  

        for(int i=0;i<a.length;i++)

           {

            min=a[i];

            for(int j=i;j<a.length;j++)

               if(a[j]<min)//每次比较的都是上一次的最小

              min=a[j];

             swap(a[i],min);

            }

    }

    插入排序

    插入排序是本章中所有排序中最快的一种排序方式,但是比较麻烦。该排序算法的前提是局部有序

    ---恢复内容开始---

    第三章  简单排序

    这一章将介绍三种基础的排序算法,冒泡,选择,插入排序。这三种排序的所有操作归结起来就是两步:比较和交换

    冒泡排序

    永远只比较相邻的两个元素,大的就放到右边,第一次冒泡完最大的元素一定在序列的最右端。第一趟冒泡进行了N-1次比较,第二趟是N-2次,以此类推。。所以冒泡算法的时间复杂度是O(N^2)。

    void bubbleSort(int a[])

    {

       for(int i=0;i<a.length;i++)

           for(int j=i;j<a.length;j++)//我这样排序出问题啦,这样写代码默认每一趟排序最小的在最左边,显然不是。

               if(a[j]>a[j+1])

                   swap(a[j],a[j+1]);

    }

    冒泡排序只能保证每一次排序最大的在最右边。因此需要修改代码。

    void bubbleSort(int a[])

    {

       for(int i=a.length-1;i>1;i--)

           for(int j=0;j<i;j++)//无论何时,看到一个循环嵌套在另外一个循环中时,时间复杂度均为N^2级

               if(a[j]>a[j+1])

                   swap(a[j],a[j+1]);

    }

    选择排序

    选择排序(选最小的来比较)是改进了的冒泡排序,它将交换次数从N的平方降到了N,但是不幸的是比较次数仍然为N的平方。

    选择排序和冒泡排序很类似,只是每一趟排序,不再是相邻的两个数比较,而是和上一趟的最小数比较,小的又被设置为比较的基准。所以交换次数是N。

    代码如下:

    void public selectionSort(int a[])

    {  

        for(int i=0;i<a.length;i++)

           {

            min=a[i];

            for(int j=i;j<a.length;j++)

               if(a[j]<min)//每次比较的都是上一次的最小

              min=a[j];

             swap(a[i],min);

            }

    }

    插入排序

    插入排序是本章中所有排序中最快的一种排序方式,但是比较麻烦。该排序算法的前提是局部有序

    ---恢复内容结束---

    第三章  简单排序

    这一章将介绍三种基础的排序算法,冒泡,选择,插入排序。这三种排序的所有操作归结起来就是两步:比较和交换

    冒泡排序

    永远只比较相邻的两个元素,大的就放到右边,第一次冒泡完最大的元素一定在序列的最右端。第一趟冒泡进行了N-1次比较,第二趟是N-2次,以此类推。。所以冒泡算法的时间复杂度是O(N^2)。

    void bubbleSort(int a[])

    {

       for(int i=0;i<a.length;i++)

           for(int j=i;j<a.length;j++)//我这样排序出问题啦,这样写代码默认每一趟排序最小的在最左边,显然不是。

               if(a[j]>a[j+1])

                   swap(a[j],a[j+1]);

    }

    冒泡排序只能保证每一次排序最大的在最右边。因此需要修改代码。

    void bubbleSort(int a[])

    {

       for(int i=a.length-1;i>1;i--)

           for(int j=0;j<i;j++)//无论何时,看到一个循环嵌套在另外一个循环中时,时间复杂度均为N^2级

               if(a[j]>a[j+1])

                   swap(a[j],a[j+1]);

    }

    选择排序

    选择排序(选最小的来比较)是改进了的冒泡排序,它将交换次数从N的平方降到了N,但是不幸的是比较次数仍然为N的平方。

    选择排序和冒泡排序很类似,只是每一趟排序,不再是相邻的两个数比较,而是和上一趟的最小数比较,小的又被设置为比较的基准。所以交换次数是N。

    代码如下:

    void public selectionSort(int a[])

    {  

        for(int i=0;i<a.length;i++)

           {

            min=a[i];

            for(int j=i;j<a.length;j++)

               if(a[j]<min)//每次比较的都是上一次的最小

              min=a[j];

             swap(a[i],min);

            }

    }

    插入排序

    插入排序是本章中所有排序中最快的一种排序方式,但是比较麻烦。该排序算法的前提是局部有序

    ---恢复内容开始---

    第三章  简单排序

    这一章将介绍三种基础的排序算法,冒泡,选择,插入排序。这三种排序的所有操作归结起来就是两步:比较和交换

    冒泡排序

    永远只比较相邻的两个元素,大的就放到右边,第一次冒泡完最大的元素一定在序列的最右端。第一趟冒泡进行了N-1次比较,第二趟是N-2次,以此类推。。所以冒泡算法的时间复杂度是O(N^2)。

    void bubbleSort(int a[])

    {

       for(int i=0;i<a.length;i++)

           for(int j=i;j<a.length;j++)//我这样排序出问题啦,这样写代码默认每一趟排序最小的在最左边,显然不是。

               if(a[j]>a[j+1])

                   swap(a[j],a[j+1]);

    }

    冒泡排序只能保证每一次排序最大的在最右边。因此需要修改代码。

    void bubbleSort(int a[])

    {

       for(int i=a.length-1;i>1;i--)

           for(int j=0;j<i;j++)//无论何时,看到一个循环嵌套在另外一个循环中时,时间复杂度均为N^2级

               if(a[j]>a[j+1])

                   swap(a[j],a[j+1]);

    }

    选择排序

    选择排序(选最小的来比较)是改进了的冒泡排序,它将交换次数从N的平方降到了N,但是不幸的是比较次数仍然为N的平方。

    选择排序和冒泡排序很类似,只是每一趟排序,不再是相邻的两个数比较,而是和上一趟的最小数比较,小的又被设置为比较的基准。所以交换次数是N。

    代码如下:

    void public selectionSort(int a[])

    {  

        for(int i=0;i<a.length;i++)

           {

            min=a[i];

            for(int j=i;j<a.length;j++)

               if(a[j]<min)//每次比较的都是上一次的最小

              min=a[j];

             swap(a[i],min);

            }

    }

    插入排序

    插入排序是本章中所有排序中最快的一种排序方式,但是比较麻烦。该排序算法的前提是局部有序

    ---恢复内容结束---

    第三章  简单排序

    这一章将介绍三种基础的排序算法,冒泡,选择,插入排序。这三种排序的所有操作归结起来就是两步:比较和交换

    冒泡排序

    永远只比较相邻的两个元素,大的就放到右边,第一次冒泡完最大的元素一定在序列的最右端。第一趟冒泡进行了N-1次比较,第二趟是N-2次,以此类推。。所以冒泡算法的时间复杂度是O(N^2)。

    void bubbleSort(int a[])

    {

       for(int i=0;i<a.length;i++)

           for(int j=i;j<a.length;j++)//我这样排序出问题啦,这样写代码默认每一趟排序最小的在最左边,显然不是。

               if(a[j]>a[j+1])

                   swap(a[j],a[j+1]);

    }

    冒泡排序只能保证每一次排序最大的在最右边。因此需要修改代码。

    void bubbleSort(int a[])

    {

       for(int i=a.length-1;i>1;i--)

           for(int j=0;j<i;j++)//无论何时,看到一个循环嵌套在另外一个循环中时,时间复杂度均为N^2级

               if(a[j]>a[j+1])

                   swap(a[j],a[j+1]);

    }

    选择排序

    选择排序(选最小的来比较)是改进了的冒泡排序,它将交换次数从N的平方降到了N,但是不幸的是比较次数仍然为N的平方。

    选择排序和冒泡排序很类似,只是每一趟排序,不再是相邻的两个数比较,而是和上一趟的最小数比较,小的又被设置为比较的基准。所以交换次数是N。

    代码如下:

    void public selectionSort(int a[])

    {  

        for(int i=0;i<a.length;i++)

           {

            min=a[i];

            for(int j=i;j<a.length;j++)

               if(a[j]<min)//每次比较的都是上一次的最小

              min=a[j];

             swap(a[i],min);

            }

    }

    插入排序

    插入排序是本章中所有排序中最快的一种排序方式,但是比较麻烦。该排序算法的前提是局部有序

  • 相关阅读:
    [原创]NT系统信息察看工具 : NtInfoGuy
    [原创]obj-c编程17:键值观察(KVO)
    python使用django框架模板的基本使用
    mysql链接查询
    mysql数据库的增删改查
    python使用django创建项目详解
    python中sdk的使用 (一)
    unittest单元测试框架小白入门
    nosql数据库与sql数据库
    javascript数组的定义及基本操作详解
  • 原文地址:https://www.cnblogs.com/maowuyu-xb/p/6430041.html
Copyright © 2011-2022 走看看