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

冒泡排序：

原理：比较两个相邻的元素，将值大的元素交换到右边

代码实现：

public class BubbleSort {
	public static void bubbleSort(int[] data) {
		System.out.println("开始排序|");
		int arrayLength = data.length;
		for (int i = 0; i < arrayLength-1; i++) {
			boolean flag = false;
			for (int j = 0; j < arrayLength-1-i; j++) {
				if (data[j] >data[j+1]) {
					int temp = data[j+1];
					data[j+1] = data[j];
					data[j]=temp;
					flag = true;
					
				}
				
			}
			System.out.println(java.util.Arrays.toString(data));
	      if(!flag)
	    	  break;
	
			
		}
	}
	public static void main(String[] args) {
		int[] data = { 9, -16, 21, 23, -30, -49, 21, 30, 30 };
		System.out.println(" 排 序 之 前 ： \n" + java.util.Arrays.toString(data));
		bubbleSort(data);
		System.out.println(" 排 序 之 后 ： \n" + java.util.Arrays.toString(data)); 
	}

}

二分查找：

实现代码：

def binarySearch(arr:Array[Int],left:Int,right:Int,findVal:Int):
	Int={
			if(left>right){//递归退出条件，找不到，返回-1 
				-1
				}
			}
				val midIndex = (left+right)/2
						if (findVal < arr(midIndex)){//向左递归查找
							binarySearch(arr,left,midIndex,findVal)
							}else if(findVal > arr(midIndex)){//向右递归查找
								binarySearch(arr,midIndex,right,findVal)
								}else{//查找到，返回下标
									midIndex 
									}
} 
			}
	}

 快排：

 实现代码：

def quickSort(list: List[Int]): List[Int] = list match {
 case Nil => Nil
 case List() => List()
 case head :: tail =>
 val (left, right) = tail.partition(_ < head)
 quickSort(left) ::: head :: quickSort(right) 
}

归并：

核心思想：不断的将大的数组分成两个小数组，直到不能拆分为止，即形成了单个值。
此时使用合并的排序思想对已经有序的数组进行合并，合并为一个大的数据，不断重复此过
程，直到最终所有数据合并到一个数组为止。