1.排序
1.1 稳定性
排序的稳定性:稳定和不稳定
稳定排序:冒泡、直接插入、归并
不稳定排序:简单选择、希尔排序、堆排序、快速排序
1.2 内排序和外排序
内排序和外排序:
内排序在整个排序过程中,待排序的所有记录全部被房子在内存中。外排序是由于排序的记录个数太多,不能同时放置在内存,整个排序过程需要在内外存之间多次交换数据才能进行。
内排序,排序算法的性能影响因素:
(1)时间性能
(2)辅助空间
(3)算法复杂性
内排序:
插入排序(直接插入、希尔排序)
交换排序(冒泡排序、快速排序)
选择排序(简单选择、堆排序)
归并排序(归并排序)
1.3 七种排序算法:
根据算法复杂度可分为两大类:简单算法和改进算法
简单算法:冒泡排序、简单选择排序、直接插入排序
改进算法:希尔排序、堆排序、归并排序、快速排序
2.排序算法
2.1冒泡排序
基本思想:两两比较相邻记录的关键字,如果反序则交换,直到没有反序的记录为止。
三种冒泡排序:
(1)不标准的冒泡排序:一个和全部的进行两两比较
(2)标准的冒泡排序:每次都是相邻两两比较
(3)优化的冒泡排序:设置标志位,在已经有序的情况下不再进行多余的比较
(交换排序类)
稳定性:稳定排序
时间复杂度:O(n2)
//不是很标准的冒泡排序
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(n2)
//简单选择排序
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(n2)
//直接插入排序
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(n3/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);
}
}