数据结构-排序

1.排序

1.1 稳定性

排序的稳定性：稳定和不稳定
稳定排序：冒泡、直接插入、归并
不稳定排序：简单选择、希尔排序、堆排序、快速排序

1.2 内排序和外排序

内排序和外排序：
内排序在整个排序过程中，待排序的所有记录全部被房子在内存中。外排序是由于排序的记录个数太多，不能同时放置在内存，整个排序过程需要在内外存之间多次交换数据才能进行。

内排序，排序算法的性能影响因素：
（1）时间性能
（2）辅助空间
（3）算法复杂性

内排序：
插入排序（直接插入、希尔排序）
交换排序（冒泡排序、快速排序）
选择排序（简单选择、堆排序）
归并排序（归并排序）

1.3 七种排序算法：

根据算法复杂度可分为两大类：简单算法和改进算法
简单算法：冒泡排序、简单选择排序、直接插入排序
改进算法：希尔排序、堆排序、归并排序、快速排序

2.排序算法

2.1冒泡排序

基本思想：两两比较相邻记录的关键字，如果反序则交换，直到没有反序的记录为止。
三种冒泡排序:
（1）不标准的冒泡排序：一个和全部的进行两两比较
（2）标准的冒泡排序：每次都是相邻两两比较
（3）优化的冒泡排序：设置标志位，在已经有序的情况下不再进行多余的比较
（交换排序类）
稳定性：稳定排序
时间复杂度：O（n²）

	//不是很标准的冒泡排序
	public static void bubbleSort1(int[] array) {
		int i,j;
		for(i=0;i<array.length-1;i++) {
			for(j=i+1;j<array.length;j++) {
				if(array[i]>array[j]) {
					int temp=array[i];
					array[i]=array[j];
					array[j]=temp;
				}
			}
		}	
	}
	//标准的冒泡排序
	public static void bubbleSort2(int[] array) {
		int i,j;
		for(i=0;i<array.length;i++) {
			for(j=array.length-2;j>=i;j--) {
				if(array[j]>array[j+1]) {
					int temp=array[j];
					array[j]=array[j+1];
					array[j+1]=temp;
				}
			}
		}	
	}
	//优化后的冒泡排序
	public static void bubbleSort3(int[] array) {
		int i,j;
		boolean flag=true;
		for(i=0;i<array.length && flag;i++) {
			flag=false;
			for(j=array.length-2;j>=i;j--) {
				if(array[j]>array[j+1]) {
					int temp=array[j];
					array[j]=array[j+1];
					array[j+1]=temp;
					flag=true;
				}
			}
		}	
	}

2.2简单选择排序

基本思想：通过n-i次关键字的比较，从n-i+个记录中选出关键字最小的记录，并和第i个记录交换。
（和上面那个不标准的冒泡排序有点像，但是选择排序针对的是数组下标）
（选择排序类）
稳定性：不稳定排序
时间复杂度：O（n²）

	//简单选择排序
	public static void simpleSelectSort(int[] array) {
		int i,j,min;
		for(i=0;i<array.length;i++) {
			min=i;
			for(j=i+1;j<array.length;j++) {
				if(array[min]>array[j]) {
					min=j;
				}
			}
			if(i!=min) {
				int temp=array[i];
				array[i]=array[min];
				array[min]=temp;
			}
		}
	}

2.3直接插入排序

基本思想：将一个记录插到已经排好序的有序表中，从而得到一个新的、记录数增1的有序表。
（插入排序类）
稳定性：稳定排序
时间复杂度：O（n²）

	//直接插入排序
	public static void straightInsertSort(int []a) {
		int i,j,k;
		for(i=1;i<a.length;i++) {
			for(j=i-1;j>=0;j--) {
				if(a[j]<a[i]) {
					break;
				}
			}
			if(j!=i-1) {
				int temp=a[i];
				for(k=i-1;k>j;k--) {
					a[k+1]=a[k];
				}
				a[k+1]=temp;
			}
		}
	}

2.4希尔排序

