几种排序方式以及它们之间的比较
2017-08-20 17:34
302 查看
1.冒泡排序
算法思想:遍历待排序的数组,每次遍历比较相邻的两个元素,如果他们的排列顺序错误就交换他们的位置,经过一趟排序后,最大的元素会浮置数组的末端。重复操 作,直到排序完成。
两次for循环,可以从后往前,首先比较全部的,比较完把最大的放最后,然后减掉最后一个比较剩下的。
2.插入排序
刚开始假定一个记录有序,其余记录无序,接着从第二个记录开始,插入到前面的有序数列中
以数组{38,65,97,76,13,27,49}为例,
我们这样来看:
当i=1时,i<7
j=1,target=65
j>0 65>arr[0],不进入while ,arr[1]=65;
当i=3时,i<7
j=3,target=76
j>0 且76<arr[2],此时arr[3]=arr[2],和那个大的交换和顺序,然后j--继续往前比较。
3.选择排序
给定一组记录,经过一轮比较得到最小记录,然后将该记录和第一个记录位置交换,接着对不包括第一个记录以外的其他记录进行第二轮比较,得到最小记录并与第二个记录进行位置交换,如此下去即可
4.快速排序
基本思想:
先找到一个初始关键字,然后使左边都比它小,右边都比它大,然后按这种方式处理左边和右边。
具体实现:
快速排序可以归结为:挖坑填数+分治法
我们以这个数组为例子,取位置0作为基准数。
开始时,i = 0; j = 9; X = a[i] = 72
由于已经将a[0]中的数保存到X中,可以理解成在数组a[0]上挖了个坑,可以将其它数据填充到这来。
从j开始向前找一个比X小或等于X的数。当j=8,符合条件,将a[8]挖出再填到上一个坑a[0]中。a[0]=a[8]; i++; 这样一个坑a[0]就被搞定了,但又形成了一个新坑a[8],这怎么办了?简单,再找数字来填a[8]这个坑。这次从i开始向后找一个大于X的数,当i=3,符合条件,将a[3]挖出再填到上一个坑中a[8]=a[3];
j--;
数组变为
i = 3; j = 7; X=72
再重复上面的步骤,先从后向前找,再从前向后找。
从j开始向前找,当j=5,符合条件,将a[5]挖出填到上一个坑中,a[3] = a[5]; i++;
从i开始向后找,当i=5时,由于i==j退出。
此时,i = j = 5,而a[5]刚好又是上次挖的坑,因此将X填入a[5]。
数组变为:
可以看出a[5]前面的数字都小于它,a[5]后面的数字都大于它。因此再对a[0…4]和a[6…9]这二个子区间重复上述步骤就可以了。
总结:
对挖坑填数进行总结
1.i =L; j = R; 将基准数挖出形成第一个坑a[i]。
2.j--由后向前找比它小的数,找到后挖出此数填前一个坑a[i]中。
3.i++由前向后找比它大的数,找到后也挖出此数填到前一个坑a[j]中。
4.再重复执行2,3二步,直到i==j,将基准数填入a[i]中。
1,2,3,4,5,
几种排序的比较:
1.稳定性比较
插入排序、冒泡排序、二叉树排序、二路归并排序及其他线形排序是稳定的
选择排序、希尔排序、快速排序、堆排序是不稳定的
2.时间复杂性比较
插入排序、冒泡排序、选择排序的时间复杂性为O(n2)
其它非线形排序的时间复杂性为O(nlog2n)
线形排序的时间复杂性为O(n);
3.辅助空间的比较
线形排序、二路归并排序的辅助空间为O(n),其它排序的辅助空间为O(1);
4.其它比较
插入、冒泡排序的速度较慢,但参加排序的序列局部或整体有序时,这种排序能达到较快的速度
反而在这种情况下,快速排序反而慢了。
当n较小时,对稳定性不作要求时宜用选择排序,对稳定性有要求时宜用插入或冒泡排序。
若待排序的记录的关键字在一个明显有限范围内时,且空间允许是用桶排序。
当n较大时,关键字元素比较随机,对稳定性没要求宜用快速排序。
当n较大时,关键字元素可能出现本身是有序的,对稳定性有要求时,空间允许的情况下,宜用归并排序。
当n较大时,关键字元素可能出现本身是有序的,对稳定性没有要求时宜用堆排序。
算法思想:遍历待排序的数组,每次遍历比较相邻的两个元素,如果他们的排列顺序错误就交换他们的位置,经过一趟排序后,最大的元素会浮置数组的末端。重复操 作,直到排序完成。
两次for循环,可以从后往前,首先比较全部的,比较完把最大的放最后,然后减掉最后一个比较剩下的。
public static void changenumber(int[] a){ int temp = 0; //设置中间变量 for (int i = a.length - 1; i > 0; --i) //从后往前判断 { for (int j = 0; j < i; ++j) //判断i以前两个数值的大小,最终把这次循环最大的数放到i的位置上去 { if (a[j + 1] < a[j]) { temp = a[j]; a[j] = a[j + 1]; a[j + 1] = temp; } } } } public static void main(String[] args) { int i = 0; int a[] = {9,4,2,1,5,6,7,8,4}; changenumber(a); for (i = 0; i < a.length; i++) { System.out.println(a[i]); } }
2.插入排序
刚开始假定一个记录有序,其余记录无序,接着从第二个记录开始,插入到前面的有序数列中
以数组{38,65,97,76,13,27,49}为例,
public static void InsertSort(int[] arr) { int i, j; int target; //这个 target 一定要有,很重要! //假定第一个元素被放到了正确的位置上 //这样,仅需遍历1 到 n-1 for (i = 1; i < arr.length;i++) { j = i; target = arr[i]; while (j > 0 && target < arr[j - 1]) { arr[j] = arr[j - 1]; j--; } arr[j] = target; } }
我们这样来看:
当i=1时,i<7
j=1,target=65
j>0 65>arr[0],不进入while ,arr[1]=65;
当i=3时,i<7
j=3,target=76
j>0 且76<arr[2],此时arr[3]=arr[2],和那个大的交换和顺序,然后j--继续往前比较。
3.选择排序
给定一组记录,经过一轮比较得到最小记录,然后将该记录和第一个记录位置交换,接着对不包括第一个记录以外的其他记录进行第二轮比较,得到最小记录并与第二个记录进行位置交换,如此下去即可
public class xzpx { //选择排序 public static void changenumber(int[] a) { int temp = 0; int flag = 0; for (int i = 0; i < a.length; i++) { temp = a[i]; //当前值给temp flag = i; //把当前值的位置传递给flag for (int j = i + 1; j < a.length; j++) { //循环当前值之后的值,把当前值之后的最小值给temp,位置给flag if (a[j] < temp) { //如果之后有小于当前值的 temp = a[j]; //将之后的那个值给temp flag = j; //将之后的那个值的位置给flag } } if(flag !=i){ //如果值之后的最小值不是他自己 a[flag]=a[i]; //最小值现在下标是flag,把最小值的位置给当前值 a[i]=temp; //把那额个最小值得值赋值给当前值 } } } public static void main(String[] args) { int i = 0; int a[] = { 9, 8, 1, 6, 4, 4, 3, 2, 1 }; changenumber(a); for (i = 0; i < a.length; i++) { System.out.println(a[i]); } } }
4.快速排序
基本思想:
先找到一个初始关键字,然后使左边都比它小,右边都比它大,然后按这种方式处理左边和右边。
具体实现:
快速排序可以归结为:挖坑填数+分治法
我们以这个数组为例子,取位置0作为基准数。
开始时,i = 0; j = 9; X = a[i] = 72
由于已经将a[0]中的数保存到X中,可以理解成在数组a[0]上挖了个坑,可以将其它数据填充到这来。
从j开始向前找一个比X小或等于X的数。当j=8,符合条件,将a[8]挖出再填到上一个坑a[0]中。a[0]=a[8]; i++; 这样一个坑a[0]就被搞定了,但又形成了一个新坑a[8],这怎么办了?简单,再找数字来填a[8]这个坑。这次从i开始向后找一个大于X的数,当i=3,符合条件,将a[3]挖出再填到上一个坑中a[8]=a[3];
j--;
数组变为
i = 3; j = 7; X=72
再重复上面的步骤,先从后向前找,再从前向后找。
从j开始向前找,当j=5,符合条件,将a[5]挖出填到上一个坑中,a[3] = a[5]; i++;
从i开始向后找,当i=5时,由于i==j退出。
此时,i = j = 5,而a[5]刚好又是上次挖的坑,因此将X填入a[5]。
数组变为:
可以看出a[5]前面的数字都小于它,a[5]后面的数字都大于它。因此再对a[0…4]和a[6…9]这二个子区间重复上述步骤就可以了。
总结:
对挖坑填数进行总结
1.i =L; j = R; 将基准数挖出形成第一个坑a[i]。
2.j--由后向前找比它小的数,找到后挖出此数填前一个坑a[i]中。
3.i++由前向后找比它大的数,找到后也挖出此数填到前一个坑a[j]中。
4.再重复执行2,3二步,直到i==j,将基准数填入a[i]中。
public class kspx{ public static void main(String[] args) { int[] a={3,4,5,2,1}; Sortkspx(a,0,4); for (int i=0;i<a.length;i++){ System.out.print(a[i]+","); } } static void Sortkspx(int s[], int l, int r) { if (l < r) //判断开始和结束值是否合规 { int i = l, j = r, x = s[l]; //起始值给i 终止值给j 将数值起始值给x while (i < j) //一直到i不小于j时 { while(i < j && s[j] >= x) j--; //不断进行j-- 一直找到小于x的数 if(i < j) s[i++] = s[j]; //将这个数放到起点位置 ,然后i+1 while(i < j && s[i] < x) // i++; if(i < j) //找到s[i]大于X得数 s[j--] = s[i]; //将这个放到j位置,然后j-1 } s[i] = x; //X就是抽出来的那个值,这里的意思是把X方法哦隔断值上 Sortkspx(s, l, i - 1); // 递归调用 Sortkspx(s, i + 1, r); } } }输出:
1,2,3,4,5,
几种排序的比较:
1.稳定性比较
插入排序、冒泡排序、二叉树排序、二路归并排序及其他线形排序是稳定的
选择排序、希尔排序、快速排序、堆排序是不稳定的
2.时间复杂性比较
插入排序、冒泡排序、选择排序的时间复杂性为O(n2)
其它非线形排序的时间复杂性为O(nlog2n)
线形排序的时间复杂性为O(n);
3.辅助空间的比较
线形排序、二路归并排序的辅助空间为O(n),其它排序的辅助空间为O(1);
4.其它比较
插入、冒泡排序的速度较慢,但参加排序的序列局部或整体有序时,这种排序能达到较快的速度
反而在这种情况下,快速排序反而慢了。
当n较小时,对稳定性不作要求时宜用选择排序,对稳定性有要求时宜用插入或冒泡排序。
若待排序的记录的关键字在一个明显有限范围内时,且空间允许是用桶排序。
当n较大时,关键字元素比较随机,对稳定性没要求宜用快速排序。
当n较大时,关键字元素可能出现本身是有序的,对稳定性有要求时,空间允许的情况下,宜用归并排序。
当n较大时,关键字元素可能出现本身是有序的,对稳定性没有要求时宜用堆排序。
相关文章推荐
- XML 文档定义有几种形式?它们之间有何本质区别?解析XML 文档有哪几种方式?
- java的list几种实现方式的效率(ArrayList、LinkedList、Vector、Stack),以及 java时间戳的三种获取方式比较
- XML 文档定义有几种形式?它们之间有何本质区别?解析 XML 文档有哪几 种方式?
- OpenGL学习:VAO和VBO以及几种顶点绘图方式比较
- PHP中2种方法快速地合并数组,你知道吗?合并两个数组有几种方式,试比较它们的异同
- Linq排序方式与Lambda排序方式比较以及OrderBy、ThenBy的使用
- 几种物联网实现方式之间的比较+转载
- 比较和排序(IComparable和IComparer以及它们的泛型实现)
- 比较和排序(IComparable和IComparer以及它们的泛型实现)
- 比较和排序(IComparable和IComparer以及它们的泛型实现)
- 比较和排序(IComparable和IComparer以及它们的泛型实现)
- 比较和排序(IComparable和IComparer以及它们的泛型实现)
- XML文档定义有几种形式?它们之间有何本质区别?解析XML文档有哪几种方式?
- PHP数组排序函数合集 以及它们之间的联系分析
- Java - XML文档定义有几种形式?它们之间有何本质区别?解析XML文档有哪几种方式?
- 比较和排序(IComparable和IComparer以及它们的泛型实现)
- 比较和排序(IComparable和IComparer以及它们的泛型实现)
- PHP 数组的遍历的几种方式(以及foreach与for/while+each效率的比较)
- 比较和排序(IComparable和IComparer以及它们的泛型实现)
- 比较和排序(IComparable和IComparer以及它们的泛型实现)