排序算法简单整理笔记

简单的学习笔记整理～

比较类排序

一、交换排序

1.冒泡排序

public static void bubbleSort(int[] a){
 	for(int i=0;i<a.length-1;i++){
 		boolean flag=true;//设定一个标记，若为true，则表示此次循环没有交换，也就是待排序列已经有序，排序已然完成
 		for(int j=0;j<a.length-1-i;j++){
				if(a[j]>a[j+1]){
					swap(a,j,j+1);
					flag=false;
				}	
		}
		if(flag) 
			break;
	}
}

2.快速排序

//通过一趟排序后，将原序列分为两部分，其中一部分的所有记录均比后一部分的所有记录小，然后依次堆前后两部分的记录进行快速排序，递归该过程。

public static void sort(int[] a,int low,int high){
	int i,j;
	int index;
	if(low>=high)
		return;
	i=low;
	j=high;
	index=a[i];
	while(i<j){
		while(i<j&&a[j]>index){
			j--;
		}
		if(i<j){
			a[i++]=a[j];
		}
		while(i<j&&a[i]<index){
			i++;
		}
		if(i<j){
			a[j--]=a[i];
		}
	}
	a[i]=index;
	sort(a,low,i-1);
	sort(a,i+1,high);
}
public static void quickSort(int[] a){
	sort(a,0,a.length-1);
}

二、插入排序

1.简单插入排序

public static void insertSort(int[] a){
	for(int i=1;i<a.length;i++){
		int j=i;
		while(j>0&&a[j]<a[j-1]){
			swap(a,j,j-1);
			j--;
		}
	}
}

2.希尔排序

public staic void shellSort(int[] a){
	for(int gap=a.length/2;gap>0;gap/=2){
		for(int i=gap;i<a.length;i++){
			int j=i;
			while(j-gap>=0&&a[j]<a[j-gap]){
				swap(a,j,j-gap);
				j-=gap;
			}
		}
	}
}

public static void swap(int[] arr,int a,int b){
	arr[a]=arr[a]+arr[b];
	arr[b]=arr[a]-arr[b];
	arr[a]=arr[a]-arr[b];
}

三、选择排序

1.简单选择排序

public static void selectSort(int[] a){
	for(int i=0;i<a.length-1;i++){
		int min=i;//每一趟循环比较时，min用于存放较小元素的数组下标，
这样当前批次比较完毕最终存放的就是此趟内最小的元素的下标，
避免每次遇到较小元素都要进行交换。
		for(int j=i+1;j<a.length;j++){
			if(a[j]<a[min])
				min=j;
		}
		if(min!=i)
			swap(a,min,i);
	}
}

2.堆排序

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

四、归并排序

public static void sort(int a[]){
	int[] temp=new int[a.length];//在排序前，先建好一个长度等于原是数组长度的临时数组，避免地柜中频繁开辟空间
	sort(a,0,a.length-1,temp);
 }
private static void sort(int[] a,int left,int right,int[] temp){
	if(left<right){
		int mid=(left+right)/2;
		sort(a,left,mid,temp);//左边归并排序，使得左子序列有序
		sort(a,mid+1,right;temp);//右边归并排序，使得右子序列有序
		merge(a,left,mid,right,temp);//将两个有序子数组合并操作
	}
}

private static void merge(int[] a,int left,int mid,int right,int[] temp){
	int i=left;//左序列指针
	int j=mid+1;//右序列指针
	int t=0;//临时数组指针
	while(i<=mid&&j<=right){
		if(a[i]<=a[j]){
			temp[t++]=a[i++];
		]else{
			temp[t++]=a[j++]
		}
	}
	while(i<=mid){//将左边剩余的元素填充进temp中
		temp[t++]=a[i++];
	}
	while(j<=right){
		temp[t++]=a[j++];//将右序列剩余元素填充进temp中
	}
	t=0;
	//将temp中的元素全部拷贝到原数组中
	while(left<=right){
		a[left++]=temp[t++];
	}
}

非比较排序

一、计数排序

二、桶排序

三、基数排序

==============================================================

稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。
不稳定：如果a原本在b的前面，而a=b，排序之后 a 可能会出现在 b 的后面。
时间复杂度：对排序数据的总的操作次数。反映当n变化时，操作次数呈现什么规律。
空间复杂度：是指算法在计算机内执行时所需存储空间的度量，它也是数据规模n的函数。

==============================================================