Java 基础算法
1、查找
1.1 基本/顺序查找
package TestCode;
import java.util.ArrayList;
public class TestClass {
public static void main(String[] args) {
int[] arr = {131, 127, 147, 81, 103, 23, 7, 79, 81};
int number = 82;
int index = basicSearch(arr, number);
System.out.println(number + "的索引为：" + index);
ArrayList<Integer> indexList = basicSearch2(arr, number);
System.out.println(number + "的索引为：" + indexList);
}
// 无关乎重复数据
public static int basicSearch(int[] arr, int number) {
for (int i = 0; i < arr.length; i++) {
if (arr[i] == number) {
return i;
}
}
return -1;
}
// 查找所有存在索引包括重复的
public static ArrayList<Integer> basicSearch2(int[] arr, int number) {
ArrayList<Integer> list = new ArrayList<>();
for (int i = 0; i < arr.length; i++) {
if (arr[i] == number) {
list.add(i);
}
}
if (list.size() == 0)
{
list.add(-1);
}
return list;
}
}
1.2 折半/二分查找
- 前提条件：数组中的数据必须是有序的
- 核心逻辑：每次排除一半的查找范围
package TestCode;
import java.util.ArrayList;
public class TestClass {
public static void main(String[] args) {
int[] arr = {7,23,79,81,103,127,131,147};
int number = 150;
int res = binarySearch(arr, number);
System.out.println(res);
}
public static int binarySearch(int[] arr, int number)
{
int left = 0;
int right = arr.length - 1;
while(left <= right) {
int mid = (left + right) / 2;
if (arr[mid] > number) {
right = mid - 1;
} else if (arr[mid] < number) {
left = mid + 1;
} else {
return mid;
}
}
return -1;
}
}
1.3 分块查找
package TestCode;
public class TestClass {
public static void main(String[] args) {
int[] arr = {16, 5, 9, 12, 21, 18,
32, 23, 37, 26, 45, 34,
50, 48, 61, 52, 73, 66};
Block b1 = new Block(21, 0, 5);
Block b2 = new Block(45, 6, 11);
Block b3 = new Block(73, 12, 17);
//定义数组管理三个块的对象（索引表）
Block[] block = {b1, b2, b3};
int number = 50;
int index = getIndex(block, arr, number);
System.out.println(index);
}
private static int getIndex(Block[] block, int[] arr, int number)
{
int indexBlock = findIndexBlock(block, number);
if (indexBlock == -1)
{
return -1;
}
int startIndex = block[indexBlock].getStartIndex();
int endIndex = block[indexBlock].getEndIndex();
for (int i = startIndex; i < endIndex; i++) {
if(number == arr[i])
{
return i;
}
}
return -1;
}
public static int findIndexBlock(Block[] blockArr, int number)
{
for (int i = 0; i < blockArr.length; i++) {
if (number <= blockArr[i].getMax())
{
return i;
}
}
return -1;
}
}
1.4 插值查找
数值分布均匀
1.5 斐波那契查找
1.6 分块扩展
所有的块不能有交集
1.7 哈希查找
2、排序
2.1 冒泡排序
- 相邻的数据两两比较，小的放前面，大的放后面
package TestCode;
public class TestClass {
public static void main(String[] args) {
int[] arr = {2, 4, 5, 3, 1};
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length -1 - i; j++) {
if (arr[j] > arr[j + 1]) {
int tmp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = tmp;
}
}
}
printArr(arr);
}
private static void printArr(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}
}
2.2 选择排序
- 从0索引开始，拿着每一个索引上的元素和后面的元素依次比较，小的放前面，大的放后面
package TestCode;
public class TestClass {
public static void main(String[] args) {
int[] arr = {2, 4, 5, 3, 1};
// i表示这一轮用哪个索引的数据和后面数据进行比较
for (int i = 0; i < arr.length - 1; i++) {
for (int j = i + 1; j < arr.length; j++) {
if (arr[i] > arr[j]) {
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
}
}
printArr(arr);
}
private static void printArr(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}
}
2.3 插入排序
- 将0索引的元素到N索引的元素看做是有序的，把N+1索引的元素到最后一个当作是无序的。（从前往后）遍历无序的数据，将遍历的元素插入到有序序列中适当的位置（从后往前遍历有序序列进行比较），相同数据插在后面。
- N的范围0~最大索引
package TestCode;
import java.util.ArrayList;
public class TestClass {
public static void main(String[] args) {
int[] arr = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};
//1.找到无序数据起始索引
int startIndex = -1;
for (int i = 0; i < arr.length - 1; i++) {
if (arr[i] > arr[i + 1]) {
startIndex = i + 1;
break;
}
}
//2.插入有序序列中
for (int i = startIndex; i < arr.length; i++) {
int j = i;
while (j > 0 && arr[j] < arr[j - 1]) {
int tmp = arr[j];
arr[j] = arr[j - 1];
arr[j - 1] = tmp;
j--;
}
}
printArr(arr);
}
private static void printArr(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}
}
2.4 快速排序
- 将排序范围中的第一个数字作为基准数，再定义两个变量start，end
- start从前往后找比基准数大的，end从后往前找比基准数小的。
- 找到之后交换start和end指向的元素，并循环这一过程，直到start和end处于同一个位置，该位置是基准数在数组中应存入的位置，再让基准数归位
- 归位后的效果:基准数左边的，比基准数小，基准数右边的，比基准数大
package TestCode;
import java.util.ArrayList;
public class TestClass {
public static void main(String[] args) {
int[] arr = {6, 1, 2, 7, 9, 3, 4, 5, 10, 8};
quickSort(arr, 0, arr.length - 1);
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}
private static void quickSort(int[] arr, int i, int j) {
int start = i;
int end = j;
// 递归出口
if (start > end) {
return;
}
int baseNumber = arr[i];
while (start != end) {
//必须先移动end在移动start
// 利用end从后往前找，找比基准数要小的数字
while (true) {
if (end <= start || arr[end] < baseNumber) {
break;
}
end--;
}
// 利用start从前往后找，找比基准数要大的数字
while (true) {
if (end <= start || arr[start] > baseNumber) {
break;
}
start++;
}
// 把end和start数据交换
int tmp = arr[start];
arr[start] = arr[end];
arr[end] = tmp;
}
// 基准数归位
int temp = arr[i];
arr[i] = arr[start];
arr[start] = temp;
// 确定基准数左边的范围，并重复之前操作
quickSort(arr, i, start - 1);
// 确定基准数右边的范围，并重复之前操作
quickSort(arr, start + 1, j);
}
}
2.5 总结
3、递归算法
- 方法中调用方法本身
- 一定要有出口，否则会出现内存溢出
- 方法内部再次调用方法的时候，参数必须要更加靠近出口
package TestCode;
import java.util.ArrayList;
public class TestClass {
public static void main(String[] args) {
int res = getSum(100);
System.out.println(res);
}
private static int getSum(int number)
{
if (number ==1)
{
return 1;
}
return number + getSum(number - 1);
}
}
参考视频：
https://www.bilibili.com/video/BV17F411T7Ao?p=177&vd_source=a89593e8d33b31a56b894ca9cad33d33
197
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
