这里再补充一条本博客的方法论：精简
- 只有精简才能一语中的，描绘出事物的本质，过于冗长的博客是谁不不愿意看的。
SearchAlgorithm查找算法
算法其实都是有固定模版的，至少从我考研到现在看来。以及工作之后的一些应用场景，好记性不如烂笔头，拿一些好用算法模版写到自己能随时看到的地方比自己工作胡乱在网上找，或者自己凭感觉写要好的多。
二分查找算法
精华：求mid = left + right / 2, 如果mid > key 则 right = mid - 1, 反之left = mid + 1
代码案例
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
public class BinarySearchAlgorithm {
public static void main(String[] args) {
int[] arr = {88, 66, 55, 37, 25, 23, 12, 6, 3, 1};
int key = 66;
for (int left = 0, right = arr.length -1 ; left <= right;) {
int mid = (left + right) / 2;
if (key > arr[mid]){
right = mid - 1;
}else if (key < arr[mid]){
left = mid + 1;
}else {
System.out.println(key + "在：" + mid + "索引位置找到了！");
return;
}
}
System.out.println("要查找的元素不在数组中");
}
}
|
SortAlgorithm排序算法
冒泡排序是最经典的算法，其次还有选择排序算法。总之算法很多，拿一两个比较常用的记一下还是很好的。
BubbleSort冒泡排序
精华：外层循环控制排序次数，内层循环控制元素大小比较
Tips：
- 外层：
int i = 0; i < arr.length; i++
- 内层：
int j = 0; j < arr.length - i -1; j++
代码案例
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| public class BubbleSortAlgorithm {
public static void main(String[] args) {
int[] arr = {5, 8, 7, 8, 9, 5, 7, 3, 5, 8, 2, 9, 1};
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr.length - i -1; j++) {
if (arr[j] > arr[j + 1]){
int tmp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = tmp;
}
}
}
System.out.println(Arrays.toString(arr));
}
}
|
SelectionSort选择排序
精华：使用当前位置的元素和后面的每一个位置的元素都比较一次,如果发现更小的元素,则交换到当前位置
图示：
代码案例
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| public class SelectionSortAlgorithm {
public static void main(String[] args) {
int[] arr = {4, 7, 8, 9, 5, 6, 8, 9, 4, 2, 1};
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;
}
}
}
System.out.println(Arrays.toString(arr));
}
}
|
Arrays工具类
Arrays工具类中其实就已经封装好了排序算法，所以直接使用吧！
概述
1
| 是java提供的一个专门用于操作数组的工具类,里面所有的方法都是静态方法;
|
常用方法
代码案例
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
| public class MyArrays {
public static void main(String[] args) {
int[] arr = {2, 5, 6, 8, 9, 22, 55, 77, 99};
int i = Arrays.binarySearch(arr, 8);
System.out.println(i);
int[] ints = Arrays.copyOfRange(arr, 1, 4);
System.out.println(Arrays.toString(ints));
int[] arr2 = Arrays.copyOf(arr, 5);
System.out.println(Arrays.toString(arr2));
Arrays.setAll(arr, new IntUnaryOperator() {
@Override
public int applyAsInt(int operand) {
return arr[operand] * 3;
}
});
System.out.println(Arrays.toString(arr));
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
}
}
|
Arrays操作对象数组(※)
对存放对象的数组进行排序，有两种方法
- 方法一：在JavaBean中实现Comparable接口<泛型类-本类类名>（不太灵活，因为可能实体类是别人写的不好修改）
- 方法二：在Arrays.sort(数组，Comparator比较器对象)方法中，使用匿名内部类表达式（方便灵活）
其实不管那种写法，都遵守一个规则：前减后升序，后减前降序
JavaBean
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
| public class Student implements Comparable<Student>{
private String name;
private double height;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getHeight() {
return height;
}
public void setHeight(double height) {
this.height = height;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Student(String name, double height, int age) {
this.name = name;
this.height = height;
this.age = age;
}
public Student() {
}
@Override
public int compareTo(Student o) {
return this.age - o.age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", height=" + height +
", age=" + age +
'}';
}
}
|
方法一&方法二演示
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
| import java.util.Arrays;
import java.util.Comparator;
public class ArraysTest {
public static void main(String[] args) {
Student[] students = new Student[4];
students[0] = new Student("蜘蛛精", 169.5, 23);
students[1] = new Student("紫霞", 163.8, 26);
students[2] = new Student("至尊宝", 163.8, 24);
students[3] = new Student("抓根宝", 167.5, 27);
Arrays.sort(students);
System.out.println(Arrays.toString(students));
Arrays.sort(students, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
return o2.getAge() - o1.getAge();
}
});
System.out.println(Arrays.toString(students));
}
}
|
微信
支付宝