数据结构排序总结
数据结构排序总结
排序概念：
1，排序要素：稳定性（相同关键字时，相对顺序是否发生变化），时间复杂度，空间复杂度：
2，排序分类：内部排序（内排序适用于记录个数不很多的小文件，计算在内存中），外部排序（外排序则适用于记录个数太多，不能一次将其全部记录放人内存的大文件）
内部排序：
1，插入排序
插入排序(Insertion Sort)的基本思想是：每次将一个待排序的记录，按其关键字大小插入到前面已经排好序的子文件中的适当位置，直到全部记录插入完成为止。
直接插入排序：
假设待排序的记录存放在数组R[1..n]中。初始时，R[1]自成1个有序区，无序区为R[2..n]。从i=2起直至i=n为止，依次将R[i]插入当前的有序区R[1..i-1]中，生成含n个记录的有序区。
JAVA实现：
public class InsertSort2 { public static void main(String[] args) { int[] array = new int[]{2, 3, 5, 8, 9, 0, 7, 5, 1, 6, 8, 7}; sort(array); System.out.println(Arrays.toString(array)); } private static void sort(int[] array) { int n = array.length; for (int i = 1; i < n; i++) { int key = array[i]; int j = i -1; while (j >= 0 && array[j]>key) {//找到位置后，移动数据 array[j + 1] = array[j]; j-=1; } array[j+1] = key; } } }
时间复杂度最大O(N^2)，空间复杂度为O（1），是一稳定的算法
希尔（Shell）排序：
先取一个小于n的整数d1作为第一个增量，把文件的全部记录分成d1个组。所有距离为dl的倍数的记录放在同一个组中。先在各组内进行直接插人排序；然后，取第二个增量d2<d1重复上述的分组和排序，直至所取的增量dt=1(dt<dt-l<…<d2<d1)，即所有记录放在同一组中进行直接插入排序为止。目的是让数组变为基本有序。
public class ShellSort { public static void main(String[] args) { int[] array = new int[]{2, 3, 5, 8, 9, 0, 7, 5, 1, 6, 8, 7, 15}; sort(array); System.out.println(Arrays.toString(array)); } private static void sort(int[] array) { int n = array.length; int h = 1; while (h<n/3) h = 3*h +1; while (h >= 1) { for (int i = h; i < n; i++) {/直接插入排序 for (int j = i; j >= h && (array[j] < array[j - h]); j -= h) { int temp = array[j]; array[j] = array[j - h]; array[j-h]= temp; } } h /=3; } } }
希尔排序最好时间复杂度和平均时间复杂度都是，最坏时间复杂度为
。非稳定的算法，空间复杂度O（1）到O（n）
2，交换排序
交换排序的基本思想是：两两比较待排序记录的关键字，发现两个记录的次序相反时即进行交换，直到没有反序的记录为止。
冒泡排序：
将被排序的记录数组R[1..n]垂直排列，每个记录R[i]看作是重量为R[i].key的气泡。根据轻气泡不能在重气泡之下的原则，从下往上扫描数组R：凡扫描到违反本原则的轻气泡，就使其向上"飘浮"。如此反复进行，直到最后任何两个气泡都是轻者在上，重者在下为止。（第一趟扫描完毕时，"最轻"的气泡就飘浮到该区间的顶部，即关键字最小的记录被放在最高位置R[1]上，先确定a[0],a[1]...）。
public class BubbleSort { public static void main(String[] args) { int[] array = new int[]{2, 3, 5, 8, 9, 0, 4, 5, 1, 6, 8, 7}; sort(array); System.out.println(Arrays.toString(array)); } private static void sort(int[] array) { int n = array.length; for (int i = 0; i < n-1; i++) {//每趟排序确定末尾最大的值 for (int j = 0; j < n-i-1; j++) { if (array[j] >array[j+1]) { int temp = array[j]; array[j] = array[j+1]; array[j+1] = temp; } } } } }
算法为稳定算法，时间复杂度为O（n^2）,空间复杂度为O（1）
快速排序：
时间复杂度O(nlgn)到O（n^2）,不稳定算法,在无序，大数据量的情况下表现良好，使用栈存储，递归树的高度或空间复杂度为O（lgn）到O（n）
/* *快速排序 *O（nlog(n)) */ public static void main(String[] args) { int[] numbers = {10,20,15,0,6,7,2,1,-5,55}; quick(numbers); System.out.print("快速排序后："); Arrays.toString(numbers); } public static void quick(int[] numbers){ if(numbers.length > 0) //查看数组是否为空 { quickSort(numbers, 0, numbers.length-1); } } public int[] quickSort(int[] arr,int low,int high){ if(low <high){ int middle=getMiddle(arr,low,high); quickSort(arr,middle+1,high); quickSort(arr,low,middle-1); } } //在找中间时，排好了序，值传递 public static int getMiddle(int[] arr, int low,int high){ int temp = arr[low]; int middle=low; //数组的第一个作为中轴,和指向中轴的指针 while(low < high) { while(arr[high] > temp&&low<high) //low<high是必须的，因为内循环在递减是high可能小于low { high-=1; }
if(low<high){//在low<high,才交换数据 arr[low] = arr[high]; low+=1;middle=high;//比中轴小的记录移到低端 while(low < high && arr[low] <temp) { low+=1; }
if(low<high){ arr[high] = arr[low] ;high-=1;middle=low; //比中轴大的记录移到高端 } arr[middle] = temp ; //中轴记录到尾 return middle ; // 返回中轴的位置 }
在当前无序区中选取划分的基准关键字是决定算法性能的关键。采用"三者取中"规则，即在当前区间里，将该区间首、尾和中间位置上的关键字比较，取三者之中值（第二大）所对应的记录作为初始基准，
即不是固定的选a[0]为初始基准。
选择排序：
选择排序(Selection Sort)的基本思想是：每一趟从待排序的记录中选出关键字最小的记录，顺序放在已排好序的子文件的最后，直到全部记录排序完毕。
直接选择排序(Straight Selection Sort)：
第i趟排序开始时，当前有序区和无序区分别为R[1..i-1]和R[i..n](1≤i≤n-1)。该趟排序从当前无序区中选出关键字最小的记录R[k]，将它与无序区的第1个记录R[i]交换，使R[1..i]和R[i+1..n]分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。
public class SelectSort { public static void main(String[] args) { int[] array = new int[]{2, 3, 5, 8, 9, 0, 7, 5, 1, 6, 8, 7}; sort(array); System.out.println(Arrays.toString(array)); } private static void sort(int[] array) { int n = array.length; for (int i = 0; i < n-1; i++) { int min = i; for (int j = i+1; j < n; j++) { if (array[j] < array[min]) min = j; } int temp = array[i]; array[i] = array[min]; array[min] = temp; } } }
直接选择排序的平均时间复杂度为O(n2)，是一个就地排序（若排序算法所需的辅助空间并不依赖于问题的规模n，即辅助空间是O(1)，则称之为就地排序(In-PlaceSou)。非就地排序一般要求的辅助空间为O(n)），是不稳定的
堆排序：
堆排序利用了大根堆(或小根堆)堆顶记录的关键字最大(或最小)这一特征，使得在当前无序区中选取最大(或最小)关键字的记录变得简单。
（1）用大根堆排序的基本思想
① 先将初始文件R[1..n]建成一个大根堆，此堆为初始的无序区
② 再将关键字最大的记录R[1](即堆顶)和无序区的最后一个记录R[n]交换，由此得到新的无序区R[1..n-1]和有序区R[n]，且满足R[1..n-1].keys≤R[n].key
③ 由于交换后新的根R[1]可能违反堆性质，故应将当前无序区R[1..n-1]调整为堆。然后再次将R[1..n-1]中关键字最大的记录R[1]和该区间的最后一个记录R[n-1]交换，由此得到新的无序区R[1..n-2]和有序区R[n-1..n]，且仍满足关系R[1..n-2].keys≤R[n-1..n].keys，同样要将R[1..n-2]调整为堆。
直到无序区只有一个元素为止。
（2）大根堆排序算法的基本操作：
① 初始化操作：将R[1..n]构造为初始堆；
② 每一趟排序的基本操作：将当前无序区的堆顶记录R[1]和该区间的最后一个记录交换，然后将新的无序区调整为堆(亦称重建堆)。
import java.util.Arrays; publicclass HeapSort { int a[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51}; public HeapSort(){ heapSort(a); } public void heapSort(int[] a){ System.out.println("开始排序"); int arrayLength=a.length; //循环建堆 for(int i=0;i<arrayLength-1;i++){ //建堆 buildMaxHeap(a,arrayLength-1-i); //交换堆顶和最后一个元素 swap(a,0,arrayLength-1-i); System.out.println(Arrays.toString(a)); } } private void swap(int[] data, int i, int j) { // TODO Auto-generated method stub int tmp=data[i]; data[i]=data[j]; data[j]=tmp; } //对data数组从0到lastIndex建大顶堆 private void buildMaxHeap(int[] data, int lastIndex) { // TODO Auto-generated method stub //从lastIndex处节点（最后一个节点）的父节点开始 for(int i=(lastIndex-1)/2;i>=0;i--){ //k保存正在判断的节点 int k=i; //如果当前k节点的子节点存在 while(k*2+1<=lastIndex){ //k节点的左子节点的索引 int biggerIndex=2*k+1; //如果biggerIndex小于lastIndex，即biggerIndex+1代表的k节点的右子节点存在 if(biggerIndex<lastIndex){ //若果右子节点的值较大 if(data[biggerIndex]<data[biggerIndex+1]){ //biggerIndex总是记录较大子节点的索引 biggerIndex++; } } //如果k节点的值小于其较大的子节点的值 if(data[k]<data[biggerIndex]){ //交换他们 swap(data,k,biggerIndex); //将biggerIndex赋予k，开始while循环的下一次循环，重新保证k节点的值大于其左右子节点的值 k=biggerIndex; }else{ break; } } } } }
堆排序的最坏时间复杂度为O(nlgn)，由于建初始堆所需的比较次数较多，所以堆排序不适宜于记录数较少的文件，堆排序是就地排序，辅助空间为O(1)，不稳定的算法
归并排序：
设两个有序的子文件(相当于输入堆)放在同一向量中相邻的位置上：R[low..m]，R[m+1..high]，先将它们合并到一个局部的暂存向量R1(相当于输出堆)中，待合并完成后将R1复制回R[low..high]中。
（1）合并过程
合并过程中，设置i，j和p三个指针，其初值分别指向这三个记录区的起始位置。合并时依次比较R[i]和R[j]的关键字，取关键字较小的记录复制到R1[p]中，然后将被复制记录的指针i或j加1，以及指向复制位置的指针p加1。
重复这一过程直至两个输入的子文件有一个已全部复制完毕(不妨称其为空)，此时将另一非空的子文件中剩余记录依次复制到R1中即可。
（2）动态申请R1
实现时，R1是动态申请的，因为申请的空间可能很大，故须加入申请空间是否成功的处理。
1,自顶向下：
设归并排序的当前区间是R[low..high]，分治法的三个步骤是：
① 分解：将当前区间一分为二，即求分裂点
② 求解：递归地对两个子区间R[low..mid]和R[mid+1..high]进行归并排序；
③ 组合：将已排序的两个子区间R[low..mid]和R[mid+1..high]归并为一个有序的区间R[low..high]。
public class MergeSort { public static void main(String[] args) { int[] array = new int[]{2, 3, 5, 8, 9, 0, 7, 5, 1, 6, 8, 7}; mergeSort(array); System.out.println(Arrays.toString(array)); } private static void mergeSort(int[] array) { int[] aux = new int[array.length]; sort(array, aux, 0, array.length - 1); }
private static void sort(int[] array, int[] aux, int lo, int hi) { if (hi<=lo) return; int mid = lo + (hi - lo)/2; sort(array, aux, lo, mid); sort(array, aux, mid + 1, hi); merge(array, aux, lo, mid, hi); }
private static void merge(int[] array, int[] aux, int lo, int mid, int hi) { System.arraycopy(array,0,aux,0,array.length); int i = lo, j = mid + 1; for (int k = lo; k <= hi; k++) { if (i>mid) array[k] = aux[j++]; else if (j > hi) array[k] = aux[i++]; else if (aux[j]<aux[i]) array[k] = aux[j++]; else array[k] = aux[i++]; } } }
http://blog.csdn.net/guanhang89/article/details/51902378#归并排序
