---恢复内容开始---
第三章 简单排序
这一章将介绍三种基础的排序算法,冒泡,选择,插入排序。这三种排序的所有操作归结起来就是两步:比较和交换
冒泡排序
永远只比较相邻的两个元素,大的就放到右边,第一次冒泡完最大的元素一定在序列的最右端。第一趟冒泡进行了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);
}
}
插入排序
插入排序是本章中所有排序中最快的一种排序方式,但是比较麻烦。该排序算法的前提是局部有序