数据结构排序总结
数据结构排序总结
排序概念:
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#归并排序