• 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);

            }

    }

    插入排序

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

  • 相关阅读:
    页面性能优化的简单介绍
    JavaScript基础介绍
    迅雷/快车/旋风地址转换器
    关于 API 中返回字串的一些问题
    将文件夹映射为驱动器的工具
    BCB/Delphi2007 隐藏任务栏图标
    所有小工具
    oracle ora01033和ora00600错误
    批量更改文件名的批处理文件
    替代Windows运行功能的工具FastRun
  • 原文地址:https://www.cnblogs.com/maowuyu-xb/p/6430041.html
Copyright © 2020-2023  润新知