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);
}
}
插入排序
插入排序是本章中所有排序中最快的一种排序方式，但是比较麻烦。该排序算法的前提是局部有序