基本思想：缩小增量排序
（插入排序的升级，插入排序类）
稳定性：不稳定排序
时间复杂度：O（n^3/2）

    //希尔排序
	public static void shellSort(int[]list) {
		int gap=list.length/2;
		while(1<=gap) {
			for(int i=gap;i<list.length;i++) {
				int j=0;
				int temp=list[i];
				for(j=i-gap;j>=0 && temp<list[j];j=j-gap) {
					list[j+gap]=list[j];
				}
				list[j+gap]=temp;
			}
			gap=gap/2;
		}
		
	}

2.5堆排序

基本思想：大顶堆。建大顶堆、移走最大元素（根结点）、重建堆…
（简单选择排序的升级，选择排序类）
稳定性：不稳定排序
时间复杂度：O（nlogn）

	//堆排序
	public static void heapSort(int []arr){
		//构建大顶堆
		for(int i=arr.length/2-1;i>=0;i--) {
			//从第一个非叶子结点从下往上
			adjustHeap(arr,i,arr.length);
		}
		//调整堆结构+交换堆顶元素和末尾元素
		for(int j=arr.length-1;j>0;j--) {
			swap(arr,0,j);//将堆顶元素与末尾元素进行交换
			adjustHeap(arr,0,j);//重新对堆进行调整
		}
	}
	//调整大顶堆
	public static void adjustHeap(int []arr,int i,int length) {
		int temp=arr[i];//先取出当前元素i
		for(int k=i*2+1;k<length;k=k*2+1) {
			//从i的结点的左子结点开始,也就是2i+1处开始
			if(k+1<length && arr[k]<arr[k+1]) {
				//如果左子结点小于右子结点,k指向右子结点
				k++;
			}
			if(arr[k]>temp) {
				//如果子结点大于父结点,将子结点值赋给父结点（不用进行交换）
				arr[i]=arr[k];
				i=k;	
			}else {
				break;
			}
		}
		arr[i]=temp;//将temp值放到最终的位置
	}
	//交换元素
	public static void swap(int []arr,int a,int b) {
		int temp=arr[a];
		arr[a]=arr[b];
		arr[b]=temp;
	}

2.6归并排序

基本思想：n个有序的子序列，两两归并。2路归并排序
稳定性：稳定排序
时间复杂度：O（nlogn）
空间复杂度：O（n）

    //归并排序
    public static void mergeSort(int []arr) {
		int []temp=new int[arr.length];
		mergeSort(arr,0,arr.length-1,temp);
	}
	
	private static void mergeSort(int[] arr,int left,int right,int[] temp) {
		if(left<right) {
			int mid =(left+right)/2;
			mergeSort(arr,left,mid,temp);
			mergeSort(arr,mid+1,right,temp);
			merge(arr,left,mid,right,temp);
		}
	}
	
	private static void merge(int[] arr,int left,int mid,int right,int[] temp) {
		int i=left;
		int j=mid+1;
		int t=0;
		while(i<=mid && j<=right){
			if(arr[i]<=arr[j]) {
				temp[t++]=arr[i++];
			}else {
				temp[t++]=arr[j++];
			}
		}
		while(i<=mid){
			temp[t++]=arr[i++];
		}
		while(j<=right){
			temp[t++]=arr[j++];
		}
		t=0;
		while(left<=right) {
			arr[left++]=temp[t++];
		}
	}

2.7快速排序

基本思想：通过一趟排序将待排记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，可分别对这两部分的记录继续进行排序，达到整个序列有序的目的。
（冒泡排序的升级，交换排序类）
稳定性：不稳定排序
时间复杂度：O（nlogn）
空间复杂度：O（nlogn）

	//快速排序
	public static void quickSort(int []a,int l,int r) {
		//前提是右大于左
		if(l<r) {
			int i,j,x;
			i=l;
			j=r;
			x=a[i];
			while(i<j) {
				//从右往左比较
				while(i<j && a[j]>x) {
					j--;
				}
				if(i<j) {
					a[i++]=a[j];
				}
				//从左往右比较
				while(i<j && a[i]<x) {
					i++;
				}
				if(i<j) {
					a[j--]=a[i];
				}
			}
			a[i]=x;
			quickSort(a,l,i-1);
			quickSort(a,i+1,r);
		}
		
	}