Java七种排序算法!
2014-01-25 00:22
295 查看
冒泡排序、选择排序、快速排序、插入排序、希尔排序、归并排序、堆排序
Java排序算法
1)分类:
1)插入排序(直接插入排序、希尔排序)
2)交换排序(冒泡排序、快速排序)
3)选择排序(直接选择排序、堆排序)
4)归并排序
5)分配排序(箱排序、基数排序)
所需辅助空间最多:归并排序
所需辅助空间最少:堆排序
平均速度最快:快速排序
不稳定:快速排序,希尔排序,堆排序。
1)选择排序算法的时候
1.数据的规模; 2.数据的类型 ; 3.数据已有的顺序
一般来说,当数据规模较小时,应选择直接插入排序或冒泡排序。任何排序算法在数据量小时基本体现不出来差距。考虑数据的类型,比如如果全部是正整数,那么考虑使用桶排序为最优。 考虑数据已有顺序,快排是一种不稳定的排序(当然可以改进),对于大部分排好的数据,快排会浪费大量不必要的步骤。数据量极小,而起已经基本排好序,冒泡是最佳选择。我们说快排好,是指大量随机数据下,快排效果最理想。而不是所有情况。
3)总结:
——按平均的时间性能来分:
1)时间复杂度为O(nlogn)的方法有:快速排序、堆排序和归并排序,其中以快速排序为最好;
2)时间复杂度为O(n2)的有:直接插入排序、起泡排序和简单选择排序,其中以直接插入为最好,特别是对那些对关键字近似有序的记录序列尤为如此;
3)时间复杂度为O(n)的排序方法只有,基数排序。
当待排记录序列按关键字顺序有序时,直接插入排序和起泡排序能达到O(n)的时间复杂度;而对于快速排序而言,这是最不好的情况,此时的时间性能蜕化为O(n2),因此是应该尽量避免的情况。简单选择排序、堆排序和归并排序的时间性能不随记录序列中关键字的分布而改变。
——按平均的空间性能来分(指的是排序过程中所需的辅助空间大小):
1) 所有的简单排序方法(包括:直接插入、起泡和简单选择)和堆排序的空间复杂度为O(1);
2) 快速排序为O(logn ),为栈所需的辅助空间;
3) 归并排序所需辅助空间最多,其空间复杂度为O(n );
4)链式基数排序需附设队列首尾指针,则空间复杂度为O(rd )。
——排序方法的稳定性能:
1) 稳定的排序方法指的是,对于两个关键字相等的记录,它们在序列中的相对位置,在排序之前和 经过排序之后,没有改变。
2) 当对多关键字的记录序列进行LSD方法排序时,必须采用稳定的排序方法。
3) 对于不稳定的排序方法,只要能举出一个实例说明即可。
4) 快速排序,希尔排序和堆排序是不稳定的排序方法。
Java排序算法
1)分类:
1)插入排序(直接插入排序、希尔排序)
2)交换排序(冒泡排序、快速排序)
3)选择排序(直接选择排序、堆排序)
4)归并排序
5)分配排序(箱排序、基数排序)
所需辅助空间最多:归并排序
所需辅助空间最少:堆排序
平均速度最快:快速排序
不稳定:快速排序,希尔排序,堆排序。
1)选择排序算法的时候
1.数据的规模; 2.数据的类型 ; 3.数据已有的顺序
一般来说,当数据规模较小时,应选择直接插入排序或冒泡排序。任何排序算法在数据量小时基本体现不出来差距。考虑数据的类型,比如如果全部是正整数,那么考虑使用桶排序为最优。 考虑数据已有顺序,快排是一种不稳定的排序(当然可以改进),对于大部分排好的数据,快排会浪费大量不必要的步骤。数据量极小,而起已经基本排好序,冒泡是最佳选择。我们说快排好,是指大量随机数据下,快排效果最理想。而不是所有情况。
3)总结:
——按平均的时间性能来分:
1)时间复杂度为O(nlogn)的方法有:快速排序、堆排序和归并排序,其中以快速排序为最好;
2)时间复杂度为O(n2)的有:直接插入排序、起泡排序和简单选择排序,其中以直接插入为最好,特别是对那些对关键字近似有序的记录序列尤为如此;
3)时间复杂度为O(n)的排序方法只有,基数排序。
当待排记录序列按关键字顺序有序时,直接插入排序和起泡排序能达到O(n)的时间复杂度;而对于快速排序而言,这是最不好的情况,此时的时间性能蜕化为O(n2),因此是应该尽量避免的情况。简单选择排序、堆排序和归并排序的时间性能不随记录序列中关键字的分布而改变。
——按平均的空间性能来分(指的是排序过程中所需的辅助空间大小):
1) 所有的简单排序方法(包括:直接插入、起泡和简单选择)和堆排序的空间复杂度为O(1);
2) 快速排序为O(logn ),为栈所需的辅助空间;
3) 归并排序所需辅助空间最多,其空间复杂度为O(n );
4)链式基数排序需附设队列首尾指针,则空间复杂度为O(rd )。
——排序方法的稳定性能:
1) 稳定的排序方法指的是,对于两个关键字相等的记录,它们在序列中的相对位置,在排序之前和 经过排序之后,没有改变。
2) 当对多关键字的记录序列进行LSD方法排序时,必须采用稳定的排序方法。
3) 对于不稳定的排序方法,只要能举出一个实例说明即可。
4) 快速排序,希尔排序和堆排序是不稳定的排序方法。
/** * 七种排序算法Java版 * @author Administrator */ public class Sort { /** * 打印数组 * @param data */ public static void displayData(int[] data) { for (int d : data) { System.out.print(d + " "); } System.out.println(); } /** * 冒泡排序算法,时间复杂度O(n2),算法具有稳定性,堆排序和快速排序算法不具有稳定性,即排序后相同元素的顺序会发生变化 * @param src */ public static void bubbleSort(int[] src) { if (src.length > 0) { int length = src.length; for (int i = 1; i < length; i++) { for (int j = 0; j < length - i; j++) { if (src[j] > src[j + 1]) { int temp = src[j]; src[j] = src[j + 1]; src[j + 1] = temp; } } } } }
/** * 快速排序,时间复杂度O(nlogn),最坏时间复杂度O(n2),平均时间复杂度O(nlogn),算法不具稳定性 * @param src * @param begin * @param end */ public static void quickSort(int[] src, int begin, int end) { if (begin < end) { int key = src[begin]; int i = begin; int j = end; while (i < j) { while (i < j && src[j] > key) { j--; } if (i < j) { src[i] = src[j]; i++; } while (i < j && src[i] < key) { i++; } if (i < j) { src[j] = src[i]; j--; } } src[i] = key; quickSort(src, begin, i - 1); quickSort(src, i + 1, end); } } /** * 选择排序,分为简单选择排序、树形选择排序(锦标赛排序)、堆排序 此算法为简单选择排序 * @param a */ public static void selectSort(int[] a) { int length = a.length; for (int i = 0; i < length; i++) { int minIndex = i; for (int j = i + 1; j < a.length; j++) { if (a[j] < a[minIndex]) { minIndex = j; } } if (minIndex != i) { int temp = a[minIndex]; a[minIndex] = a[i]; a[i] = temp; } } } /** * 插入排序,适用于少量数据的排序,时间复杂度O(n2),是稳定的排序算法,原地排序 * @param a */ public static void insertSort(int[] a) { int length = a.length; for (int i = 1; i < length; i++) { int temp = a[i]; int j = i; for (; j > 0 && a[j - 1] > temp; j--) { a[j] = a[j - 1]; } a[j] = temp; } } /** * 归并排序算法,稳定排序,非原地排序,空间复杂度O(n),时间复杂度O(nlogn) * @param a * @param low * @param high */ public static void mergeSort(int a[], int low, int high) { if (low < high) { mergeSort(a, low, (low + high) / 2); mergeSort(a, (low + high) / 2 + 1, high); merge(a, low, (high + low) / 2, high); } }
/** * 归并排序辅助方法,合并 * * @param a * @param low * @param mid * @param high */ private static void merge(int[] a, int low, int mid, int high) { int[] b = new int[high - low + 1]; int s = low; int t = mid + 1; int k = 0; while (s <= mid && t <= high) { if (a[s] <= a[t]) b[k++] = a[s++]; else b[k++] = a[t++]; } while (s <= mid) b[k++] = a[s++]; while (t <= high) b[k++] = a[t++]; for (int i = 0; i < b.length; i++) { a[low + i] = b[i]; } /** * 希尔排序的一种实现方法 * * @param a */ public static void shellSort(int[] a) { int temp; for (int k = a.length / 2; k > 0; k /= 2) { for (int i = k; i < a.length; i++) { for (int j = i; j >= k; j -= k) { if (a[j - k] > a[j]) { temp = a[j - k]; a[j - k] = a[j]; a[j] = temp; } } } } } /** * 堆排序,最坏时间复杂度O(nlog2n),平均性能接近于最坏性能。由于建初始堆所需的比较次数多,故堆不适合记录较少的比较 堆排序为原地不稳定排序 * * @param array */ public static void heapSort(int[] array) { for (int i = 1; i < array.length; i++) { makeHeap(array, i); } for (int i = array.length - 1; i > 0; i--) { int temp = array[i]; array[i] = array[0]; array[0] = temp; rebuildHeap(array, i); } } /** * 堆排序辅助方法---创建堆 * * @param array * @param k */ private static void makeHeap(int[] array, int k) { int current = k; while (current > 0 && array[current] > array[(current - 1) / 2]) { int temp = array[current]; array[current] = array[(current - 1) / 2]; array[(current - 1) / 2] = temp; current = (current - 1) / 2; } } /** * 堆排序辅助方法---堆的根元素已删除,末尾元素已移到根位置,开始重建 * * @param array * @param size */ private static void rebuildHeap(int[] array, int size) { int currentIndex = 0; int right = currentIndex * 2 + 2; int left = currentIndex * 2 + 1; int maxIndex = currentIndex; boolean isHeap = false; while (!isHeap) { if (left < size && array[currentIndex] < array[left]) { maxIndex = left; } if (right < size && array[maxIndex] < array[right]) { maxIndex = right; } if (currentIndex == maxIndex) { isHeap = true; } else { int temp = array[currentIndex]; array[currentIndex] = array[maxIndex]; array[maxIndex] = temp; currentIndex = maxIndex; right = currentIndex * 2 + 2; left = currentIndex * 2 + 1; } } } public static void main(String[] args) { int data[] = { 2, -1, 5, 4, 6, 8, 7, -3 }; Sort.displayData(data); Sort.bubbleSort(data); Sort.displayData(data); } }
相关文章推荐
- java编程规范(常用的)
- String 值传递or引用传递
- Eclipse debug调试
- Ubuntu安装JDK及环境变量配置(sun java)
- Eclipse启动时fail to create Java Virtual Machine问题的解决
- Spring配置ibatis的十种方法
- JavaSE 第二章 JDK安装与第一个程序
- eclipse debug (调试) 学习心得
- [Java] JRebel + Maven + Jetty 热部署
- Eclipse插件开发系列文章---序
- Eclpse 标准版,在联想一体机上报 eclipse failed to create the java virtual machine
- Eclpse 标准版,在联想一体机上报 eclipse failed to create the java virtual machine
- Eclpse 标准版,在联想一体机上报 eclipse failed to create the java virtual machine
- struts2 jsp页面取值
- struts2 多文件上传
- java_jdbc_基本连接池
- 关于sqlite4java内存不断增长的解决
- java中的二维数组
- java中的类|!
- java程序写法!