1. 二分查找
算法描述:
- 在有序的数组内,查找target值的索引
注意:
- 注意 l 指针和 r 指针最后的指向
private static int binarySearch(int[] array, int target) {
int l = 0;
int r = array.length - 1;
while (l <= r) {
int mid = l + (r - l) / 2;
if (array[mid] == target) {
return mid;
} else if (array[mid] < target) {
l = mid + 1;
} else {
r = mid - 1;
}
}
return -1;
}
2. 冒泡排序
算法思想:
- 每次从第 0 个元素开始,依次比较相邻的两个元素。如果后一个比前一个大,则进行交换。
- 之后的内循环比较次数,内循环的次数就会减一个,因为上一轮已经把最大的元素移动到了末尾。
- 优化:如果能够判断某一轮的内循环没有进行交换元素,则说明数组已经有序,则直接退出循环
private static void bubbling(int[] array){
for (int i = 0; i < array.length; i++) {
boolean flag = false;
for (int j = 0; j < array.length - 1 - i; j++) {
if(array[j] > array[j + 1]){
flag = true;
int temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
if (!flag) {
break;
}
}
}
3. 选择排序
算法思想:
- 将数组分成有序区和无序区。一开始整个数组是无序区。
- 每次从无序区中找到最小元素的下标,然后与无序区的第一个元素进行交换。
private static void selectionSort(int[] array){
for (int i = 0; i < array.length; i++) {
int min_idx = i;
for (int j = i + 1; j < array.length; j++) {
if (array[j] < array[min_idx]) {
min_idx = j;
}
}
int temp = array[i];
array[i] = array[min_idx];
array[min_idx] = temp;
}
}
4. 插入排序
算法思想:
- 将数组分成有序区和无序区。一开始数组的第一个元素是有序区,后面都是无序区。
- 遍历无序区的元素,将插入插入到有序区对应的位置上。
private static void insertSort(int[] array){
for (int i = 1; i < array.length; i++) {
if(array[i] < array[i - 1]){
int temp = array[i];
int idx = i - 1;
while(idx >= 0 && array[idx] > temp){
array[idx + 1] = array[idx];
idx--;
}
array[++idx] = temp;
}
}
}
5. 快速排序
算法思想:
- 挑选一个元素作为基准元素。
- 把比基准元素小的放在基准元素左侧,比基准元素大的放到右侧。此时就完成了一轮分区。
- 递归的对左右两个分区进行相同的操作。分治思想
- 缺点:如果选取最左侧或最右侧的元素最为基准点,对于已经有序的数组进行快速排序,则会退化成冒泡排序。因为:每一次只能使数组减少一个元素,而最优的情况应该是每次分区操作都能将数组一分为二。
private static void quickSorting(int[] array, int l, int r){
if(l >= r){
return;
}
// 基准点下标
int index = partition(array, l, r);
// 左边分区一趟排序
quickSorting(array, l, index - 1);
// 右边分区一趟排序
quickSorting(array, index + 1, r);
}
private static int partition(int[] array, int l, int r){
int val = array[l];
int i = l;
while(i < r){
while (i < r && array[r] > val){
r--;
}
while (i < r && array[r] <= val){
i++;
}
swap(array, i, r);
}
swap(array, l, i);
return i;
}
private static void swap(int[] array, int j, int i) {
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
6. 归并排序
算法思想:
- 归并排序分为两部分,
分解
和合并
- 分解:将待排序的序列,一分为二,直到分成单个元素时,则认为是有序的了。
- 合并:将有序的序列进行合并,形成一个有序的大序列。通过不断的合并最终得到完全排序好的序列。
private static void mergeSort(int[] array, int l, int r){
if (l >= r) {
return;
}
int mid = l + (r - l) / 2;
mergeSort(array, l, mid);
mergeSort(array, mid + 1, r);
merge(array, l, mid, r);
}
/**
*
* @param array
* @param left 表示第一个子数组的起始位置。
* @param mid 表示第一个子数组的结束位置,也是第二个子数组的起始位置-1
* @param right 表示第二个子数组的结束位置。
*/
private static void merge(int[] array, int left, int mid, int right) {
int[] temp = new int[right - left + 1];
int i = left;
int j = mid + 1;
int k = 0;
while(i <= mid && j <= right) {
if(array[i] <= array[j]) {
temp[k++] = array[i++];
} else {
temp[k++] = array[j++];
}
}
while(i <= mid) {
temp[k++] = array[i++];
}
while(j <= right) {
temp[k++] = array[j++];
}
for(int p = 0; p < temp.length; p++) {
array[left + p] = temp[p];
}
}