一，冒泡排序
/**
* 冒泡排序 時間複雜度 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)
}