dataList = new ArrayList<>(500000);
63 | for (int i = 0; i < 500000; i++) {
64 | dataList.add(i);
65 | }
66 |
67 | ForkJoinPool pool = new ForkJoinPool();
68 | Integer result = pool.invoke(new Task(dataList));
69 |
70 | System.out.println("result:" + result);
71 |
72 | }
73 |
74 | }
75 |
--------------------------------------------------------------------------------
/src/main/java/com/waylau/java/demo/HelloWorld.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Welcome to https://waylau.com
3 | */
4 | package com.waylau.java.demo;
5 |
6 | /**
7 | * Hello World.
8 | *
9 | * @since 1.0.0 2020年4月12日
10 | * @author Way Lau
11 | */
12 | public class HelloWorld {
13 |
14 | private String words;
15 |
16 | public HelloWorld(String words) {
17 | this.words = words;
18 | }
19 |
20 | public String getWords() {
21 | return words;
22 | }
23 |
24 | }
25 |
--------------------------------------------------------------------------------
/src/main/java/com/waylau/java/demo/algorithm/BinarySearch.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Welcome to https://waylau.com
3 | */
4 | package com.waylau.java.demo.algorithm;
5 |
6 | /**
7 | * Binary Search.
8 | *
9 | *
10 | * Worst-case performance O(log n)
11 | * Best-case performance O(1)
12 | * Average performance O(log n)
13 | * Worst-case space complexity O(1)
14 | *
15 | *
16 | * @since 1.0.0 2020年11月27日
17 | * @author Way Lau
18 | */
19 |
20 | public class BinarySearch> {
21 |
22 | /**
23 | * 值在数组中的索引
24 | *
25 | * @param value 待查找的值
26 | * @param array 假定数组已排序
27 | *
28 | * @return 值在数组中的索引
29 | */
30 | public static final int find(T value, T[] array) {
31 | return recursiveFind(array, value, 0,
32 | array.length - 1);
33 | }
34 |
35 | // 递归查找元素
36 | @SuppressWarnings("unchecked")
37 | private static int recursiveFind(T[] array, T value,
38 | int start, int end) {
39 | if (start == end) {
40 | T lastValue = array[start]; // start==end
41 |
42 | if (value == lastValue) {
43 | return start; // start==end
44 | }
45 |
46 | return Integer.MAX_VALUE;
47 | }
48 |
49 | final int low = start;
50 | final int high = end + 1; // 索引是从0开始的，所以加一个
51 | final int middle = low + ((high - low) / 2); // 取中间索引
52 | final T middleValue = array[middle];
53 |
54 | // 与中间值进行比较
55 | int compareResult = ((Comparable) value)
56 | .compareTo(middleValue);
57 |
58 | if (compareResult == 0) { // 等于中间值，则查找结束
59 | return middle;
60 | } else if (compareResult > 0) {// 大于中间值，则往右查找
61 | return recursiveFind(array, value, middle + 1,
62 | end);
63 | } else {// 小于中间值，则往左查找
64 | return recursiveFind(array, value, start,
65 | middle - 1);
66 | }
67 | }
68 | }
69 |
--------------------------------------------------------------------------------
/src/main/java/com/waylau/java/demo/algorithm/Chromosome.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Welcome to https://waylau.com
3 | */
4 | package com.waylau.java.demo.algorithm;
5 |
6 | import java.util.ArrayList;
7 |
8 | import java.util.List;
9 |
10 | /**
11 | * Chromosome.
12 | *
13 | * @author Way Lau
14 | * @since 2020-11-30
15 | */
16 |
17 | public class Chromosome {
18 | private boolean[] genes;// 基因序列
19 |
20 | private double score;// 对应的函数得分
21 |
22 | public double getScore() {
23 | return score;
24 | }
25 |
26 | public void setScore(double score) {
27 | this.score = score;
28 | }
29 |
30 | /**
31 | * 限制无参构造函数的使用
32 | */
33 | private Chromosome() {
34 | }
35 |
36 | /**
37 | * 随机生成基因序列
38 | *
39 | * @param size 基因序列长度
40 | */
41 | public Chromosome(int size) {
42 | if (size <= 0) {
43 | return;
44 | }
45 |
46 | initGeneSize(size);
47 |
48 | for (int i = 0; i < size; i++) {
49 | genes[i] = Math.random() >= 0.5;
50 | }
51 | }
52 |
53 | /**
54 | * 初始化基因长度
55 | *
56 | * @param size 基因序列长度
57 | */
58 | private void initGeneSize(int size) {
59 | if (size <= 0) {
60 | return;
61 | }
62 |
63 | genes = new boolean[size];
64 | }
65 |
66 | /**
67 | * 将基因转化为对应的数字
68 | *
69 | * @return 基因转化成应的数字
70 | */
71 | public int getNum() {
72 | if (genes == null) {
73 | return 0;
74 | }
75 |
76 | int num = 0;
77 |
78 | for (boolean bool : genes) {
79 | num <<= 1;
80 | if (bool) {
81 | num += 1;
82 | }
83 | }
84 |
85 | return num;
86 | }
87 |
88 | /**
89 | * 基因num个位置发生变异
90 | *
91 | * @param num 突变的位置
92 | */
93 | public void mutation(int num) {
94 | // 允许变异
95 | int size = genes.length;
96 |
97 | for (int i = 0; i < num; i++) {
98 | // 寻找变异位置
99 | int at = ((int) (Math.random() * size)) % size;
100 |
101 | // 变异后的值
102 | boolean bool = !genes[at];
103 | genes[at] = bool;
104 | }
105 | }
106 |
107 | /**
108 | * 克隆染色体
109 | *
110 | * @param c 被克隆染色体
111 | *
112 | * @return 克隆染色体
113 | */
114 | public static Chromosome clone(final Chromosome c) {
115 | if (c == null || c.genes == null) {
116 | return null;
117 | }
118 |
119 | Chromosome clonedChromosome = new Chromosome();
120 | clonedChromosome.initGeneSize(c.genes.length);
121 |
122 | for (int i = 0; i < c.genes.length; i++) {
123 | clonedChromosome.genes[i] = c.genes[i];
124 | }
125 |
126 | return clonedChromosome;
127 | }
128 |
129 | /**
130 | * 遗传产生下一代染色体
131 | *
132 | * @param c1
133 | * @param c2
134 | */
135 | public static List genetic(Chromosome p1,
136 | Chromosome p2) {
137 | if (p1 == null || p2 == null) { // 染色体有一个为空，不产生下一代
138 | return null;
139 | }
140 |
141 | if (p1.genes == null || p2.genes == null) { // 染色体有一个没有基因序列，不产生下一代
142 | return null;
143 | }
144 |
145 | if (p1.genes.length != p2.genes.length) { // 染色体基因序列长度不同，不产生下一代
146 | return null;
147 | }
148 |
149 | Chromosome c1 = clone(p1);
150 | Chromosome c2 = clone(p2);
151 |
152 | // 随机产生交叉互换位置
153 | int size = c1.genes.length;
154 | int a = ((int) (Math.random() * size)) % size;
155 | int b = ((int) (Math.random() * size)) % size;
156 | int min = a > b ? b : a;
157 | int max = a > b ? a : b;
158 |
159 | // 对位置上的基因进行交叉互换
160 | for (int i = min; i <= max; i++) {
161 | boolean t = c1.genes[i];
162 | c1.genes[i] = c2.genes[i];
163 | c2.genes[i] = t;
164 | }
165 |
166 | List list = new ArrayList();
167 |
168 | list.add(c1);
169 | list.add(c2);
170 |
171 | return list;
172 | }
173 | }
--------------------------------------------------------------------------------
/src/main/java/com/waylau/java/demo/algorithm/Fibonacci.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Welcome to https://waylau.com
3 | */
4 | package com.waylau.java.demo.algorithm;
5 |
6 | import java.util.concurrent.RecursiveTask;
7 |
8 | /**
9 | * Fibonacci
10 | *
11 | * @since 1.0.0 2020年11月27日
12 | * @author Way Lau
13 | */
14 | public class Fibonacci extends RecursiveTask {
15 | private static final long serialVersionUID = 1L;
16 |
17 | final int n;
18 |
19 | Fibonacci(int n) {
20 | this.n = n;
21 | }
22 |
23 | protected Integer compute() {
24 | if (n <= 1) {
25 | return n;
26 | }
27 |
28 | Fibonacci f1 = new Fibonacci(n - 1);
29 |
30 | // 创建子任务
31 | f1.fork();
32 | Fibonacci f2 = new Fibonacci(n - 2);
33 |
34 | // 等待子任务结果，并合并结果
35 | return f2.compute() + f1.join();
36 | }
37 |
38 | }
39 |
--------------------------------------------------------------------------------
/src/main/java/com/waylau/java/demo/algorithm/FibonacciDemo.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Welcome to https://waylau.com
3 | */
4 | package com.waylau.java.demo.algorithm;
5 |
6 | import java.util.concurrent.ForkJoinPool;
7 |
8 | /**
9 | * Fibonacci Demo.
10 | *
11 | * @since 1.0.0 2020年11月27日
12 | * @author Way Lau
13 | */
14 | public class FibonacciDemo {
15 |
16 | /**
17 | * @param args
18 | */
19 | public static void main(String[] args) {
20 | // 创建分治任务线程池
21 | ForkJoinPool fjp = new ForkJoinPool(4);
22 |
23 | // 创建分治任务
24 | Fibonacci fib = new Fibonacci(30);
25 |
26 | // 启动分治任务
27 | Integer result = fjp.invoke(fib);
28 |
29 | // 输出结果
30 | System.out.println(result);
31 | }
32 |
33 | }
34 |
--------------------------------------------------------------------------------
/src/main/java/com/waylau/java/demo/algorithm/FibonacciSequenceBasic.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Welcome to https://waylau.com
3 | */
4 | package com.waylau.java.demo.algorithm;
5 |
6 | /**
7 | * Fibonacci Sequence.
8 | *
9 | * @since 1.0.0 2020年11月28日
10 | * @author Way Lau
11 | */
12 | public class FibonacciSequenceBasic {
13 |
14 | public static int fibonacci(int n) {
15 |
16 | if ((n == 1) || (n == 2)) {
17 | return 1;
18 | }
19 |
20 | // 递归
21 | return fibonacci(n - 1) + fibonacci(n - 2);
22 | }
23 | }
24 |
--------------------------------------------------------------------------------
/src/main/java/com/waylau/java/demo/algorithm/FibonacciSequenceForwardCalculation.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Welcome to https://waylau.com
3 | */
4 | package com.waylau.java.demo.algorithm;
5 |
6 | /**
7 | * Fibonacci Sequence Forward Calculation
8 | *
9 | * @since 1.0.0 2020年11月28日
10 | * @author Way Lau
11 | */
12 | public class FibonacciSequenceForwardCalculation {
13 | public static int fibonacci(int n) {
14 | if ((n == 1) || (n == 2)) {
15 | return 1;
16 | }
17 |
18 | int fn = 0;
19 | int fn1 = 1;
20 | int fn2 = 1;
21 | int k = 3;
22 |
23 | while (k <= n) {
24 | fn = fn1 + fn2;
25 | fn1 = fn2;
26 | fn2 = fn;
27 | k++;
28 | }
29 |
30 | return fn;
31 | }
32 |
33 | }
34 |
--------------------------------------------------------------------------------
/src/main/java/com/waylau/java/demo/algorithm/FibonacciSequenceWithCache.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Welcome to https://waylau.com
3 | */
4 | package com.waylau.java.demo.algorithm;
5 |
6 | /**
7 | * Fibonacci Sequence with cache
8 | *
9 | * @since 1.0.0 2020年11月28日
10 | * @author Way Lau
11 | */
12 | public class FibonacciSequenceWithCache {
13 | private static final int cache[] = new int[100000];
14 |
15 | public static int fibonacci(int n) {
16 | if ((n == 1) || (n == 2)) {
17 | return 1;
18 | } else if (0 != cache[n]) {
19 | return cache[n];
20 | }
21 |
22 | cache[n] = fibonacci(n - 1) + fibonacci(n - 2);
23 |
24 | return cache[n];
25 | }
26 | }
27 |
--------------------------------------------------------------------------------
/src/main/java/com/waylau/java/demo/algorithm/GeneticAlgorithmMaxValue.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Welcome to https://waylau.com
3 | */
4 | package com.waylau.java.demo.algorithm;
5 |
6 | /**
7 | * GeneticAlgorithmMaxValue.
8 | *
9 | * @since 1.0.0 2020年11月29日
10 | * @author Way Lau
11 | */
12 | public class GeneticAlgorithmMaxValue
13 | extends GeneticAlgorithm {
14 |
15 | private final int num;
16 |
17 | /**
18 | * 构造函数
19 | *
20 | * @param geneSize
21 | */
22 | public GeneticAlgorithmMaxValue(int geneSize) {
23 | super(geneSize);
24 |
25 | num = 1 << geneSize;
26 | }
27 |
28 | @Override
29 | public double changeX(Chromosome chro) {
30 | return ((1.0 * chro.getNum() / num) * 100) + 6;
31 | }
32 |
33 | @Override
34 | public double caculateY(double x) {
35 | return 100 - Math.log(x);
36 | }
37 | }
38 |
--------------------------------------------------------------------------------
/src/main/java/com/waylau/java/demo/algorithm/GraphColoringProblem.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Welcome to https://waylau.com
3 | */
4 | package com.waylau.java.demo.algorithm;
5 |
6 | /**
7 | * Graph Coloring Problem.
8 | *
9 | * @author Way Lau
10 | * @since 2020-11-02
11 | */
12 | public class GraphColoringProblem {
13 | /**
14 | * 图着色：
15 | *
16 | * @param graph 待着色图
17 | * @param n 图的结点数
18 | * @param m 限制需要涂的颜色种数
19 | *
20 | * @return 满足时返回图着色的结果，否则返回空
21 | */
22 | public static int[] graphColor(int[][] graph, int n,
23 | int m) {
24 | if (m <= 0) {
25 | return null;
26 | }
27 |
28 | int[] color = initColor(n);// 初始化数组
29 | int index = 0;
30 |
31 | while (index >= 0) {
32 | color[index] += 1;// 填色
33 |
34 | while (color[index] <= m) {
35 | // 检验当前所涂颜色是否符合
36 | if (check(graph, color, index)) {
37 | break;// 符合
38 | } else {
39 | color[index] += 1;// 考察下一种颜色
40 | }
41 | }
42 |
43 | if (color[index] <= m && index == n - 1) {
44 | return color;
45 | }
46 |
47 | if (color[index] > m) {
48 | color[index--] = 0;// 回溯
49 | } else {
50 | index++;// 填下一个结点
51 | }
52 | }
53 |
54 | return null;
55 | }
56 |
57 | /**
58 | * 检测当前考察结点的颜色是否符合要求：
59 | *
60 | * @param graph 图
61 | * @param color 图的每个结点的颜色组成的数组
62 | * @param index 索引，用于考察当前结点的颜色是否符合
63 | *
64 | * @return 符合或者不符合
65 | */
66 | public static boolean check(int[][] graph, int[] color,
67 | int index) {
68 | for (int i = 0; i < index; i++) {
69 | // 判断当前结点所图的颜色是否与前面重复
70 |
71 | if (graph[index][i] == 1
72 | && color[i] == color[index]) {
73 | return false;
74 | }
75 | }
76 |
77 | return true;
78 | }
79 |
80 | /**
81 | * 初始化颜色数组：
82 | *
83 | * @param n 结点的个数
84 | * @return 初始化后的数组
85 | */
86 |
87 | public static int[] initColor(int n) {
88 | int[] color = new int[n];
89 |
90 | for (int i = 0; i < n; i++) {
91 | color[i] = 0;
92 | }
93 |
94 | return color;
95 | }
96 | }
--------------------------------------------------------------------------------
/src/main/java/com/waylau/java/demo/algorithm/GreedyAlgorithm.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Welcome to https://waylau.com
3 | */
4 | package com.waylau.java.demo.algorithm;
5 |
6 | import java.util.ArrayList;
7 | import java.util.List;
8 |
9 | /**
10 | * Greedy Algorithm.
11 | *
12 | * @since 1.0.0 2020年11月28日
13 | * @author Way Lau
14 | */
15 | public class GreedyAlgorithm {
16 |
17 | public static int maxNumber(int[] customers) {
18 | if (customers.length < 3) {
19 | return 0;
20 | }
21 |
22 | // 把符合条件的点餐员都取出来
23 | List dealers = new ArrayList<>();
24 |
25 | for (int i = 1; i < customers.length - 1; i++) {
26 | if (customers[i - 1] < customers[i]
27 | && customers[i] > customers[i + 1]) {
28 | dealers.add(i);
29 | i++;
30 | }
31 | }
32 |
33 | // 初始化k为最大数
34 | int k = dealers.size();
35 |
36 | // 等于1则直接返回
37 | if (k == 1) {
38 | return k;
39 | }
40 |
41 | // 大于1的时候进循环
42 | while (k >= 1) {
43 | // 记录合规的点餐员数量
44 | int passed = 1;
45 | for (int i = 0; i < dealers.size() - 1; i++) {
46 | if (dealers.get(i + 1)
47 | - dealers.get(i) >= k) {
48 |
49 | // 相邻两个间隔合规
50 | passed++;
51 | } else if (i < dealers.size() - 2
52 | && dealers.get(i + 2)
53 | - dealers.get(i) >= k) {
54 | // 如果相邻两个不合规，跳过一个看是否合规
55 |
56 | passed++;
57 | i++;
58 | }
59 | }
60 |
61 | // 如果合规个数等于k，则返回
62 | if (k == passed) {
63 | break;
64 | }
65 |
66 | // 否则k减小，再来一次
67 | k--;
68 | }
69 |
70 | return k;
71 | }
72 | }
73 |
--------------------------------------------------------------------------------
/src/main/java/com/waylau/java/demo/algorithm/MapReduce.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Welcome to https://waylau.com
3 | */
4 | package com.waylau.java.demo.algorithm;
5 |
6 | import java.util.HashMap;
7 | import java.util.Map;
8 | import java.util.concurrent.RecursiveTask;
9 |
10 | /**
11 | * MapReduce
12 | *
13 | * @since 1.0.0 2020年11月27日
14 | * @author Way Lau
15 | */
16 | public class MapReduce
17 | extends RecursiveTask> {
18 | private static final long serialVersionUID = 1L;
19 |
20 | private String[] fc;
21 | private int start, end;
22 |
23 | // 构造函数
24 | MapReduce(String[] fc, int fr, int to) {
25 | this.fc = fc;
26 | this.start = fr;
27 | this.end = to;
28 | }
29 |
30 | @Override
31 | protected Map compute() {
32 | if (end - start == 1) {
33 | return calc(fc[start]);
34 | } else {
35 | int mid = (start + end) / 2;
36 | MapReduce mr1 = new MapReduce(fc, start, mid);
37 | mr1.fork();
38 | MapReduce mr2 = new MapReduce(fc, mid, end);
39 |
40 | // 计算子任务，并返回合并的结果
41 | return merge(mr2.compute(), mr1.join());
42 | }
43 | }
44 |
45 | // 合并结果
46 | private Map merge(Map r1,
47 | Map r2) {
48 | Map result = new HashMap<>();
49 | result.putAll(r1);
50 |
51 | // 合并结果
52 | r2.forEach((k, v) -> {
53 | Long c = result.get(k);
54 | if (c != null) {
55 | result.put(k, c + v);
56 | } else {
57 | result.put(k, v);
58 | }
59 |
60 | });
61 | return result;
62 | }
63 |
64 | // 统计单词数量
65 | private Map calc(String line) {
66 | Map result = new HashMap<>();
67 |
68 | // 分割单词
69 | String[] words = line.split("\\s+");
70 |
71 | // 统计单词数量
72 | for (String w : words) {
73 | Long v = result.get(w);
74 | if (v != null) {
75 | result.put(w, v + 1);
76 | } else {
77 | result.put(w, 1L);
78 | }
79 |
80 | }
81 | return result;
82 | }
83 | }
84 |
--------------------------------------------------------------------------------
/src/main/java/com/waylau/java/demo/algorithm/MapReduceDemo.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Welcome to https://waylau.com
3 | */
4 | package com.waylau.java.demo.algorithm;
5 |
6 | import java.util.Map;
7 | import java.util.concurrent.ForkJoinPool;
8 |
9 | /**
10 | * @since 1.0.0 2020年11月27日
11 | * @author Way Lau
12 | */
13 | public class MapReduceDemo {
14 | public static void main(String[] args) {
15 | String[] fc = { "hello world", "hello me",
16 | "hello fork", "hello join",
17 | "fork join in world" };
18 |
19 | // 创建 ForkJoin 线程池
20 | ForkJoinPool fjp = new ForkJoinPool(3);
21 |
22 | // 创建任务
23 | MapReduce mr = new MapReduce(fc, 0, fc.length);
24 |
25 | // 启动任务
26 | Map result = fjp.invoke(mr);
27 |
28 | // 输出结果
29 | result.forEach(
30 | (k, v) -> System.out.println(k + ":" + v));
31 | }
32 | }
33 |
--------------------------------------------------------------------------------
/src/main/java/com/waylau/java/demo/algorithm/MergeSort.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Welcome to https://waylau.com
3 | */
4 | package com.waylau.java.demo.algorithm;
5 |
6 | /**
7 | * Merge sort.
8 | *
9 | * Family: Merging.
10 | * Space: In-place.
11 | * Stable: True.
12 | *
13 | * Average case = O(n*log n)
14 | * Worst case = O(n*log n)
15 | * Best case = O(n*log n)
16 | *
17 | *
18 | * @since 1.0.0 2020年11月27日
19 | * @author Way Lau
20 | */
21 | @SuppressWarnings("unchecked")
22 | public class MergeSort> {
23 |
24 | public static enum SPACE_TYPE {
25 | IN_PLACE, NOT_IN_PLACE
26 | }
27 |
28 | private MergeSort() {
29 | }
30 |
31 | public static > T[] sort(
32 | SPACE_TYPE type, T[] unsorted) {
33 | sort(type, 0, unsorted.length, unsorted);
34 | return unsorted;
35 | }
36 |
37 | private static > void sort(
38 | SPACE_TYPE type, int start, int length,
39 | T[] unsorted) {
40 | if (length > 2) {
41 | int aLength = (int) Math.floor(length / 2);
42 | int bLength = length - aLength;
43 | sort(type, start, aLength, unsorted);
44 | sort(type, start + aLength, bLength, unsorted);
45 |
46 | if (type == SPACE_TYPE.IN_PLACE) {
47 | mergeInPlace(start, aLength,
48 | start + aLength, bLength, unsorted);
49 | } else {
50 | mergeWithExtraStorage(start, aLength,
51 | start + aLength, bLength, unsorted);
52 | }
53 | } else if (length == 2) {
54 | T e = unsorted[start + 1];
55 |
56 | if (e.compareTo(unsorted[start]) < 0) {
57 | unsorted[start + 1] = unsorted[start];
58 | unsorted[start] = e;
59 | }
60 | }
61 | }
62 |
63 | private static > void mergeInPlace(
64 | int aStart, int aLength, int bStart,
65 | int bLength, T[] unsorted) {
66 | int i = aStart;
67 | int j = bStart;
68 |
69 | int aSize = aStart + aLength;
70 | int bSize = bStart + bLength;
71 |
72 | while (i < aSize && j < bSize) {
73 | T a = unsorted[i];
74 | T b = unsorted[j];
75 |
76 | if (b.compareTo(a) < 0) {
77 | // 把所有东西都移到正确的位置
78 | System.arraycopy(unsorted, i, unsorted,
79 | i + 1, j - i);
80 | unsorted[i] = b;
81 | i++;
82 | j++;
83 | aSize++;
84 | } else {
85 | i++;
86 | }
87 | }
88 | }
89 |
90 | private static > void mergeWithExtraStorage(
91 | int aStart, int aLength, int bStart,
92 | int bLength, T[] unsorted) {
93 | int count = 0;
94 | T[] output = (T[]) new Comparable[aLength
95 | + bLength];
96 | int i = aStart;
97 | int j = bStart;
98 |
99 | int aSize = aStart + aLength;
100 | int bSize = bStart + bLength;
101 |
102 | while (i < aSize || j < bSize) {
103 | T a = null;
104 | if (i < aSize) {
105 | a = unsorted[i];
106 | }
107 |
108 | T b = null;
109 | if (j < bSize) {
110 | b = unsorted[j];
111 | }
112 |
113 | if (a != null && b == null) {
114 | output[count++] = a;
115 | i++;
116 | } else if (b != null && a == null) {
117 | output[count++] = b;
118 | j++;
119 | } else if (b != null && b.compareTo(a) <= 0) {
120 | output[count++] = b;
121 | j++;
122 | } else {
123 | output[count++] = a;
124 | i++;
125 | }
126 | }
127 |
128 | int x = 0;
129 | int size = aStart + aLength + bLength;
130 |
131 | for (int y = aStart; y < size; y++) {
132 | unsorted[y] = output[x++];
133 | }
134 | }
135 | }
--------------------------------------------------------------------------------
/src/main/java/com/waylau/java/demo/algorithm/NQueens.java:
--------------------------------------------------------------------------------
1 | package com.waylau.java.demo.algorithm;
2 |
3 | import java.util.Arrays;
4 | import java.util.LinkedList;
5 | import java.util.List;
6 |
7 | /**
8 | * N Queens
9 | *
10 | * @author Way Lau
11 | * @since 2020-11-30
12 | */
13 | public class NQueens {
14 | private static List> res = new LinkedList<>();
15 |
16 | public static List> solveNQueens(int n) {
17 | char[][] board = new char[n][n];
18 |
19 | for (int i = 0; i < n; i++) {
20 | Arrays.fill(board[i], '.');
21 | }
22 |
23 | backtrack(0, board);
24 |
25 | return res;
26 | }
27 |
28 | /**
29 | * backtrack为标准的回溯法模板
30 | *
31 | * @param index 索引，或者已做选择的路径
32 | * @param board
33 | */
34 | private static void backtrack(int index,
35 | char[][] board) {
36 | // 结束条件为所有的皇后都已放置
37 | if (index == board.length) {
38 | res.add(chars2StrList(board));// 把可行解加入到结果集
39 |
40 | return;
41 | }
42 |
43 | int cols = board[0].length;
44 |
45 | // 选择列表为每一列
46 | for (int i = 0; i < cols; i++) {
47 | if (!isValid(board, index, i)) {// 剪枝
48 | continue;
49 | }
50 |
51 | // 做选择，在当前位置放置皇后
52 | board[index][i] = 'Q';
53 |
54 | // 向纵深方向扩展一步
55 | backtrack(index + 1, board);
56 |
57 | // 撤销选择
58 | board[index][i] = '.';
59 | }
60 | }
61 |
62 | private static List chars2StrList(
63 | char[][] board) {
64 | List strList = new LinkedList<>();
65 |
66 | for (char[] row : board) {
67 | strList.add(String.valueOf(row));
68 | }
69 |
70 | return strList;
71 | }
72 |
73 | private static boolean isValid(char[][] board, int row,
74 | int col) {
75 | // 检查同一列有没有放置皇后
76 | for (int i = 0; i < row; i++) {
77 | if (board[i][col] == 'Q') {
78 | return false;
79 | }
80 | }
81 |
82 | // 检查左上角的对角线有没有放置皇后
83 | for (int i = row - 1, j = col - 1; i >= 0
84 | && j >= 0; i--, j--) {
85 | if (board[i][j] == 'Q') {
86 | return false;
87 | }
88 | }
89 |
90 | // 检查右上角的对角线有没有放置皇后
91 | for (int i = row - 1, j = col + 1; i >= 0
92 | && j < board.length; i--, j++) {
93 | if (board[i][j] == 'Q') {
94 | return false;
95 | }
96 | }
97 |
98 | return true;
99 | }
100 | }
101 |
--------------------------------------------------------------------------------
/src/main/java/com/waylau/java/demo/algorithm/QuickSort.java:
--------------------------------------------------------------------------------
1 | package com.waylau.java.demo.algorithm;
2 |
3 | import java.util.Random;
4 |
5 | /**
6 | * Quick sort.
7 | *
8 | *
9 | * Family: Divide and conquer.
10 | * Space: In-place.
11 | * Stable: False.
12 | *
13 | *
14 | * Average case = O(n*log n)
15 | * Worst case = O(n^2)
16 | * Best case = O(n) [three-way partition and equal keys]
17 | *
18 | *
19 | *
20 | * @author Way Lau
21 | * @since 2020-11-27
22 | */
23 | public class QuickSort> {
24 |
25 | private static final Random RAND = new Random();
26 |
27 | public static enum PIVOT_TYPE {
28 | FIRST, MIDDLE, RANDOM
29 | }
30 |
31 | public static PIVOT_TYPE type = PIVOT_TYPE.RANDOM;
32 |
33 | private QuickSort() {
34 | }
35 |
36 | public static > T[] sort(
37 | PIVOT_TYPE pivotType, T[] unsorted) {
38 | int pivot = 0;
39 |
40 | if (pivotType == PIVOT_TYPE.MIDDLE) {
41 | pivot = unsorted.length / 2;
42 | } else if (pivotType == PIVOT_TYPE.RANDOM) {
43 | pivot = getRandom(unsorted.length);
44 | }
45 |
46 | sort(pivot, 0, unsorted.length - 1, unsorted);
47 |
48 | return unsorted;
49 | }
50 |
51 | private static > void sort(
52 | int index, int start, int finish,
53 | T[] unsorted) {
54 | int pivotIndex = start + index;
55 | T pivot = unsorted[pivotIndex];
56 | int s = start;
57 | int f = finish;
58 |
59 | while (s <= f) {
60 | while (unsorted[s].compareTo(pivot) < 0) {
61 | s++;
62 | }
63 |
64 | while (unsorted[f].compareTo(pivot) > 0) {
65 | f--;
66 | }
67 |
68 | if (s <= f) {
69 | swap(s, f, unsorted);
70 | s++;
71 | f--;
72 | }
73 | }
74 |
75 | if (start < f) {
76 | pivotIndex = getRandom((f - start) + 1);
77 | sort(pivotIndex, start, f, unsorted);
78 | }
79 |
80 | if (s < finish) {
81 | pivotIndex = getRandom((finish - s) + 1);
82 | sort(pivotIndex, s, finish, unsorted);
83 | }
84 | }
85 |
86 | private static final int getRandom(int length) {
87 | if (type == PIVOT_TYPE.RANDOM && length > 0) {
88 | return RAND.nextInt(length);
89 | }
90 |
91 | if (type == PIVOT_TYPE.FIRST && length > 0) {
92 | return 0;
93 | }
94 |
95 | return length / 2;
96 | }
97 |
98 | private static > void swap(
99 | int index1, int index2, T[] unsorted) {
100 | T index2Element = unsorted[index1];
101 | unsorted[index1] = unsorted[index2];
102 | unsorted[index2] = index2Element;
103 | }
104 |
105 | }
106 |
--------------------------------------------------------------------------------
/src/main/java/com/waylau/java/demo/datastructure/ArrayBinaryTree.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Welcome to https://waylau.com
3 | */
4 | package com.waylau.java.demo.datastructure;
5 |
6 | import java.util.List;
7 |
8 | /**
9 | * ArrayBinaryTree.
10 | *
11 | * @since 1.0.0 2020年8月12日
12 | * @author Way Lau
13 | */
14 | public class ArrayBinaryTree {
15 |
16 | private T[] arr;
17 |
18 | public ArrayBinaryTree(T[] arr) {
19 | if (arr == null || arr.length == 0) {
20 | throw new IllegalArgumentException(
21 | "arr must not null");
22 | }
23 |
24 | this.arr = arr;
25 | }
26 |
27 | // 前序遍历
28 | public void preOrder(int index, List result) {
29 | result.add(arr[index]);
30 |
31 | if (2 * index + 1 < arr.length) {
32 | preOrder(2 * index + 1, result);
33 | }
34 |
35 | if (2 * index + 2 < arr.length) {
36 | preOrder(2 * index + 2, result);
37 | }
38 | }
39 |
40 | // 中序遍历
41 | public void infixOrder(int index, List result) {
42 | if (2 * index + 1 < arr.length) {
43 | infixOrder(2 * index + 1, result);
44 | }
45 |
46 | result.add(arr[index]);
47 |
48 | if (2 * index + 2 < arr.length) {
49 | infixOrder(2 * index + 2, result);
50 | }
51 | }
52 |
53 | // 后序遍历
54 | public void postOrder(int index, List result) {
55 | if (2 * index + 1 < arr.length) {
56 | postOrder(2 * index + 1, result);
57 | }
58 |
59 | if (2 * index + 2 < arr.length) {
60 | postOrder(2 * index + 2, result);
61 | }
62 |
63 | result.add(arr[index]);
64 | }
65 |
66 | }
67 |
--------------------------------------------------------------------------------
/src/main/java/com/waylau/java/demo/datastructure/ArrayBlockingQueueDemo.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Welcome to https://waylau.com
3 | */
4 | package com.waylau.java.demo.datastructure;
5 |
6 | import java.util.concurrent.ArrayBlockingQueue;
7 | import java.util.concurrent.BlockingQueue;
8 |
9 | /**
10 | * ArrayBlockingQueue Demo
11 | *
12 | * @since 1.0.0 2020年5月3日
13 | * @author Way Lau
14 | */
15 | class ArrayBlockingQueueDemo {
16 |
17 | public static void main(String[] args) {
18 | BlockingQueue queue =
19 | new ArrayBlockingQueue(3);
20 |
21 | // 1个生产者
22 | Producer p = new Producer(queue);
23 |
24 | // 2个消费者
25 | Consumer c1 = new Consumer("c1", queue);
26 | Consumer c2 = new Consumer("c2", queue);
27 |
28 | // 启动线程
29 | new Thread(p).start();
30 | new Thread(c1).start();
31 | new Thread(c2).start();
32 | }
33 |
34 | }
35 |
36 |
--------------------------------------------------------------------------------
/src/main/java/com/waylau/java/demo/datastructure/ArrayDemo.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Welcome to https://waylau.com
3 | */
4 | package com.waylau.java.demo.datastructure;
5 |
6 | import com.waylau.java.demo.studentinfo.Student;
7 |
8 | /**
9 | * Array Demo.
10 | *
11 | * @since 1.0.0 2020年5月3日
12 | * @author Way Lau
13 | */
14 | public class ArrayDemo {
15 |
16 | /**
17 | * @param args
18 | */
19 | @SuppressWarnings("unused")
20 | public static void main(String[] args) {
21 | // 声明数组
22 | int[] anArray;
23 |
24 | // 分配内存空间
25 | anArray = new int[10];
26 |
27 | // 初始化元素
28 | anArray[0] = 100;
29 | anArray[1] = 200;
30 | anArray[2] = 300;
31 | anArray[3] = 400;
32 | anArray[4] = 500;
33 | anArray[5] = 600;
34 | anArray[6] = 700;
35 | anArray[7] = 800;
36 | anArray[8] = 900;
37 | anArray[9] = 1000;
38 | // anArray[10] = 66666; // 错误！报java.lang.ArrayIndexOutOfBoundsException异常
39 |
40 | // 获取元素值
41 | System.out.println("Element at index 0: " + anArray[0]);
42 | System.out.println("Element at index 1: " + anArray[1]);
43 | System.out.println("Element at index 2: " + anArray[2]);
44 | System.out.println("Element at index 3: " + anArray[3]);
45 | System.out.println("Element at index 4: " + anArray[4]);
46 | System.out.println("Element at index 5: " + anArray[5]);
47 | System.out.println("Element at index 6: " + anArray[6]);
48 | System.out.println("Element at index 7: " + anArray[7]);
49 | System.out.println("Element at index 8: " + anArray[8]);
50 | System.out.println("Element at index 9: " + anArray[9]);
51 | System.out.println("Array length: " + anArray.length);
52 |
53 | // 基本数据类型
54 | int[] array = new int[] { 1, 2, 3, 4, 5 };
55 | int[] intArray = { 1, 2, 3, 4, 5 };
56 | double[] doubleArray = { 1.1D, 22.62D, 33.3D, 44.4D };
57 | boolean[] booleanArray = { true, false };
58 | char[] charArray = { 'd', 'e', 'w', 'a', 'y', 'f', 'e', 'd' };
59 | String[] stringArray = { "C", "C++", "Java" };
60 |
61 | // 复杂数据类型
62 | Student student1 = new Student(32, "Way Lau", "17088888888", "Shenzhen");
63 | Student student2 = new Student(28, "Ken Sun", "17000000000", "Shenzhen");
64 | Student[] studentArray = { student1, student2 };
65 |
66 | // 数组的默认值
67 | // arrayDefault等效于arrayDefault2
68 | int[] arrayDefault = new int[5];
69 | int[] arrayDefault2 = new int[] { 0, 0, 0, 0, 0 };
70 |
71 | // 二维数组
72 | // 即创建了一个 3*2 的二维数组，array 里有三个数组元素，三个数组元素都是长度为 2 的一维数组的引用。
73 | int[][] twoDArray = new int[3][2];
74 |
75 | // 二维数组相当于是一维数组这种引用类型的引用组成的
76 | // twoDArray2等价于twoDArray3
77 | int[][] twoDArray2 = new int[3][];
78 | int[][] twoDArray3 = { null, null, null };
79 |
80 | // 下面可以为 array 数组分别赋上长度不同的一维数组
81 | int[][] twoDArray4 = new int[3][];
82 | twoDArray4[0] = new int[1];
83 | twoDArray4[1] = new int[2];
84 | twoDArray4[2] = new int[3];
85 |
86 | int[][] twoDArray5 = { { 1, 2 }, { 1, 3, 5 }, { 2 } };
87 |
88 | }
89 | }
90 |
--------------------------------------------------------------------------------
/src/main/java/com/waylau/java/demo/datastructure/ArrayPriorityQueue.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Welcome to https://waylau.com
3 | */
4 | package com.waylau.java.demo.datastructure;
5 |
6 | import java.util.Arrays;
7 | import java.util.Comparator;
8 |
9 | /**
10 | * Array-based Priority Queue.
11 | *
12 | * @since 1.0.0 2020年9月14日
13 | * @author Way Lau
14 | */
15 | public class ArrayPriorityQueue
16 | implements PriorityQueue {
17 | private static final int DEFAULT_INITIAL_CAPACITY = 11;
18 |
19 | private int size;
20 |
21 | private Object[] queue;
22 |
23 | private final Comparator comparator;
24 |
25 | public ArrayPriorityQueue() {
26 | this(DEFAULT_INITIAL_CAPACITY, null);
27 | }
28 |
29 | public ArrayPriorityQueue(int initialCapacity) {
30 | this(initialCapacity, null);
31 | }
32 |
33 | public ArrayPriorityQueue(
34 | Comparator comparator) {
35 | this(DEFAULT_INITIAL_CAPACITY, comparator);
36 | }
37 |
38 | public ArrayPriorityQueue(int initialCapacity,
39 | Comparator comparator) {
40 | if (initialCapacity < 1) {
41 | throw new IllegalArgumentException();
42 | }
43 |
44 | this.queue = new Object[initialCapacity];
45 | this.comparator = comparator;
46 | }
47 |
48 | @Override
49 | public boolean add(E e) {
50 | int i = size;
51 |
52 | // 判断容量，自动增长
53 | if (i >= queue.length) {
54 | grow(i + 1);
55 | }
56 |
57 | // 从新排序
58 | siftUp(i, e);
59 | size = i + 1;
60 |
61 | return true;
62 | }
63 |
64 | @SuppressWarnings("unchecked")
65 | @Override
66 | public E remove() {
67 | // 删除返回首个元素
68 | // 后续元素前移
69 |
70 | if (size == 0) {
71 | return null;
72 | }
73 |
74 | final Object[] es = queue;
75 | E result = (E) es[0]; // 首个元素
76 | es[0] = null; // 删除首个元素
77 |
78 | int newCapacity = --size;
79 |
80 | // 后续元素前移
81 | Object[] newQueue = new Object[newCapacity];
82 | System.arraycopy(queue, 1, newQueue, 0,
83 | newCapacity);
84 |
85 | queue = newQueue;
86 |
87 | return result;
88 | }
89 |
90 | private void grow(int minCapacity) {
91 | int oldCapacity = queue.length;
92 |
93 | // 如果是小数组则容量加倍；
94 | // 如果是大数组则容量加50%
95 | int newCapacity = oldCapacity
96 | + ((oldCapacity < 64) ? (oldCapacity + 2)
97 | : (oldCapacity >> 1));
98 |
99 | queue = Arrays.copyOf(queue, newCapacity);
100 | }
101 |
102 | private void siftUp(int k, E x) {
103 | if (comparator != null) {
104 | siftUpUsingComparator(k, x, queue, comparator);
105 | } else {
106 | siftUpComparable(k, x, queue);
107 | }
108 | }
109 |
110 | @SuppressWarnings("unchecked")
111 | private static void siftUpComparable(int k, T x,
112 | Object[] es) {
113 |
114 | Comparable key = (Comparable) x;
115 |
116 | // 从后往前遍历队列
117 | for (int i = k; i > 0; i--) {
118 | // 与队列的前一位进行比较;
119 | // 如果比前一位小，则进行位置交换，交换完成后，再与前一位比较；否则比较结束。
120 | int preIndex = i - 1;
121 | Object pre = es[preIndex];
122 |
123 | if (key.compareTo((T) pre) >= 0) {
124 | break;
125 | }
126 |
127 | es[k] = pre;
128 | k = preIndex;
129 | }
130 |
131 | es[k] = key;
132 | }
133 |
134 | @SuppressWarnings("unchecked")
135 | private static void siftUpUsingComparator(int k,
136 | T x, Object[] es, Comparator cmp) {
137 | // 从后往前遍历队列
138 | for (int i = k; i > 0; i--) {
139 | // 与队列的前一位进行比较;
140 | // 如果比前一位小，则进行位置交换，交换完成后，再与前一位比较；否则比较结束。
141 | int preIndex = i - 1;
142 | Object pre = es[preIndex];
143 |
144 | if (cmp.compare(x, (T) pre) >= 0) {
145 | break;
146 | }
147 |
148 | es[k] = pre;
149 | k = preIndex;
150 | }
151 |
152 | es[k] = x;
153 | }
154 |
155 | }
156 |
--------------------------------------------------------------------------------
/src/main/java/com/waylau/java/demo/datastructure/AvlNode.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Welcome to https://waylau.com
3 | */
4 | package com.waylau.java.demo.datastructure;
5 |
6 | /**
7 | * AVL Node.
8 | *
9 | * @since 1.0.0 2020年10月28日
10 | * @author Way Lau
11 | */
12 | public class AvlNode {
13 | private T data;
14 | private AvlNode left; // 左结点
15 | private AvlNode right; // 右结点
16 | private Integer height; // 节点高度
17 |
18 | AvlNode(T data) {
19 | this(data, null, null);
20 | }
21 |
22 | AvlNode(T data, AvlNode left, AvlNode right) {
23 | this.data = data;
24 | this.left = left;
25 | this.right = right;
26 | this.height = 0;
27 | }
28 |
29 | public T getData() {
30 | return data;
31 | }
32 |
33 | public void setData(T data) {
34 | this.data = data;
35 | }
36 |
37 | public AvlNode getLeft() {
38 | return left;
39 | }
40 |
41 | public void setLeft(AvlNode left) {
42 | this.left = left;
43 | }
44 |
45 | public AvlNode getRight() {
46 | return right;
47 | }
48 |
49 | public void setRight(AvlNode right) {
50 | this.right = right;
51 | }
52 |
53 | public Integer getHeight() {
54 | return height;
55 | }
56 |
57 | public void setHeight(Integer height) {
58 | this.height = height;
59 | }
60 |
61 | }
62 |
--------------------------------------------------------------------------------
/src/main/java/com/waylau/java/demo/datastructure/BinarySearchTree.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Welcome to https://waylau.com
3 | */
4 | package com.waylau.java.demo.datastructure;
5 |
6 | import java.util.List;
7 | /**
8 | * Binary Search Tree.
9 | *
10 | * @since 1.0.0 2020年9月23日
11 | * @author Way Lau
12 | */
13 | public interface BinarySearchTree {
14 | boolean isEmpty(); // 判断树是否为空
15 |
16 | void insert(E e); // 插入节点
17 |
18 | void remove(E e); // 删除节点
19 |
20 | E findMin(); // 找最小节点
21 |
22 | E findMax(); // 找最大节点
23 |
24 | List preOrder();// 前序遍历
25 |
26 | List infixOrder(); // 中序遍历
27 |
28 | List postOrder(); // 后序遍历
29 |
30 | void print(); // 打印树的信息
31 | }
32 |
--------------------------------------------------------------------------------
/src/main/java/com/waylau/java/demo/datastructure/BinaryTreeNode.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Welcome to https://waylau.com
3 | */
4 | package com.waylau.java.demo.datastructure;
5 |
6 | /**
7 | * BinaryTree Node.
8 | *
9 | * @since 1.0.0 2020年8月13日
10 | * @author Way Lau
11 | */
12 | public class BinaryTreeNode {
13 |
14 | private T data;
15 |
16 | private BinaryTreeNode left; // 左结点
17 |
18 | private BinaryTreeNode right; // 右结点
19 |
20 | BinaryTreeNode(T data) {
21 | this(data, null, null);
22 | }
23 |
24 | BinaryTreeNode(T data, BinaryTreeNode left,
25 | BinaryTreeNode right) {
26 | this.left = left;
27 | this.right = right;
28 | this.data = data;
29 | }
30 |
31 | public T getData() {
32 | return data;
33 | }
34 |
35 | public void setData(T data) {
36 | this.data = data;
37 | }
38 |
39 | public BinaryTreeNode getLeft() {
40 | return left;
41 | }
42 |
43 | public void setLeft(BinaryTreeNode left) {
44 | this.left = left;
45 | }
46 |
47 | public BinaryTreeNode getRight() {
48 | return right;
49 | }
50 |
51 | public void setRight(BinaryTreeNode right) {
52 | this.right = right;
53 | }
54 |
55 | }
--------------------------------------------------------------------------------
/src/main/java/com/waylau/java/demo/datastructure/ConcurrentSkipListMapDemo.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Welcome to https://waylau.com
3 | */
4 | package com.waylau.java.demo.datastructure;
5 |
6 |
7 | import java.util.Map;
8 | import java.util.concurrent.ConcurrentSkipListMap;
9 |
10 | /**
11 | * ConcurrentSkipListMap Demo: Word Count.
12 | *
13 | * @since 1.0.0 2020年6月14日
14 | * @author Way Lau
15 | */
16 | public class ConcurrentSkipListMapDemo {
17 |
18 | /**
19 | * @param args
20 | */
21 | @SuppressWarnings("preview")
22 | public static void main(String[] args) {
23 | Map wordCountStore = new ConcurrentSkipListMap<>();
24 |
25 | // JDK13之后
26 | String wordString = """
27 | Give me the strength lightly to bear my joys and sorrows
28 | Give me the strength to make my love fruitful in service
29 | Give me the strength never to disown the poor or bend my knees
30 | before insolent might
31 | Give me the strength to raise my mind high above daily trifles
32 | And give me the strength to surrender my strength to thy will with love
33 | """;
34 |
35 | // 转为字符串数组.
36 | // 换行符和头尾空格要特殊处理
37 | String[] words = wordString.replace("\n", " ")
38 | .strip().split(" ");
39 |
40 | for (String word : words) {
41 |
42 | // key统一为小写
43 | String key = word.toLowerCase();// 转为小写
44 |
45 | Integer value = wordCountStore.get(key);
46 |
47 | // 如果value不存在，则先赋值为0
48 | if (value == null) {
49 | value = 0;
50 | }
51 |
52 | // 累加1
53 | value += 1;
54 |
55 | // 存到Map中
56 | wordCountStore.put(key, value);
57 | }
58 |
59 | // 输出结果到控制台
60 | for (Map.Entry entry : wordCountStore
61 | .entrySet()) {
62 | String key = entry.getKey();
63 | Integer value = entry.getValue();
64 | System.out.println(key + ": " + value);
65 | }
66 |
67 | }
68 |
69 | }
70 |
--------------------------------------------------------------------------------
/src/main/java/com/waylau/java/demo/datastructure/Consumer.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Welcome to https://waylau.com
3 | */
4 | package com.waylau.java.demo.datastructure;
5 |
6 | import java.util.concurrent.BlockingQueue;
7 |
8 | /**
9 | * Consumer
10 | *
11 | * @since 1.0.0 2020年5月29日
12 | * @author Way Lau
13 | */
14 |
15 | class Consumer implements Runnable {
16 |
17 | private final BlockingQueue queue;
18 |
19 | private final String name;
20 |
21 | Consumer(String name, BlockingQueue queue) {
22 | this.queue = queue;
23 | this.name = name;
24 | }
25 |
26 | public void run() {
27 | try {
28 | while (true) {
29 | // 模拟耗时操作
30 | Thread.sleep(2000L);
31 | consume(queue.take());
32 | }
33 | } catch (InterruptedException ex) {
34 | ex.printStackTrace();
35 | }
36 | }
37 |
38 | void consume(Object x) {
39 | System.out.println(this.name + " consume " + x);
40 | }
41 |
42 | }
--------------------------------------------------------------------------------
/src/main/java/com/waylau/java/demo/datastructure/GomokuGame.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Welcome to https://waylau.com
3 | */
4 | package com.waylau.java.demo.datastructure;
5 |
6 | /**
7 | * Gomoku Gamme.
8 | *
9 | * @since 1.0.0 2020年5月5日
10 | * @author Way Lau
11 | */
12 | public class GomokuGame {
13 |
14 | /**
15 | *
16 | */
17 | public GomokuGame() {
18 | // TODO Auto-generated constructor stub
19 | }
20 |
21 | /**
22 | * @param args
23 | */
24 | public static void main(String[] args) {
25 | // TODO Auto-generated method stub
26 |
27 | }
28 |
29 | }
30 |
--------------------------------------------------------------------------------
/src/main/java/com/waylau/java/demo/datastructure/GraphAStar.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Welcome to https://waylau.com
3 | */
4 | package com.waylau.java.demo.datastructure;
5 |
6 | import java.util.ArrayList;
7 | import java.util.Collections;
8 | import java.util.Comparator;
9 | import java.util.HashMap;
10 | import java.util.HashSet;
11 | import java.util.List;
12 | import java.util.Map;
13 | import java.util.Set;
14 |
15 | import com.waylau.java.demo.datastructure.Graph.Edge;
16 | import com.waylau.java.demo.datastructure.Graph.Vertex;
17 |
18 | /**
19 | * In computer science, A* is a computer algorithm that is widely used in path
20 | * finding and graph traversal, the process of plotting an efficiently
21 | * traversable path between multiple points, called nodes.
22 | *
23 | * @since 1.0.0 2020年11月25日
24 | * @author Way Lau
25 | */
26 | public class GraphAStar> {
27 | public GraphAStar() {
28 |
29 | }
30 |
31 | /**
32 | * 从开始点到结束点使用A*算法查找路径，如果不存在路径，则返回NULL
33 | *
34 | * @param graph Graph to search.
35 | * @param start Start vertex.
36 | * @param goal Goal vertex.
37 | *
38 | * @return 从开始点到结束点边的列表，如果不存在，则返回NULL
39 | */
40 | public List> aStar(Graph graph,
41 | Graph.Vertex start, Graph.Vertex goal) {
42 | final int size = graph.getVertices().size(); // 用于适当调整数据结构的大小
43 | final Set> closedSet = new HashSet>(
44 | size); // 已评估的节点集。
45 | final List> openSet = new ArrayList>(
46 | size); // 要评估的暂定节点的集合，最初包含起始节点
47 | openSet.add(start);
48 | final Map, Graph.Vertex> cameFrom = new HashMap, Graph.Vertex>(
49 | size); // 导航节点
50 | final Map, Integer> gScore = new HashMap, Integer>(); // 从开始沿最知名的路径的权值
51 | gScore.put(start, 0);
52 |
53 | // 从开始到目标到y的估计总权值
54 | final Map, Integer> fScore = new HashMap, Integer>();
55 | for (Graph.Vertex v : graph.getVertices()) {
56 | fScore.put(v, Integer.MAX_VALUE);
57 | }
58 |
59 | fScore.put(start,
60 | heuristicCostEstimate(start, goal));
61 |
62 | final Comparator> comparator = new Comparator>() {
63 | /**
64 | * {@inheritDoc}
65 | */
66 | @Override
67 | public int compare(Vertex o1, Vertex o2) {
68 | if (fScore.get(o1) < fScore.get(o2)) {
69 | return -1;
70 | }
71 |
72 | if (fScore.get(o2) < fScore.get(o1)) {
73 | return 1;
74 | }
75 |
76 | return 0;
77 | }
78 | };
79 |
80 | while (!openSet.isEmpty()) {
81 | final Graph.Vertex current = openSet.get(0);
82 | if (current.equals(goal)) {
83 | return reconstructPath(cameFrom, goal);
84 | }
85 |
86 | openSet.remove(0);
87 | closedSet.add(current);
88 |
89 | for (Graph.Edge edge : current.getEdges()) {
90 | final Graph.Vertex neighbor = edge
91 | .getToVertex();
92 |
93 | if (closedSet.contains(neighbor)) {
94 | continue; // 忽略已评估的
95 | }
96 |
97 | final int tenativeGScore = gScore
98 | .get(current)
99 | + distanceBetween(current,
100 | neighbor); // 路径长度
101 |
102 | if (!openSet.contains(neighbor)) {
103 | openSet.add(neighbor); // 发现新结点
104 | } else if (tenativeGScore >= gScore
105 | .get(neighbor)) {
106 | continue;
107 | }
108 |
109 | // 这条路到现在为止是最好的。记录下来！
110 | cameFrom.put(neighbor, current);
111 | gScore.put(neighbor, tenativeGScore);
112 | final int estimatedFScore = gScore
113 | .get(neighbor)
114 | + heuristicCostEstimate(neighbor,
115 | goal);
116 |
117 | fScore.put(neighbor, estimatedFScore);
118 |
119 | // fScore改变了，需要重新排序
120 | Collections.sort(openSet, comparator);
121 | }
122 | }
123 |
124 | return null;
125 | }
126 |
127 | /**
128 | * 默认距离为边的权值。如果开始和下一个之间没有边，则返回Integer.MAX_VALUE；
129 | */
130 | protected int distanceBetween(Graph.Vertex start,
131 | Graph.Vertex next) {
132 |
133 | for (Edge e : start.getEdges()) {
134 | if (e.getToVertex().equals(next)) {
135 | return e.getCost();
136 | }
137 | }
138 |
139 | return Integer.MAX_VALUE;
140 | }
141 |
142 | /**
143 | * 默认每个顶点的权值为1
144 | */
145 | protected int heuristicCostEstimate(
146 | Graph.Vertex start, Graph.Vertex goal) {
147 | return 1;
148 | }
149 |
150 | private List> reconstructPath(
151 | Map, Graph.Vertex> cameFrom,
152 | Graph.Vertex current) {
153 |
154 | final List> totalPath = new ArrayList>();
155 |
156 | while (current != null) {
157 | final Graph.Vertex previous = current;
158 | current = cameFrom.get(current);
159 |
160 | if (current != null) {
161 | final Graph.Edge edge = current
162 | .getEdge(previous);
163 | totalPath.add(edge);
164 | }
165 |
166 | }
167 |
168 | Collections.reverse(totalPath);
169 |
170 | return totalPath;
171 | }
172 |
173 | }
174 |
--------------------------------------------------------------------------------
/src/main/java/com/waylau/java/demo/datastructure/GraphBreadthFirstTraversal.java:
--------------------------------------------------------------------------------
1 | package com.waylau.java.demo.datastructure;
2 |
3 | import java.util.ArrayDeque;
4 | import java.util.ArrayList;
5 | import java.util.HashMap;
6 | import java.util.List;
7 | import java.util.Map;
8 | import java.util.Queue;
9 | import com.waylau.java.demo.datastructure.Graph.Edge;
10 | import com.waylau.java.demo.datastructure.Graph.Vertex;
11 | /**
12 | * Breadth-first search (BFS) for traversing or searching graph data structures.
13 | *
14 | * @author Way Lau
15 | * @since 2020-10-12
16 | */
17 | public class GraphBreadthFirstTraversal {
18 | @SuppressWarnings("unchecked")
19 | public static final > Graph.Vertex[] breadthFirstTraversal(
20 | Graph graph,
21 | Graph.Vertex source) {
22 | // 用于通过索引查找
23 | final ArrayList> vertices = new ArrayList>();
24 | vertices.addAll(graph.getVertices());
25 |
26 | // 用于通过顶点查找
27 | final int n = vertices.size();
28 | final Map, Integer> vertexToIndex = new HashMap, Integer>();
29 |
30 | for (int i = 0; i < n; i++) {
31 | final Vertex v = vertices.get(i);
32 | vertexToIndex.put(v, i);
33 | }
34 |
35 | // 邻接矩阵
36 | final byte[][] adj = new byte[n][n];
37 |
38 | for (int i = 0; i < n; i++) {
39 | final Vertex v = vertices.get(i);
40 | final int idx = vertexToIndex.get(v);
41 | final byte[] array = new byte[n];
42 | adj[idx] = array;
43 | final List> edges = v.getEdges();
44 |
45 | for (Edge e : edges) {
46 | array[vertexToIndex
47 | .get(e.getToVertex())] = 1;
48 | }
49 | }
50 |
51 | // visited 用于记录访问过的顶点。初始值都是-1
52 | final byte[] visited = new byte[n];
53 |
54 | for (int i = 0; i < visited.length; i++) {
55 | visited[i] = -1;
56 | }
57 |
58 | // 返回的结果
59 | final Graph.Vertex[] result = new Graph.Vertex[n];
60 |
61 | // source为遍历的起点
62 | Vertex element = source;
63 |
64 | int c = 0;
65 | int i = vertexToIndex.get(element);
66 | int k = 0;
67 |
68 | result[k] = element;
69 | visited[i] = 1;
70 |
71 | k++;
72 |
73 | final Queue> queue = new ArrayDeque>();
74 | queue.add(source);
75 |
76 | while (!queue.isEmpty()) {
77 | element = queue.peek();
78 | c = vertexToIndex.get(element);
79 | i = 0;
80 |
81 | while (i < n) {
82 | if (adj[c][i] == 1 && visited[i] == -1) {
83 | final Vertex v = vertices.get(i);
84 | queue.add(v);
85 | visited[i] = 1;
86 | result[k] = v;
87 |
88 | k++;
89 | }
90 |
91 | i++;
92 | }
93 |
94 | queue.poll();
95 | }
96 |
97 | return result;
98 |
99 | }
100 | }
--------------------------------------------------------------------------------
/src/main/java/com/waylau/java/demo/datastructure/GraphDepthFirstTraversal.java:
--------------------------------------------------------------------------------
1 | package com.waylau.java.demo.datastructure;
2 |
3 | import java.util.ArrayList;
4 | import java.util.HashMap;
5 | import java.util.List;
6 | import java.util.Map;
7 | import java.util.Stack;
8 | import com.waylau.java.demo.datastructure.Graph.Edge;
9 | import com.waylau.java.demo.datastructure.Graph.Vertex;
10 | /**
11 | * Depth-first search (DFS) for traversing or searching graph data structures.
12 | *
13 | * @author Way Lau
14 | * @since 2020-10-12
15 | */
16 | public class GraphDepthFirstTraversal {
17 | @SuppressWarnings("unchecked")
18 | public static > Graph.Vertex[] depthFirstTraversal(
19 | Graph graph,
20 | Graph.Vertex source) {
21 | // 用于通过索引查找
22 | final ArrayList> vertices = new ArrayList>();
23 |
24 | vertices.addAll(graph.getVertices());
25 |
26 | // 用于通过顶点查找
27 | final int n = vertices.size();
28 | final Map, Integer> vertexToIndex = new HashMap, Integer>();
29 |
30 | for (int i = 0; i < n; i++) {
31 | final Vertex v = vertices.get(i);
32 | vertexToIndex.put(v, i);
33 | }
34 |
35 | // 邻接矩阵
36 | final byte[][] adj = new byte[n][n];
37 | for (int i = 0; i < n; i++) {
38 | final Vertex v = vertices.get(i);
39 | final int idx = vertexToIndex.get(v);
40 | final byte[] array = new byte[n];
41 | adj[idx] = array;
42 | final List> edges = v.getEdges();
43 |
44 | for (Edge e : edges)
45 | array[vertexToIndex
46 | .get(e.getToVertex())] = 1;
47 | }
48 |
49 | // visited 用于记录访问过的顶点。初始值都是-1
50 | final byte[] visited = new byte[n];
51 |
52 | for (int i = 0; i < visited.length; i++) {
53 | visited[i] = -1;
54 | }
55 |
56 | // 返回的结果
57 | final Graph.Vertex[] arr = new Graph.Vertex[n];
58 |
59 | // source为遍历的起点
60 | Vertex element = source;
61 |
62 | int c = 0;
63 | int i = vertexToIndex.get(element);
64 | int k = 0;
65 | visited[i] = 1;
66 | arr[k] = element;
67 |
68 | k++;
69 |
70 | final Stack> stack = new Stack>();
71 | stack.push(source);
72 |
73 | while (!stack.isEmpty()) {
74 | element = stack.peek();
75 | c = vertexToIndex.get(element);
76 | i = 0;
77 |
78 | while (i < n) {
79 | if (adj[c][i] == 1 && visited[i] == -1) {
80 | final Vertex v = vertices.get(i);
81 | stack.push(v);
82 | visited[i] = 1;
83 | element = v;
84 |
85 | c = vertexToIndex.get(element);
86 | i = 0;
87 |
88 | arr[k] = v;
89 | k++;
90 |
91 | continue;
92 | }
93 |
94 | i++;
95 | }
96 |
97 | stack.pop();
98 | }
99 |
100 | return arr;
101 | }
102 | }
103 |
--------------------------------------------------------------------------------
/src/main/java/com/waylau/java/demo/datastructure/GraphFloydWarshall.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Welcome to https://waylau.com
3 | */
4 | package com.waylau.java.demo.datastructure;
5 |
6 | import java.util.HashMap;
7 | import java.util.List;
8 | import java.util.Map;
9 |
10 | /**
11 | * Floyd–Warshall algorithm is a graph analysis algorithm for finding shortest
12 | * paths in a weighted graph (with positive or negative edge weights). Worst
13 | * case: O(V^3)
14 | *
15 | * @author Way Lau
16 | * @since 2020-11-28
17 | */
18 | public class GraphFloydWarshall {
19 |
20 | private GraphFloydWarshall() {
21 |
22 | }
23 |
24 | public static Map, Map, Integer>> getAllPairsShortestPaths(
25 | Graph graph) {
26 |
27 | if (graph == null) {
28 | throw (new NullPointerException(
29 | "Graph must be non-NULL."));
30 | }
31 |
32 | final List> vertices = graph
33 | .getVertices();
34 | final int[][] sums = new int[vertices
35 | .size()][vertices.size()];
36 |
37 | for (int i = 0; i < sums.length; i++) {
38 | for (int j = 0; j < sums[i].length; j++) {
39 | sums[i][j] = Integer.MAX_VALUE;
40 | }
41 | }
42 |
43 | final List> edges = graph
44 | .getEdges();
45 |
46 | for (Graph.Edge e : edges) {
47 | final int indexOfFrom = vertices
48 | .indexOf(e.getFromVertex());
49 | final int indexOfTo = vertices
50 | .indexOf(e.getToVertex());
51 | sums[indexOfFrom][indexOfTo] = e.getCost();
52 | }
53 |
54 | for (int k = 0; k < vertices.size(); k++) {
55 | for (int i = 0; i < vertices.size(); i++) {
56 | for (int j = 0; j < vertices.size(); j++) {
57 | if (i == j) {
58 | sums[i][j] = 0;
59 | } else {
60 | final int ijCost = sums[i][j];
61 | final int ikCost = sums[i][k];
62 | final int kjCost = sums[k][j];
63 | final int summed = (ikCost != Integer.MAX_VALUE
64 | && kjCost != Integer.MAX_VALUE)
65 | ? (ikCost + kjCost)
66 | : Integer.MAX_VALUE;
67 |
68 | if (ijCost > summed) {
69 | sums[i][j] = summed;
70 | }
71 | }
72 | }
73 | }
74 | }
75 |
76 | final Map, Map, Integer>> allShortestPaths =
77 | new HashMap, Map, Integer>>();
78 |
79 | for (int i = 0; i < sums.length; i++) {
80 | for (int j = 0; j < sums[i].length; j++) {
81 | final Graph.Vertex from = vertices
82 | .get(i);
83 | final Graph.Vertex to = vertices
84 | .get(j);
85 |
86 | Map, Integer> map = allShortestPaths
87 | .get(from);
88 |
89 | if (map == null) {
90 | map = new HashMap, Integer>();
91 | }
92 |
93 | final int cost = sums[i][j];
94 |
95 | if (cost != Integer.MAX_VALUE) {
96 | map.put(to, cost);
97 | }
98 |
99 | allShortestPaths.put(from, map);
100 | }
101 | }
102 |
103 | return allShortestPaths;
104 | }
105 | }
--------------------------------------------------------------------------------
/src/main/java/com/waylau/java/demo/datastructure/GraphKruskal.java:
--------------------------------------------------------------------------------
1 | package com.waylau.java.demo.datastructure;
2 |
3 | import java.util.ArrayList;
4 | import java.util.HashMap;
5 | import java.util.HashSet;
6 | import java.util.List;
7 | import java.util.PriorityQueue;
8 |
9 | /**
10 | * Kruskal's minimum spanning tree. Only works on undirected graphs. It finds a
11 | * subset of the edges that forms a tree that includes every vertex, where the
12 | * total weight of all the edges in the tree is minimized.
13 | *
14 | * @author Way Lau
15 | * @since 2020-10-12
16 | */
17 | public class GraphKruskal {
18 | private GraphKruskal() {
19 | }
20 |
21 | public static Graph.CostPathPair getMinimumSpanningTree(
22 | Graph graph) {
23 | if (graph == null) {
24 | throw (new NullPointerException(
25 | "Graph must be non-NULL."));
26 | }
27 |
28 | // Kruskal的算法只适用于无向图
29 | if (graph.getType() == Graph.TYPE.DIRECTED)
30 | throw (new IllegalArgumentException(
31 | "Undirected graphs only."));
32 | int cost = 0;
33 | final List> path = new ArrayList>();
34 |
35 | // 准备数据以存储给定顶点的树的部分
36 | HashMap, HashSet>> membershipMap =
37 | new HashMap, HashSet>>();
38 |
39 | for (Graph.Vertex v : graph
40 | .getVertices()) {
41 | HashSet> set = new HashSet>();
42 | set.add(v);
43 | membershipMap.put(v, set);
44 | }
45 |
46 | // 把边排成队列来考虑所有边，从权值最低的边开始
47 | PriorityQueue> edgeQueue = new PriorityQueue>(
48 | graph.getEdges());
49 |
50 | while (!edgeQueue.isEmpty()) {
51 | Graph.Edge edge = edgeQueue.poll();
52 | // 如果从顶点和到顶点来自树的不同部分，则将此边添加到结果和并集顶点的部分
53 | if (!isTheSamePart(edge.getFromVertex(),
54 | edge.getToVertex(), membershipMap)) {
55 | union(edge.getFromVertex(),
56 | edge.getToVertex(), membershipMap);
57 | path.add(edge);
58 | cost += edge.getCost();
59 | }
60 | }
61 |
62 | return (new Graph.CostPathPair(cost,
63 | path));
64 | }
65 |
66 | private static boolean isTheSamePart(
67 | Graph.Vertex v1,
68 | Graph.Vertex v2,
69 |
70 | HashMap, HashSet>> membershipMap) {
71 | return membershipMap.get(v1) == membershipMap
72 | .get(v2);
73 | }
74 |
75 | private static void union(Graph.Vertex v1,
76 | Graph.Vertex v2,
77 | HashMap, HashSet>> membershipMap) {
78 | HashSet> firstSet = membershipMap
79 | .get(v1); // 第一个 set最大
80 |
81 | HashSet> secondSet = membershipMap
82 | .get(v2);
83 |
84 | // 我们想把较小的集合包含在较大的集合中，所以第二集合不能大于第一集合
85 | if (secondSet.size() > firstSet.size()) {
86 | HashSet> tempSet = firstSet;
87 | firstSet = secondSet;
88 | secondSet = tempSet;
89 | }
90 |
91 | // 从较小的集合改变每个顶点的成员
92 | for (Graph.Vertex v : secondSet) {
93 | membershipMap.put(v, firstSet);
94 | }
95 |
96 | // 把所有顶点从小集加到大集
97 | firstSet.addAll(secondSet);
98 | }
99 |
100 | }
--------------------------------------------------------------------------------
/src/main/java/com/waylau/java/demo/datastructure/GraphPrim.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Welcome to https://waylau.com
3 | */
4 | package com.waylau.java.demo.datastructure;
5 |
6 | import java.util.ArrayList;
7 | import java.util.HashSet;
8 | import java.util.List;
9 | import java.util.PriorityQueue;
10 | import java.util.Queue;
11 | import java.util.Set;
12 |
13 | /**
14 | * Prim's minimum spanning tree. Only works on undirected graphs. It finds a
15 | * subset of the edges that forms a tree that includes every vertex, where the
16 | * total weight of all the edges in the tree is minimized.
17 | *
18 | * @author Way Lau
19 | * @since 2020-11-22
20 | */
21 | public class GraphPrim {
22 | private GraphPrim() {
23 |
24 | }
25 |
26 | public static Graph.CostPathPair getMinimumSpanningTree(
27 | Graph graph,
28 | Graph.Vertex start) {
29 | if (graph == null) {
30 | throw (new NullPointerException(
31 | "Graph must be non-NULL."));
32 | }
33 |
34 | // Prim算法只适用于无向图
35 | if (graph.getType() == Graph.TYPE.DIRECTED) {
36 | throw (new IllegalArgumentException(
37 | "Undirected graphs only."));
38 | }
39 |
40 | int cost = 0;
41 | final Set> unvisited = new HashSet>();
42 | unvisited.addAll(graph.getVertices());
43 | unvisited.remove(start); // O(1)
44 |
45 | final List> path = new ArrayList>();
46 | final Queue> edgesAvailable = new PriorityQueue>();
47 | Graph.Vertex vertex = start;
48 |
49 | while (!unvisited.isEmpty()) {
50 | // 将所有边添加到未访问的顶点
51 | for (Graph.Edge e : vertex
52 | .getEdges()) {
53 | if (unvisited.contains(e.getToVertex())) {
54 | edgesAvailable.add(e);
55 | }
56 | }
57 |
58 | // 删除最低开销边
59 | final Graph.Edge e = edgesAvailable
60 | .remove();
61 | cost += e.getCost();
62 | path.add(e); // O(1)
63 | vertex = e.getToVertex();
64 | unvisited.remove(vertex); // O(1)
65 | }
66 |
67 | return (new Graph.CostPathPair(cost,
68 | path));
69 | }
70 |
71 | }
--------------------------------------------------------------------------------
/src/main/java/com/waylau/java/demo/datastructure/HashMapDemo.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Welcome to https://waylau.com
3 | */
4 | package com.waylau.java.demo.datastructure;
5 |
6 | import java.util.HashMap;
7 | import java.util.Map;
8 |
9 | /**
10 | * HashMap Demo: Word Count.
11 | *
12 | * @since 1.0.0 2020年6月13日
13 | * @author Way Lau
14 | */
15 | public class HashMapDemo {
16 |
17 | /**
18 | * @param args
19 | */
20 | @SuppressWarnings("preview")
21 | public static void main(String[] args) {
22 | Map wordCountStore = new HashMap<>();
23 |
24 | // JDK13之后
25 | String wordString = """
26 | Give me the strength lightly to bear my joys and sorrows
27 | Give me the strength to make my love fruitful in service
28 | Give me the strength never to disown the poor or bend my knees
29 | before insolent might
30 | Give me the strength to raise my mind high above daily trifles
31 | And give me the strength to surrender my strength to thy will with love
32 | """;
33 |
34 | // 转为字符串数组.
35 | // 换行符和头尾空格要特殊处理
36 | String[] words = wordString.replace("\n", " ")
37 | .strip().split(" ");
38 |
39 | for (String word : words) {
40 |
41 | // key统一为小写
42 | String key = word.toLowerCase();// 转为小写
43 |
44 | Integer value = wordCountStore.get(key);
45 |
46 | // 如果value不存在，则先赋值为0
47 | if (value == null) {
48 | value = 0;
49 | }
50 |
51 | // 累加1
52 | value += 1;
53 |
54 | // 存到Map中
55 | wordCountStore.put(key, value);
56 | }
57 |
58 | // 输出结果到控制台
59 | for (Map.Entry entry : wordCountStore
60 | .entrySet()) {
61 | String key = entry.getKey();
62 | Integer value = entry.getValue();
63 | System.out.println(key + ": " + value);
64 | }
65 |
66 | }
67 |
68 | }
69 |
--------------------------------------------------------------------------------
/src/main/java/com/waylau/java/demo/datastructure/HeapPriorityQueue.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Welcome to https://waylau.com
3 | */
4 | package com.waylau.java.demo.datastructure;
5 |
6 | import java.util.Arrays;
7 | import java.util.Comparator;
8 |
9 | /**
10 | * Heap-based Priority Queue.
11 | *
12 | * @since 1.0.0 2020年9月14日
13 | * @author Way Lau
14 | */
15 | public class HeapPriorityQueue
16 | implements PriorityQueue {
17 | private static final int DEFAULT_INITIAL_CAPACITY = 11;
18 |
19 | private int size;
20 |
21 | private Object[] queue;
22 |
23 | private final Comparator comparator;
24 |
25 | public HeapPriorityQueue() {
26 | this(DEFAULT_INITIAL_CAPACITY, null);
27 | }
28 |
29 | public HeapPriorityQueue(int initialCapacity) {
30 | this(initialCapacity, null);
31 | }
32 |
33 | public HeapPriorityQueue(
34 | Comparator comparator) {
35 | this(DEFAULT_INITIAL_CAPACITY, comparator);
36 | }
37 |
38 | public HeapPriorityQueue(int initialCapacity,
39 | Comparator comparator) {
40 | if (initialCapacity < 1) {
41 | throw new IllegalArgumentException();
42 | }
43 |
44 | this.queue = new Object[initialCapacity];
45 | this.comparator = comparator;
46 | }
47 |
48 | @Override
49 | public boolean add(E e) {
50 | int i = size;
51 |
52 | // 判断容量，自动增长
53 | if (i >= queue.length) {
54 | grow(i + 1);
55 | }
56 |
57 | // 从新排序
58 | siftUp(i, e);
59 | size = i + 1;
60 |
61 | return true;
62 | }
63 |
64 | @Override
65 | public E remove() {
66 | // 删除返回首个元素
67 | // 最后的元素补齐到根节点位置
68 | // 剩余元素向下调整堆
69 |
70 | if (size == 0) {
71 | return null;
72 | }
73 |
74 | final Object[] es = queue;
75 | E result = (E) es[0]; // 首个元素
76 | es[0] = null;
77 |
78 | // 最后的元素先作为根节点
79 | int last = --size;
80 |
81 | // 剩余元素向下调整堆
82 | siftDown(0, (E) es[last]);
83 |
84 | return result;
85 | }
86 |
87 | private void grow(int minCapacity) {
88 | int oldCapacity = queue.length;
89 |
90 | // 如果是小数组则容量加倍；
91 | // 如果是大数组则容量加50%
92 | int newCapacity = oldCapacity
93 | + ((oldCapacity < 64) ? (oldCapacity + 2)
94 | : (oldCapacity >> 1));
95 |
96 | queue = Arrays.copyOf(queue, newCapacity);
97 | }
98 |
99 | private void siftUp(int k, E x) {
100 | if (comparator != null) {
101 | siftUpUsingComparator(k, x, queue, comparator);
102 | } else {
103 | siftUpComparable(k, x, queue);
104 | }
105 | }
106 |
107 | @SuppressWarnings("unchecked")
108 | private static void siftUpComparable(int k, T x,
109 | Object[] es) {
110 | Comparable key = (Comparable) x;
111 |
112 | while (k > 0) {
113 | // 无带符号右移1位，获取父节点索引
114 | int parent = (k - 1) >>> 1;
115 |
116 | // 如果比父节点小，则进行位置交换；否则比较结束。
117 | Object e = es[parent];
118 | if (key.compareTo((T) e) >= 0) {
119 | break;
120 | }
121 |
122 | es[k] = e;
123 | k = parent;
124 | }
125 |
126 | es[k] = key;
127 | }
128 |
129 | @SuppressWarnings("unchecked")
130 | private static void siftUpUsingComparator(int k,
131 | T x, Object[] es, Comparator cmp) {
132 |
133 | while (k > 0) {
134 | // 无带符号右移1位，获取父节点索引
135 | int parent = (k - 1) >>> 1;
136 |
137 | // 如果比父节点小，则进行位置交换；否则比较结束。
138 | Object e = es[parent];
139 |
140 | if (cmp.compare(x, (T) e) >= 0) {
141 | break;
142 | }
143 |
144 | es[k] = e;
145 | k = parent;
146 | }
147 |
148 | es[k] = x;
149 | }
150 |
151 | private void siftDown(int k, E x) {
152 | if (comparator != null) {
153 | siftDownUsingComparator(k, x, queue, size,
154 | comparator);
155 | } else {
156 | siftDownComparable(k, x, queue, size);
157 | }
158 | }
159 |
160 | @SuppressWarnings("unchecked")
161 | private static void siftDownComparable(int k, T x,
162 | Object[] es, int n) {
163 | Comparable key = (Comparable) x;
164 |
165 | int half = n >>> 1; // 取n的一半
166 |
167 | while (k < half) {
168 | // 带符号左移1位
169 | int child = (k << 1) + 1; // 假设左子最小
170 | Object c = es[child];
171 | int right = child + 1; // 取右子结点
172 |
173 | if (right < n &&
174 | ((Comparable) c)
175 | .compareTo((T) es[right]) > 0) {
176 | c = es[child = right];
177 | }
178 |
179 |
180 | if (key.compareTo((T) c) <= 0) {
181 | break;
182 | }
183 |
184 | es[k] = c;
185 | k = child;
186 | }
187 |
188 | es[k] = key;
189 |
190 | }
191 |
192 | @SuppressWarnings("unchecked")
193 | private static void siftDownUsingComparator(
194 |
195 | int k, T x, Object[] es, int n,
196 | Comparator cmp) {
197 |
198 | int half = n >>> 1; // 取n的一半
199 |
200 | while (k < half) {
201 | // 带符号左移1位
202 | int child = (k << 1) + 1;// 假设左子结点最小
203 | Object c = es[child];
204 | int right = child + 1; // 取右子结点
205 |
206 | if (right < n && cmp.compare((T) c,
207 | (T) es[right]) > 0) {
208 | c = es[child = right];
209 | }
210 |
211 | if (cmp.compare(x, (T) c) <= 0) {
212 | break;
213 | }
214 |
215 | es[k] = c;
216 | k = child;
217 | }
218 |
219 | es[k] = x;
220 | }
221 |
222 | }
223 |
--------------------------------------------------------------------------------
/src/main/java/com/waylau/java/demo/datastructure/Hero.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Welcome to https://waylau.com
3 | */
4 | package com.waylau.java.demo.datastructure;
5 |
6 | /**
7 | * Hero.
8 | *
9 | * @since 1.0.0 2020年9月14日
10 | * @author Way Lau
11 | */
12 | public class Hero {
13 | private String name;
14 |
15 | private Integer power; // 战力
16 |
17 | public Hero(String name, Integer power) {
18 | this.name = name;
19 | this.power = power;
20 | }
21 |
22 | public String getName() {
23 | return name;
24 | }
25 |
26 | public void setName(String name) {
27 | this.name = name;
28 | }
29 |
30 | public Integer getPower() {
31 | return power;
32 | }
33 |
34 | public void setPower(Integer power) {
35 | this.power = power;
36 | }
37 |
38 | @Override
39 | public String toString() {
40 | return "Hero [name=" + name + ", power=" + power
41 | + "]";
42 |
43 | }
44 |
45 | @Override
46 | public int hashCode() {
47 | final int prime = 31;
48 | int result = 1;
49 | result = prime * result
50 | + ((name == null) ? 0 : name.hashCode());
51 | result = prime * result
52 | + ((power == null) ? 0 : power.hashCode());
53 | return result;
54 | }
55 |
56 | @Override
57 | public boolean equals(Object obj) {
58 | if (this == obj)
59 | return true;
60 | if (obj == null)
61 | return false;
62 | if (getClass() != obj.getClass())
63 | return false;
64 | Hero other = (Hero) obj;
65 | if (name == null) {
66 | if (other.name != null)
67 | return false;
68 | } else if (!name.equals(other.name))
69 | return false;
70 | if (power == null) {
71 | if (other.power != null)
72 | return false;
73 | } else if (!power.equals(other.power))
74 | return false;
75 | return true;
76 | }
77 | }
78 |
--------------------------------------------------------------------------------
/src/main/java/com/waylau/java/demo/datastructure/HuffmanTree.java:
--------------------------------------------------------------------------------
1 | package com.waylau.java.demo.datastructure;
2 |
3 | import java.util.ArrayDeque;
4 | import java.util.ArrayList;
5 | import java.util.Collections;
6 | import java.util.List;
7 | import java.util.Queue;
8 |
9 | /**
10 | * Huffman Tree.
11 | *
12 | * @since 1.0.0 2020年9月8日
13 | * @author Way Lau
14 | */
15 | public class HuffmanTree {
16 | /**
17 | * 创建Huffman树
18 | * @param
19 | * @param HuffmanTreeNodes
20 | * @return 根节点
21 | */
22 | public static HuffmanTreeNode createTree(
23 | List> HuffmanTreeNodes) {
24 | while (HuffmanTreeNodes.size() > 1) {
25 | Collections.sort(HuffmanTreeNodes);
26 | HuffmanTreeNode left = HuffmanTreeNodes
27 | .get(HuffmanTreeNodes.size() - 1);
28 | HuffmanTreeNode right = HuffmanTreeNodes
29 | .get(HuffmanTreeNodes.size() - 2);
30 | HuffmanTreeNode parent = new HuffmanTreeNode(
31 | null,
32 | left.getWeight() + right.getWeight());
33 |
34 | parent.setLeft(left);
35 | parent.setRight(right);
36 |
37 | HuffmanTreeNodes.remove(left);
38 | HuffmanTreeNodes.remove(right);
39 | HuffmanTreeNodes.add(parent);
40 | }
41 |
42 | return HuffmanTreeNodes.get(0);
43 | }
44 |
45 | /**
46 | * 广度优先遍历
47 | *
48 | * @param
49 | * @param root
50 | * @return
51 | */
52 | public static List> breadth(
53 | HuffmanTreeNode root) {
54 | List> list = new ArrayList>();
55 | Queue> queue = new ArrayDeque>();
56 |
57 | if (root != null) {
58 | queue.offer(root);
59 | }
60 |
61 | while (!queue.isEmpty()) {
62 | list.add(queue.peek());
63 | HuffmanTreeNode HuffmanTreeNode = queue
64 | .poll();
65 |
66 | if (HuffmanTreeNode.getLeft() != null) {
67 | queue.offer(HuffmanTreeNode.getLeft());
68 | }
69 |
70 | if (HuffmanTreeNode.getRight() != null) {
71 | queue.offer(HuffmanTreeNode.getRight());
72 | }
73 | }
74 |
75 | return list;
76 | }
77 |
78 | /**
79 | * 对Huffman树中叶子节点进行编码
80 | *
81 | * @param root
82 | */
83 | public static void encode(HuffmanTreeNode root) {
84 | encode(root, "0", "1", "");
85 | }
86 |
87 | public static void encode(HuffmanTreeNode node,
88 | String a, String b, String c) {
89 | if (node.getLeft() != null) {
90 | String temp = c + "0";
91 | encode(node.getLeft(), "0", "1", temp);
92 | }
93 |
94 | if (node.getRight() != null) {
95 | String temp = c + "1";
96 | encode(node.getRight(), "0", "1", temp);
97 | }
98 |
99 | if (node.getLeft() == null
100 | && node.getRight() == null) {
101 | node.setCode(c);
102 | }
103 | }
104 | }
--------------------------------------------------------------------------------
/src/main/java/com/waylau/java/demo/datastructure/HuffmanTreeNode.java:
--------------------------------------------------------------------------------
1 | package com.waylau.java.demo.datastructure;
2 |
3 | /**
4 | * Huffman Tree Node.
5 | *
6 | * @since 1.0.0 2020年9月8日
7 | * @author Way Lau
8 | */
9 | public class HuffmanTreeNode
10 | implements Comparable> {
11 |
12 | private T data;
13 |
14 | private HuffmanTreeNode left; // 左结点
15 |
16 | private HuffmanTreeNode right; // 右结点
17 |
18 | private Double weight; // 权值
19 |
20 | private String code; // 编码
21 |
22 | public HuffmanTreeNode(T data, double weight) {
23 | this.data = data;
24 | this.weight = weight;
25 | }
26 |
27 | public T getData() {
28 | return data;
29 | }
30 |
31 | public void setData(T data) {
32 | this.data = data;
33 | }
34 |
35 | public HuffmanTreeNode getLeft() {
36 | return left;
37 | }
38 |
39 | public void setLeft(HuffmanTreeNode left) {
40 | this.left = left;
41 | }
42 |
43 | public HuffmanTreeNode getRight() {
44 | return right;
45 | }
46 |
47 | public void setRight(HuffmanTreeNode right) {
48 | this.right = right;
49 | }
50 |
51 | public Double getWeight() {
52 | return weight;
53 | }
54 |
55 | public void setWeight(Double weight) {
56 | this.weight = weight;
57 | }
58 |
59 | public String getCode() {
60 | return code;
61 | }
62 |
63 | public void setCode(String code) {
64 | this.code = code;
65 | }
66 |
67 | @Override
68 | public String toString() {
69 | return "HuffmanTreeNode [data=" + data + ", weight="
70 | + weight
71 | + ", code=" + code + "]";
72 |
73 | }
74 |
75 | @Override
76 | public int compareTo(HuffmanTreeNode o) {
77 | if (o.getWeight() > this.getWeight()) {
78 | return 1;
79 | }
80 |
81 | if (o.getWeight() < this.getWeight()) {
82 | return -1;
83 | }
84 |
85 | return 0;
86 | }
87 |
88 | }
89 |
--------------------------------------------------------------------------------
/src/main/java/com/waylau/java/demo/datastructure/LinkedBinarySearchTree.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Welcome to https://waylau.com
3 | */
4 | package com.waylau.java.demo.datastructure;
5 |
6 | import java.util.ArrayList;
7 | import java.util.List;
8 |
9 | /**
10 | * @since 1.0.0 2020年9月23日
11 | * @author Way Lau
12 | */
13 | public class LinkedBinarySearchTree>
14 | implements BinarySearchTree {
15 |
16 | private BinaryTreeNode root;
17 |
18 | @Override
19 | public boolean isEmpty() {
20 | return root == null;
21 | }
22 |
23 | @Override
24 | public void insert(E e) {
25 | root = insert(e, root);
26 | }
27 |
28 | @Override
29 | public void remove(E e) {
30 | root = remove(e, root);
31 | }
32 |
33 | @Override
34 | public E findMin() {
35 | return findMin(root).getData();
36 | }
37 |
38 | @Override
39 | public E findMax() {
40 | return findMax(root).getData();
41 | }
42 |
43 | @Override
44 | public List preOrder() {
45 | List result = new ArrayList();
46 | if (isEmpty()) {
47 | return result;
48 | } else {
49 | preOrder(root, result);
50 | }
51 |
52 | return result;
53 | }
54 |
55 | @Override
56 | public List infixOrder() {
57 | List result = new ArrayList();
58 | if (isEmpty()) {
59 | return result;
60 | } else {
61 | infixOrder(root, result);
62 | }
63 |
64 | return result;
65 | }
66 |
67 | @Override
68 | public List postOrder() {
69 | List result = new ArrayList();
70 | if (isEmpty()) {
71 | return result;
72 | } else {
73 | postOrder(root, result);
74 | }
75 |
76 | return result;
77 | }
78 |
79 | @Override
80 | public void print() {
81 | if (isEmpty()) {
82 | System.out.println("tree is empty");
83 | return;
84 | } else {
85 | print(root);
86 | }
87 | }
88 |
89 | private BinaryTreeNode insert(E e,
90 | BinaryTreeNode root) {
91 | // 如果root为空，则当前e节点为根节点
92 | if (null == root) {
93 | return new BinaryTreeNode(e);
94 | }
95 |
96 | // e与root进行比较
97 | int compareResult = e.compareTo(root.getData());
98 |
99 | // 小于当前根节点 将e插入根节点的左边
100 | if (compareResult < 0) {
101 | root.setLeft(insert(e, root.getLeft()));
102 | } else if (compareResult > 0) {
103 | // 大于当前根节点 将e插入根节点的右边
104 | root.setRight(insert(e, root.getRight()));
105 | }
106 |
107 | return root;
108 | }
109 |
110 | private BinaryTreeNode remove(E e,
111 | BinaryTreeNode root) {
112 | if (null == root) {
113 | return root;
114 | }
115 |
116 | // e与root进行比较
117 | int compareResult = e.compareTo(root.getData());
118 |
119 | // 小于当前根节点
120 | if (compareResult < 0) {
121 | root.setLeft(remove(e, root.getLeft()));
122 | } else if (compareResult > 0) {
123 | // 大于当前根节点
124 | root.setRight(remove(e, root.getRight()));
125 | } else if (root.getLeft() != null
126 | && root.getRight() != null) {
127 | // 找到右边最小的节点
128 | root.setData(
129 | findMin(root.getRight()).getData());
130 |
131 | // 当前节点的右边等于原节点右边删除已经被选为的替代节点
132 | root.setRight(remove(root.getData(),
133 | root.getRight()));
134 | } else {
135 | root = (root.getLeft() != null) ? root.getLeft()
136 | : root.getRight();
137 | }
138 |
139 | return root;
140 | }
141 |
142 | private BinaryTreeNode findMin(
143 | BinaryTreeNode root) {
144 | if (null == root) {
145 | return root;
146 | } else if (root.getLeft() == null) {
147 | return root;
148 | }
149 |
150 | // 递归查找
151 | return findMin(root.getLeft());
152 | }
153 |
154 | private BinaryTreeNode findMax(
155 | BinaryTreeNode