java 常用算法

1.冒泡排序（Bubble Sort）
算法描述：（从小到大排序）

● 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
● 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
● 针对所有的元素重复以上的步骤，除了最后一个；
● 重复步骤1~3，直到排序完成。

如果两个元素相等，不会再交换位置，所以冒泡排序是一种稳定排序算法。
Public static int[] bubbleSort(int[] arr) {
int arrSize = arr.length;
for (int i = 0; i < arrSize; i++) {
for (int j = i + 1; j < arrSize; j++) {
if (arr[i] > arr[j]) {
int tmp = arr[j];
arr[j] = arr[i];
arr[i] = tmp;
}
}
}
return arr;
}
2.快速排序
使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：

● 从数列中挑出一个元素，称为 “基准”（pivot）；
● 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
● 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

key值的选取可以有多种形式，例如中间数或者随机数，分别会对算法的复杂度产生不同的影响。

public static void quickSort(int[] arr, int low, int high) {
if (low >= high) {
return;
}
int mark = arr[low];// 选取第一个值为基准值
/arr[low]=arr[(high+low)/2];
arr[(high+low)/2]=mark;
mark = arr[low]; 选取数组中间值为基准值/
int i = low;
int j = high;
while (low < high) {
if (low < high && arr[high] >= mark) {// 如果大于基准值下标左移，直到小于基准值，取等是为了将基准值放入队尾，必须取等
high–;
}
arr[low] = arr[high];// 队尾值小于基准值的要替代队首的值，第一次替代的为基准值
while (low < high && arr[low] <= mark) { // 如果小于基准值下标右移，直到大于基准值。取等是为了将基准值相等的放右队列，可以不取等。
low++;
}
arr[high] = arr[low];
}
arr[low] = mark;//将基准值放入小值的队尾
quickSort(arr, i, low - 1);// 此处-1和下面加以是因为基准值前面必然小于等于他，无需再进行排序，提升效率。
quickSort(arr, low + 1, j);
}

3.归并排序
把长度为n的输入序列分成两个长度为n/2的子序列；
● 对这两个子序列分别采用归并排序；
● 将两个排序好的子序列合并成一个最终的排序序列。

（1）归并排序的流程

public static void mergeSort(int[] arr, int l, int r) {
if (r == l) { //已经分到最小，无需再排序
return;
}
// 逻辑拆分成两个两数组
int mid = l + ((r - l) / 2);
mergeSort(arr, l, mid);
mergeSort(arr, mid + 1, r);

merge(arr, l, mid, r);

}

/**

• 合并两有序数组
• @param arr 原数组
• @param l 数组一起点下标
• @param mid 数组一终点下标
• @param r 数组二终点下标
  */
  public static void merge(int[] arr, int l, int mid, int r) {
  int tmp[] = new int[r - l + 1];
  int index1 = l;
  int index2 = mid + 1;
  int i = 0;
  // 循环遍历，依次将较小数插入临时数组
  while (index1 <= mid && index2 <= r) {
  tmp[i++] = arr[index1] < arr[index2] ? arr[index1++] : arr[index2++];
  }
  // 如果数组一未遍历完，依次将剩余插入临时数组
  while (index1 <= mid) {
  tmp[i++] = arr[index1++];
  }
  // 如果数组二未遍历完，依次将剩余插入临时数组
  while (index2 <= r) {
  tmp[i++] = arr[index2++];
  }
  // 将原数组部分替换为排序好的临时数组
  for (int j = 0; j < tmp.length; j++) {
  arr[l + j] = tmp[j];
  }
  }

4. 二分查找
   算法描述：

● 二分查找也称折半查找，它是一种效率较高的查找方法，要求列表中的元素首先要进行有序排列。
● 首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；
● 否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。
● 重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。
代码实现：
public static int binarySearch(int[] arr, int left, int right, int targetVal) {
// 查找不到返回-1
if (left > right) {
return -1;
}
int midIndex = (left + right) / 2;
if (targetVal == arr[midIndex]) {
return midIndex;
} else if (targetVal < arr[midIndex]) {
return binarySearch(arr, left, midIndex - 1, targetVal);
} else {
return binarySearch(arr, midIndex + 1, right, targetVal);
}
}