JAVA冒泡排序，归并排序，二分查找

一、基本理解

冒泡排序基本思想：两两比较相邻记录的关键码，如果反序则交换，知道没有反序的记录为止。

归并排序基本思想：将若干个有序序列进行两两归并，直至所有待排序序列都在一个有序序列为止。前提：数组有序。

二分查找（折半查找）基本思想：对一个队列数组设置头start、尾end、中间索引mid=(start+end)/2，每次将待查找的值num与中间索引对应的值进行比较，分为三种情况：①查找的值小于中间索引对应的值；②：查找的值大于中间索引对应的值；③：查找的值等于中间索引对应的值。三种情况分别处理，结束条件为：start>end。

二、代码详解

class SortDemo{
	public static void main(String[] args){
		int[] arr=new int[100];
		fuZhi(arr);
	    bobbleSort(arr);  //冒泡排序
	    mergeSort(arr);   //归并排序
		print(arr);       //打印数组
		System.out.println();
		int index=binarySearch(arr,10);    //二分查找数值
		if(index!=-1){
			System.out.println("找到了——索引为"+index);
		}else{
			System.out.println("没有找到索引！");
		}
		//long last=System.currentTimeMillis();
		//System.out.println();
		//System.out.println("所用时间为："+(last-pre));
	}
	// 二分查找
	public static int binarySearch(int[] arr,int num){
		int index=-1;
		int start=0;
		int end=arr.length-1;
		int mid=(start+end)/2;  //先初始化变量
		while(start<end){
			if(num<arr[mid]){
				end=mid-1;
			}else if(num>arr[mid]){
				start=mid+1;
			}else{
				index=mid;
				break;
			}
			mid=(start+end)/2;
		}
		return index;
	}
	//为归并排序准备一个临时数组
	public static void mergeSort(int[] arr){
		int[] temp=new int[arr.length];
		sort(arr,0,arr.length-1,temp);
	}
	//归并
	public static void sort(int[] arr,int left,int right,int[] temp){
		if(left<right){
			int mid=(left+right)/2;
			sort(arr,left,mid,temp);     //左边归并排序
			sort(arr,mid+1,right,temp);  //右边归并排序
			merge(arr,left,mid,right,temp); //将两个有序子数组合并操作
		}
	}
	// 归并排序
	public 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++];
		}
	}
	// 赋值
	public static void fuZhi(int[] arr){
		for(int i=0;i<arr.length;i++){
			arr[i]=(int)(Math.random()*arr.length);
		}
	}
	// 打印数组
	public static void print(int[] arr){
		for(int i=0;i<arr.length;i++){
			if(i%10==0){
				System.out.println();
			}
			System.out.print(arr[i]+" ");
		}
	}
	//冒泡排序
	public static void bobbleSort(int[] arr){
		for(int i=0;i<arr.length;i++){
			for(int j=0;j<arr.length-1-i;j++){
				if(arr[j]>arr[j+1]){
					swap(arr,j,j+1);
				}
			}
		}
	}
	// 交换
	public static void swap(int[] arr,int from,int to){
		int temp=arr[from];
		arr[from]=arr[to];
		arr[to]=temp;
	}
}

三、时空复杂度

冒泡排序：时间复杂度为O(n^2)；空间复杂度为O(1)。

归并排序：时间复杂度为O(nlog2n)；空间复杂度为O(n)—为其开辟了一个和原数组同等长度的数组。