常见的排序算法哪个效率最高

java排序，效率高的是哪种排序方法~

和所有其他语言是一样的。应该还是快速排序效率最高。

public static void bubbleSort(int a[]) {
int len = a.length;
for (int i = 0; i < len - 1; i++) {
for (int j = 0; j < len - 1 - i; j++) {
if (a[j] > a[j + 1]) {
int temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
}
}
public static void selectSort(int a[]) {
int temp = 0;
int len = a.length;
for (int i = 0; i < len - 1; i++) {
int min = a[i];
int index = i;
for (int j = i + 1; j < len; j++) {
if (min > a[j]) {
min = a[j];
index = j;
}
}
temp = a[i];
a[i] = a[index];
a[index] = temp;
}
}
public static void insertSort(int a[]) {
int len = a.length;
for (int i = 1; i < len; i++) {
int temp = a[i];// 待插入的值
int index = i;// 待插入的位置
while (index > 0 && a[index - 1] > temp) {
a[index] = a[index - 1];// 待插入的位置重新赋更大的值
index--;// 位置往前移
}
a[index] = temp;
}
}
public static int partition(int a[], int low, int height) {
int key = a[low];
while (low < height) {
while (low = key)
height--;
a[low] = a[height];
while (low < height && a[low] <= key)
low++;
a[height] = a[low];
}
a[low] = key;
return low;
}
public static void quickSort(int a[], int low, int height) {
if (low < height) {
int result = partition(a, low, height);
quickSort(a, low, result - 1);
quickSort(a, result + 1, height);
}
}
测试结果
------------------------------------------
测试数据10000
冒泡排序：120ms
选择排序：32ms
插入排序：20ms
快速排序：7ms
------------------------------------------
测试数据100000
冒泡排序：13098ms
选择排序：2334ms
插入排序：1264ms
快速排序：23ms
效率差距很大啊！！！！

　　一、冒泡排序
　　已知一组无序数据a[1]、a[2]、……a[n]，需将其按升序排列。首先比较a[1]与 a[2]的值，若a[1]大于a[2]则交换 两者的值，否则不变。再比较a[2]与a[3]的值，若a[2]大于a[3]则交换两者的值，否则不变。再比 较a[3]与a[4]，以此 类推，最后比较a[n-1]与a[n]的值。这样处理一轮后，a[n]的值一定是这组数据中最大的。再对a[1]~a[n- 1]以相同方法 处理一轮，则a[n-1]的值一定是a[1]~a[n-1]中最大的。再对a[1]~a[n-2]以相同方法处理一轮，以此类推。共处理 n-1 轮 后a[1]、a[2]、……a[n]就以升序排列了。
　　优点：稳定；
　　缺点：慢，每次只能移动相邻两个数据。

　　二、选择排序
　　每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数 据元素排完。
　　选择排序是不稳定的排序方法。
　　n 个记录的文件的直接选择排序可经过n-1 趟直接选择排序得到有序结果：
　　①初始状态：无序区为R[1..n]，有序区为空。
　　②第1 趟排序 在无序区R[1..n]中选出关键字最小的记录R[k]，将它与无序区的第1 个记录R[1]交换，使R[1..1]和R[2..n]分别变 为记录个数增加1 个的新有序区和记录个数减少1 个的新无序区。
　　③第i 趟排序
　　第i 趟排序开始时，当前有序区和无序区分别为R[1..i-1]和R(1≤i≤n-1)。该趟 排序从当前无序区中选出关键字最 小的记录 R[k]，将它与无序区的第1 个记录R 交换，使R[1..i]和R 分别变为记录个数增加1 个的新有序区和记录个数减少 1 个的新无序区。
　　这样，n 个记录的文件的直接选择排序可经过n-1 趟直接选择排序得到有序结果。
　　优点：移动数据的次数已知（n-1 次）；
　　缺点：比较次数多。

　　三、插入排序
　　已知一组升序排列数据a[1]、a[2]、……a[n]，一组无序数据b[1]、 b[2]、……b[m]，需将二者合并成一个升序数列。 首先比较b[1]与a[1]的值，若b[1]大于a[1]，则跳过，比较b[1]与a[2]的值， 若b[1]仍然大于a[2]，则继续跳过，直 到b[1]小于a 数组中某一数据a[x]，则将a[x]~a[n]分别向后移动一位，将b[1]插入到原来 a[x]的位置这就完成了b[1] 的插入。b[2]~b[m]用相同方法插入。（若无数组a，可将b[1]当作n=1 的数组a）
　　优点：稳定，快；
　　缺点：比较次数不一定，比较次数越少，插入点后的数据移动越多，特别是当数据总量庞大的时候，但用链表可以解决 这个问题。

　　四、缩小增量排序
　　由希尔在1959 年提出，又称希尔排序(shell 排序)。
　　已知一组无序数据a[1]、a[2]、……a[n]，需将其按升序排列。发现当n 不大时，插入 排序的效果很好。首先取一增 量d(d<n)，将a[1]、a[1+d]、a[1+2d]……列为第一组，a[2]、a[2+d]、 a[2+2d]……列为第二组……，a[d]、a[2d]、a[3d]……="" 列为最后一组以次类推，在各组内用插入排序，然后取d'<d，重复上述操="" 作，直到d="1。"
　　优点：快，数据移动少；=""
　　缺点：不稳定，d="" 的取值是多少，应取多少个不同的值，都无法确切知道，只能凭经验来取。=""

　　五、快速排序=""
　　快速排序是冒泡排序的改进版，是目前已知的最快的排序方法。
　　="" 已知一组无序数据a[1]、a[2]、……a[n]，需将其按升序排列。首先任取数据a[x]="" 作为基准。比较a[x]与其它数据并="" 排序，使a[x]排在数据的第k="" 位，并且使a[1]~a[k-1]中的每一个数="" 据a[x]，然后采 用分治的策略分别对a[1]~a[k-1]和a[k+1]~a[n] 两组数据进行快速排序。
　　优点：极快，数据移动少；
　　缺点：不稳定。

快速排序法。

快速排序、归并排序的理想时间复杂度都是O(nlogn)，但是快速排序的时间复杂度并不稳定，最坏情况下复杂度为O(n^2)，所以最理想的算法还是归并排序，但是如果楼主用的是c++的话，algorithm库中有sort()函数

快速排序资料http://baike.baidu.com/link?url=oZNqyzNlL7MijEe79GDpF_lOmxvpjPS0JyMKJKOotoZHgghByc3oqyh5SA1bUqzevVxuTgSBehUlvbgX6cSr7a
归并排序资料http://baike.baidu.com/link?url=ZHHP4p6oykvJkCo0JvmWFnCsjJOaYQx-h89winUXIeWbnFJ1fZjCX8guaeMN8jUz
sort函数使用方法http://baike.baidu.com/link?url=uJvpXObE5iqoRh9SSpbGAHmCQ4WZMoVzWTwGbxib7b7ku8UvG6iYKkDkwVakTeqGMmXh0EyUKNHwzSccGN8Tl_

数据个数不多时无所谓，大数据量时一般以快速排序为最好。
详见http://baike.baidu.com/link?url=ou4b8whqvHkagwWA2c22f15DOv3Uizj1GwVD4cPjLt9HwOCHBwcfiYMDqjILA7ss-ZJ_MsHUN4naASNZ53Vz1q

网页链接

动图你看看就明白了

---

君山区18516305103： 哪种排序算法的效率最高 - ？
于苗盐酸： #includeusing namespace std; sort(a,a+n); 这种算法的复杂度是nlogn写起来比较方便,算法效率比较高的,但不是最高的,这种已经很常用了,除非你是专门搞排序算法的,不然的话,这个已经够用了

君山区18516305103： 请问常用排序算法的效率谁最高? - ？
于苗盐酸： 折半排序法,也叫二分归并排序:程序如下:#includevoid merge(int a[],int p,int q,int r) { int n1=q-p+1,n2=r-q,i,j,k; int l[1002],R[1002]; for (i=1;ifor (j=1;jR[n2+1]=l[n1+1]=999999; i=j=1; for (k=p;k{ if (l[i]{ a[k]=l[i]; i++; } else { a[k]=R[j]; j++; } } } void ...

君山区18516305103： 对大量数据排序,多种排序方法中,哪种最快,效率最高 - ？
于苗盐酸： 直接选择排序>快速排序>基数排序>归并排序 >堆排序>Shell排序>冒泡排序=冒泡排序2 =直接插入排序

君山区18516305103： 请问冒泡排序和选择排序哪个效率更高? - ？
于苗盐酸： 冒泡是所有排序方法中效率最低的.

君山区18516305103： 排序算法中目前最快的是哪种? - ？
于苗盐酸： 快排、堆排序...

君山区18516305103： 性能最好的排序算法是什么? - ？
于苗盐酸： 拿钱让别人替你排! 事实上各种排序方法个有优缺点适用于不同的场合: 排序(Sorting) 插入排序(insertion sort):直接插入排序 希尔排序(shell's sort)(缩小增量排序Diminishing increment sort) 交换排序:冒泡排序(bubble sort)快速排序(quick sort) 选择排序:直接选择排序(straight selection sort),堆排序; 归并排序(merge sort): 分配排序:箱排序(Bin sort),基数排序(radix sort) 更多的自己研究一下. 排序方法的选取主要考虑算法的性能与资源占用.也就是速度和占用的存储空间.

君山区18516305103： 哪一种排序方法最快? - ？
于苗盐酸： 首先,对大多数包含排序应用的程序来说,排序算法的速度并不重要,因为在程序中排序 的工作量并不是很多,或者,与排序相比,程序中其它操作所花费的时间要多得多. 实际上,没有哪一种排序算法永远是最快的,在运行程序的软硬件环境相同的情况下,不同排序算法的速度还与数据的长度、性质以及数据的初始顺序有关.