6.归并排序
- 思想：运用分治法思想先使每个子序列有序，再将两个已经排序的序列合并成一个序列的操作。若将两个有序表合并成一个有序表，称为二路归并。
- 时间复杂度：平均、最佳、最差时间复杂度均为O(nlgn)
- 代码如下：一般用递归求解：
package xianggen.sortsummary;
/**
*
* MergeSort.java
* @author xianggen
* @date 2016年7月25日 下午3:31:00
*/
public class MergeSort {
public static void main(String[] args) {
int[] arr={3,5,7,1,4,2,8,9,0,6};
recursiveMergeSort(arr,0,arr.length-1);
for(int i=0;i<arr.length;i++)
System.out.print(arr[i]+" ");
System.out.println();
}
public static int[] recursiveMergeSort(int[] arr, int low, int high) {
int mid = (low + high) / 2;
if (low < high) {
// 左边
recursiveMergeSort(arr, low, mid);
// 右边
recursiveMergeSort(arr, mid + 1, high);
// 左右归并
merge(arr, low, mid, high);
}
return arr;
}
public static void merge(int[] arr, int low, int mid, int high) {
int[] temp = new int[high - low + 1];
int i = low;// 左指针
int j = mid + 1;// 右指针
int k = 0;
// 把较小的数先移到新数组中
while (i <= mid && j <= high) {
if (arr[i] < arr[j]) {
temp[k++] = arr[i++];
} else {
temp[k++] = arr[j++];
}
}
// 把左边剩余的数移入数组
while (i <= mid) {
temp[k++] = arr[i++];
}
// 把右边边剩余的数移入数组
while (j <= high) {
temp[k++] = arr[j++];
}
// 把新数组中的数覆盖arr数组
for (int k2 = 0; k2 < temp.length; k2++) {
arr[k2 + low] = temp[k2];
}
}
}
7.堆排序
二叉堆：二叉堆是完全二叉树或者是近似完全二叉树。
父结点的键值总是大于或等于（小于或等于）任何一个子节点的键值。
每个结点的左子树和右子树都是一个二叉堆。
其它几种堆（二项式堆，斐波纳契堆等）用的较少，一般将二叉堆就简称为堆。堆排序是原址排序，同快排，空间开销小！
- 思想：初始时把要排序的n个数的序列看作是一棵顺序存储的完全二叉树（一维数组存储二叉树），调整它们的存储序，使之成为一个堆，将堆顶元素输出，得到n 个元素中最小(或最大)的元素，这时堆的根节点的数最小（或者最大）。然后对前面(n-1)个元素重新调整使之成为堆，输出堆顶元素，得到n 个元素中次小(或次大)的元素。依此类推，直到只有两个节点的堆，并对它们作交换，最后得到有n个节点的有序序列。称这个过程为堆排序。
- 时间复杂度：平均、最佳、最差时间复杂度均为O(nlogn )
- **代码如下：实现堆排序需解决两个问题：1. 如何将n 个待排序的数建成堆；2. 输出堆顶元素后，怎样调整剩余n-1 个元素，使其成为一个新堆。
先上图解：
package xianggen.sortsummary;
/**
* 堆排序！
* 两个过程：建堆，堆顶与堆的最后一个元素交换位置
* HeapSort.java
* @author xianggen
* @date 2016年8月16日 上午10:18:14
*/
public class HeapSort {
public static void main(String[] args) {
int[] arr={3,5,7,1,4,2,8,9,0,6};
heapSort(arr,arr.length);
printHeap(arr);
}
public static void heapSort(int[] arr,int length){
buildHeap(arr,length);
for(int i=arr.length-1;i>0;i--){
swap(arr,0,i);
heapAdjust(arr,0,i);
}
}
/**
* 堆初始数组建最大堆！
* arr[0..length-1]建成堆 ，其中arr[0]为最大值，将其与arr[length-1]交换
* @param arr,length
*/
public static void buildHeap(int[] arr,int length){
//!!! 从最后一个有孩子的节点的位置开始堆调整： i= (length -1) / 2
for(int i=(length-1)/2;i>=0;i--){
heapAdjust(arr,i,length);
}
}
/**
* 这是堆排序的关键操作！！功能将一个节点拖拽至子树的合适位置！
* @param arr
* @param index
* @param length
*/
public static void heapAdjust(int[]arr, int index,int length){
int tmp=arr[index],child=2*index+1; //左孩子结点的位置
while(child<length){
if(child+1<length&&arr[child]<arr[child+1]){
child++; //如果位于index的节点有右孩子且其值比左孩子大，则得到右孩子的索引值
}
if(arr[index]<arr[child]){ // 若父节点小于孩子(较大的)，则把父节点拖拽下来
arr[index]=arr[child];
index=child;
child=2*index+1; //注意这个更新，千万不要忘记。(保持刚开始时child指向的是左孩子)
}else{
break; //！！！ 如果当前待调整结点大于它的左右孩子，则不需要调整，直接退出
}
arr[index]=tmp; // 当前待调整的结点放到比其大的孩子结点位置上
}
}
public static void swap(int[] arr,int i,int j){
int tmp=arr[i];
arr[i]=arr[j];
arr[j]=tmp;
}
public static void printHeap(int[] arr){
for(int i=0;i<arr.length;i++)
System.out.print(arr[i]+" ");
System.out.println();
}
}
8.计数排序
http://www.cnblogs.com/eaglet/archive/2010/09/16/1828016.html
计数排序是一个类似于桶排序的排序算法，其优势是对已知数量范围的数组进行排序。它创建一个长度为这个数据范围的数组C，C中每个元素记录要排序数组中对应记录的出现个数。这个算法于1954年由 Harold H. Seward 提出。
依靠一个辅助数组来实现，不基于比较，算法复杂度为 O(n) ，但由于要一个辅助数组C，所以空间复杂度要大一些，由于计算机的内存有限，这种算法不适合范围很大的数的排序。
最坏情况运行时间：O(n+k)；最好情况运行时间：O(n+k)，k为待排数组中的最大值。
看一个例子：
/**
*
* CountingSort.java
* @author xianggen
* @date 2016年8月16日 下午2:51:08
*/
public class CountingSort {
public static void main(String[] args) {
int[] arr={3,3,7,1,4,2,8,19,0,6};
int[] res=countSort(arr);
printHeap(res);
}
public static int[] countSort(int[] arr){
int max=arr[0];
for(int i=1;i<arr.length;i++)
if(arr[i]>max)
max=arr[i];
int[] tmpArr=new int[max+1];
int[] res=new int[arr.length];
for(int i=0;i<arr.length;i++)
tmpArr[arr[i]]++; //此时res[i]表示等于i的元素个数
for(int i=1;i<=max;i++)
tmpArr[i]+=tmpArr[i-1]; //此时res[i]表示小于或者等于i的元素个数
// 把输入数组中的元素放在输出数组中对应的位置
for(int i=arr.length-1;i>=0;i--){
res[tmpArr[arr[i]]-1]=arr[i]; // 用tmpArr数组来确定arr[i]的下标！
tmpArr[arr[i]]--; // 该操作使得下一个值为arr[i]的元素直接进入输出数组中arr[i]的前一个位置
}
return res;
}8.基数排序
http://www.cnblogs.com/Braveliu/archive/2013/01/21/2870201.html
根据从低位还是从高位开始排序，基数排序分为两种：LSD（Least significant digital）或MSD（Most significant digital）
待排数组：73 22 93 43 55 14 28 65 39 81
使用LSD排序：先根据个位数的数值，在遍历数据时将它们各自分配到编号0至9的桶（个位数值与桶号一一对应）中；接着根据十位数值再进行一次分配。
每位基于计数排序：
package xianggen.sortsummary;
/**
* 基数排序，假定每位的排序是计数排序
* RadixSort.java
* @author xianggen
* @date 2016年8月16日 下午5:34:48
*/
public class RadixSort {
public static void main(String[] args) {
int[] arr={3,3,7,1,4,2,8,11,0,6};
radixSort(arr);
}
public static void radixSort(int[] arr){
int d=getOffset(arr);
int radix=10;
int[] count=new int[radix];
int[] bucket=new int[arr.length];
// 按照从低位到高位的顺序执行排序过程
for(int i=0;i<d;i++){
// 置空各个桶的数据统计,这个操作一定不能忘记！
for (int j=0; j<radix; j++) {
count[j] = 0;
}
// 统计各个桶将要装入的数据个数
for(int j=0;j<arr.length;j++){
count[getDigit(arr[j],i)]++;
}
for(int j=1;j<radix;j++)
count[j]=count[j]+count[j-1];
// 将数据依次装入桶中,从右向左扫描，保证排序稳定性
for(int j=arr.length-1;j>=0;j--){
int index=getDigit(arr[j],i);
bucket[count[index]-1]=arr[j];
count[index]--;
}
// 将已分配好的桶中数据再倒出来，此时已是对应当前位数有序的表
for(int j=0;j<bucket.length;j++)
arr[j]=bucket[j];
}
for(int j=0;j<bucket.length;j++)
System.out.print(arr[j]+" ");
System.out.println();
}
/**
* 获取数组中元素中最大的位数！
* @param arr
* @return
*/
public static int getOffset(int[] arr){
int result=1;
for(int i=0;i<arr.length;i++){
int tmp=1,k=10;
while(arr[i]>=k){
k*=10;
tmp++;
}
if(tmp>result)
result=tmp;
}
return result;
}
/**
* // 获取number这个数的(d+1)位数上的数字,从右往左开始(个位计起)
* @param number
* @param d
* @return
*/
public static int getDigit(int number,int d){
int a[]={1,10,100};
return ((number/a[d])%10);
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
