大数据面试二常见算法之冒泡排序，二分查找，快排，归并

一，冒泡排序

/**
* 冒泡排序 时间复杂度 O(n^2) 空间复杂度 O(1)
*/
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;
10
}
}
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));
}
}

二，二分查找

/**
* 二分查找 时间复杂度 O(log2n);空间复杂度 O(1)
*/
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{//查找到，返回下标
11
midIndex
}
}

拓展需求：当一个有序数组中，有多个相同的数值时，如何将所有的数值都查找到。

代码实现如下：

/*
{1,8, 10, 89, 1000, 1000，1234} 当一个有序数组中，有多个相同的数值时，如何将所有的数值都查找到，比如这里的 1000.
//分析
1. 返回的结果是一个可变数组 ArrayBuffer
2. 在找到结果时，向左边扫描，向右边扫描 [条件]
3. 找到结果后，就加入到 ArrayBuffer
*/
def binarySearch2(arr: Array[Int], l: Int, r: Int,
findVal: Int): ArrayBuffer[Int] = {
//找不到条件?
if (l > r) {
return ArrayBuffer()
}
val midIndex = (l + r) / 2
val midVal = arr(midIndex)
if (midVal > findVal) {
//向左进行递归查找
binarySearch2(arr, l, midIndex - 1, findVal)
} else if (midVal < findVal) { //向右进行递归查找
binarySearch2(arr, midIndex + 1, r, findVal)
} else {
println("midIndex=" + midIndex)
//定义一个可变数组
val resArr = ArrayBuffer[Int]()
//向左边扫描
var temp = midIndex - 1
breakable {
while (true) {
if (temp < 0 || arr(temp) != findVal) {
break()
}
if (arr(temp) == findVal) {
resArr.append(temp)
}
12
temp -= 1
}
}
//将中间这个索引加入
resArr.append(midIndex)
//向右边扫描
temp = midIndex + 1
breakable {
while (true) {
if (temp > arr.length - 1 || arr(temp) != findVal) {
break()
}
if (arr(temp) == findVal) {
resArr.append(temp)
}
temp += 1
}
}
return resArr
}

三，快速排序

核心思想：

代码实现：

/**
13
* 快排
* 时间复杂度:平均时间复杂度为 O(nlogn)
* 空间复杂度:O(logn)，因为递归栈空间的使用问题
*/
public class QuickSort {
public static void main(String[] args) {
int [] a = {1,6,8,7,3,5,16,4,8,36,13,44};
QKSourt(a,0,a.length-1);
for (int i:a) {
System.out.print(i + " ");
}
}
private static void QKSourt(int[] a, int start, int end) {
if (a.length < 0){
return ;
}
if (start >= end){
return ;
}
int left = start;
int right = end;
int temp = a[left];
while (left < right){
while (left < right && a[right] > temp){
right -- ;
}
a[left] = a[right];
while (left < right && a[left] < temp){
left ++ ;
}
a[right] = a[left];
}
a[left] = temp;
System.out.println(Arrays.toString(a));
QKSourt(a, start, left -1);
QKSourt(a,left+1,end);
}
}

四，归并排序

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

归并排序流程：

最后将临时数组拷贝回原数组

代码实现：

/**
* 快排
* 时间复杂度:O(nlogn)
* 空间复杂度:O(n)
*/
15
def merge(left: List[Int], right: List[Int]): List[Int] = (left, right) match {
case (Nil, _) => right
case (_, Nil) => left
case (x :: xTail, y :: yTail) =>
if (x <= y) x :: merge(xTail, right)
else y :: merge(left, yTail)
}