java排序算法

1、冒泡排序

		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};
		int tmp = 0;
		// 遍历数组
		for(int i=0;i<a.length-1;i++){
			// 每执行完此循环一次便把一个下标（0，a.length-1-i）范围内最大的数放置到了a.length-1-i上
			// 直到a.length次循环后完成排序
			for(int j=0;j<a.length-1-i;j++){
				if(a[j]>a[j+1]){
					tmp = a[j];
					a[j] = a[j+1];
					a[j+1] = tmp;
				}
			}
		}
		
		for(int b:a){
			System.out.print(b+" , ");
		}
	

基本思路为：通过两层循环，比对数组中两两相邻的两个数，若左边的数比右边大则将两数交换；每执行完一次外层的大循环

便把一个下边（0，alength-1-i）范围内最大的数放置到了a.length-1-i下标上，即不断的选出最大，第二大。。。的数放置到最后，倒数第二。。。的位置上去，最终完成排序。时间复杂度为O（n2）

2、快速排序：

快速排序的核心思想就是：①选择数组中一个数字（通常为第一或最后一个）作为中轴数，往后遍历全数组，将比中轴数大的放在数右边，将比中轴数小的放在数左边；②运用递归对中轴数左边，右边两个数组分别进行第一步的排序操作；③直至细分到中轴数两边数组无法在拆分；这样实现快速排序时间复杂度为：O(nlogn)

public static void main(String[] args) {
		int a[]={49,38,65,97,76,13,27,78,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};
		quickSort(a,0,a.length-1);
		for(int b:a){
			System.out.print(b+" , ");
		}
	}
	// 此处为递归算法，不断将数组一步步细分直至中轴数两边无法拆分，完成排序
	public static void quickSort(int[] list,int low,int high){
		// 保证数组下标低位比高位小，防止下标越界
		if(low<high){
			// 选出中轴数数，将数组拆分为两部分:中轴数左边均比中轴数小，中轴数右边均比中轴数大
			int mid = getMiddle(list,low,high);
			// 将中轴数左边数组进一步拆分
			quickSort(list,low,mid-1);
			// 将中轴数右边数组进一步拆分
			quickSort(list,mid+1,high);
		}
		
	}

	public static int getMiddle(int[] list,int low ,int high){
		// 选取数组第一个数作为中轴数
		int tmp = list[low];
		while(low<high){
			// 将若高位数比中轴数大则略过
			while(low<high&&list[high]>=tmp){
				high--;
			}
			// 将比中轴数小的数挪到左边低端
			list[low] = list[high];
			// 若低位数比中轴数小则略过
			while(low<high&&list[low]<=tmp){
				low++;
			}
			// 将比中轴数大的数挪到右边
			list[high]=list[low];
			// 若循环一遍后低位下标low仍比高位high小，则说明整个数组还没有比完，则再次进入循环对比剩余的数
		}
		list[low] = tmp;
		// 最终将此中轴数下标返回，下次再将中轴数左右两边数组分别进行拆分排序
		return low;
	}

3、希尔排序：

    在学习希尔排序前先复习一遍直接插入排序的概念：在要排序的一组数中，假设前面(n-1)[n>=2] 个数已经是排好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数也是排好顺序的。如此反复循环，直到全部排好顺序。而希尔排序便是基于直接插入排序的，先将要排序的一组数按照某个增量d（如n/2，n为数组大小）分成若干组，每组中下标相差d，对每组原数进行直接插入排序，然后再用一个较小的增量（d/2）对它进行排序，每组再进行直接插入排序，当增量减到1时，再进行直接插入排序，此时排序完成。

public static void main(String[] args) {
		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};
		double d1=a.length;
		int tmp = 0;
		// 此大循环将数组不断细分为小数组，直至增量为1，增量为1时即比较左右大小并交换即可
		while(true){
			// 取得增量d，对数组长度的二分之一向上取整，防止有数字没进入循环
			d1=Math.ceil(d1/2);
			int d=(int)d1;
			// 分组后遍历每个分组（每个分组间数字间距为d个下标）
			for(int x=0;x<d;x++){
				// 此处为直接插入排序实现，不过相邻数间下标相差d
				for(int i=x+d;i<a.length;i=i+d){
					int j = i-d;
					tmp = a[i];
					// 将未排序数字与前面已排好序的数组比较，若更小则将此数字右移，直至插入到合适位置
					for(;j>=0&&tmp<a[j];j=j-d){
						a[j+d]=a[j];
					}
					a[j+d] = tmp;
				}
			}
			// 当增量为1即无法继续拆分时，中断循环
			if(d==1){
				break;
			}	
		}
		
		for(int b:a){
			System.out.print(b+" , ");
		}	

	}

4、堆排序：

    堆排序包含两个步骤的循环：①建大顶堆；②将堆顶与还未排序数组末尾数字交换，直至完成排序。让我们来复习一下堆的性质：堆是一种完全二叉树，以从左到右的顺序占位，因此可以用一个一维数组标示它。在完全二叉树中对于任意节点k，k的左右子节点的下标分别为2*k和2*k+1。（若k的左右子节点存在）节点k的父节点的下标为k/2（注意下标值是要向下取整）。大顶堆中父节点要大于左右两子节点。针对这些性质，我们可以循环建立大顶堆以获得最大，第二大。。。的数字最终筛选出数字的顺序。java中优先队列就是通过建立堆来实现队列的优先级

public static void main(String[] args) {
		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}; 
		// 循环建大顶堆，交换堆顶与堆尾
		for(int i=0;i<a.length;i++){
			buildMaxHeap(a,a.length-1-i);
			swap(a,0,a.length-1-i);
		}
		
		for(int i:a){
			System.out.print(i+"  ");
		}
	}
	
	public static void buildMaxHeap(int[] list,int lastIndex){
		// 从末尾节点的父节点开始向堆顶位置循环
		for(int i=(lastIndex-1)/2;i>=0;i--){
			int k = i;
			// 若此节点存在子节点，进入循环
			while(2*k+1<=lastIndex){
				int biggerIndex = 2*k+1;
				// 判断是否有右节点，若有则比较左右节点大小，记录更大的节点的下标为biggerIndex
				if(biggerIndex<lastIndex){
					if(list[biggerIndex]<list[biggerIndex+1]){
						biggerIndex++;
					}
				}
				// 若父节点小于子节点，则将子节点上浮到父节点
				if(list[k]<list[biggerIndex]){
					swap(list,k,biggerIndex);
					k=biggerIndex;
				}else{
					break;
				}
			}
		}
	}
	
	public static void swap(int[] list,int i,int j){
		int tmp = list[i];
		list[i] = list[j];
		list[j] = tmp;
	}