java基础算法及代码实现

java基础算法及代码实现
# 二分查找
二分查找是一种在有序数组中查找指定元素的一种搜索算法，是一种非常高效的算法，时间复杂度为O(log n)。

```java
// 非递归
public static int binarySearch(int[] array, int target) {
int left = 0;
int right = array.length - 1;
while (left <= right) {
int mid = (left + right) >>> 1;
int midVal = array[mid];
if (midVal == target)
return mid; //相等，找到target
if (midVal < target)
left = mid + 1; //小于，向右搜索
if (midtVal > target)
right = mid - 1; // 大于，向左搜素
}
return -1; // 未找到
}
// 递归
public static int binarySearch(int[] array, int left, int right, int target) { if (left > right)
return -1;
int mid = (left + right) >>> 1;
int midVal = array[mid];
if (midVal == target)
return mid;
if (midVal < target)
return binarySeearch(array, mid + 1, right, target);
if (midtVal > target)
return binarySeearch(array, left, mid - 1, target);
return -1;
}
```
# 插入排序
插入排序是一种简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后往前扫描，找到相应位置并插入。

时间复杂度为O(n^2)。

```java
public static void insertSort(int[] array) {
for (int i = 1; i < array.length; i++) {
int insertVal = array[i];
int index = i - 1;
while (index >= 0 && array[index] > insertVal) {
array[index + 1] = array[index];
index--;
}
array[index + 1] = insertVal;
}
}
```
# 快速排序
快速排序是一种不稳定的排序算法，快速排序可以在n*log(n) 的时间复杂度内完成排序。

```java
// 非递归实现
public static void quickSort(int[] array) {
Stack<Integer> stack = new Stack<Integer>();
int left = 0;
int right = array.length - 1;
stack.push(left);
stack.push(right);
while (!stack.isEmpty()) {
int high = stack.pop();
int low = stack.pop();
int pivot = partation(array, left, right);
if (pivot - 1 > left) {
stack.push(left);
stack.push(pivot - 1);
}
if (pivot + 1 < right) {
stack.push(pivot + 1);
stack.push(right);
}
}
public static int partation(int[] array, int left, int right) { int pivotVal = array[left];
while (left < right) {
while (left < right && array[right] >= pivotVal) { right--;
}
array[left] = array[right];
while (left < right && array[left] <= pivotVal) { left++;
}
array[right] = array[left];
}
array[left] = pivotVal;
return left;
}
// 递归实现
public static void quickSort(int[] array, int left, int right) { if (left >= right)
return;
int pivot = partation(array, left, right);
quickSort(array, left, pivot - 1);
quickSort(array, pivot + 1, right);
}
```
# 冒泡排序
冒泡排序是一种稳定的排序算法，是一种简单的排序算法，时间复杂度为O(n^2)。

```java
public static void bubbleSort(int[] array) {
for (int i = 0; i < array.length; i++)
for (int j = 0; j < array.length - i - 1; j++)
if (array[j] > array[j + 1]) {
int temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
```
# 归并排序
归并排序是一种稳定的排序算法，时间复杂度为O(nlogn)。

```java
public static void mergeSort(int[] array, int start, int end) { if (start >= end)
return;
int mid = (start + end) >>> 1;
mergeSort(array, start, mid);
mergeSort(array, mid + 1, end);
merge(array, start, mid, end);
}
public static void merge(int[] array, int start, int mid, int end) { int[] temp = new int[end - start + 1];
int i = start;
int j = mid + 1;
int k = 0;
while (i <= mid && j <= end) {
if (array[i] < array[j])
temp[k++] = array[i++];
else
temp[k++] = array[j++];
}
while (i <= mid)
temp[k++] = array[i++];
while (j <= end)
temp[k++] = array[j++];
for (int l = 0; l < k; l++)
array[start + l] = temp[l];
}
```
# 堆排序
堆排序是一种不稳定的排序算法，时间复杂度为O(nlogn)。

```java
public static void heapSort(int[] array) {
buildHeap(array);
int length = array.length;
while (length > 1) {
int temp = array[length - 1];
array[length - 1] = array[0];
array[0] = temp;
length--;
adjustHeap(array, 0, length);
}
}
// 建立heap
public static void buildHeap(int[] array) {
int length = array.length;
for (int i = length / 2 - 1; i >= 0; i--)
adjustHeap(array, i, length);
}
// 调整heap
public static void adjustHeap(int[] array, int i, int length) {。