一、学习内容
- 二分查找法非递归
- 分治算法
- 动态规划算法
- KMP算法
- 贪心算法
- 普里姆算法
- 克鲁斯卡尔算法
- 迪杰斯特拉算法
- 弗洛伊德算法
- 马踏棋算法
二、算法代码
1 package Algorithm;
2
3 /**
4 * 二分查找非递归实现 默认有序
5 *
6 * @author LEEWAY
7 *
8 */
9 public class BSAlgorithm {
10 public static int binarySearchN(int[] srcArray, int des) {
11 // 第一个位置.
12 int low = 0;
13 // 最高位置.数组长度-1,因为下标是从0开始的.
14 int high = srcArray.length - 1;
15 // 当low"指针"和high不重复的时候.
16 while (low <= high) {
17 // 中间位置计算,low+ 最高位置减去最低位置,右移一位,相当于除2.也可以用(high+low)/2
18 int middle = low + ((high - low) >> 1);
19 // 与最中间的数字进行判断,是否相等,相等的话就返回对应的数组下标.
20 if (des == srcArray[middle]) {
21 return middle;
22 // 如果小于的话则移动最高层的"指针"
23 } else if (des < srcArray[middle]) {
24 high = middle - 1;
25 // 移动最低的"指针"
26 } else {
27 low = middle + 1;
28 }
29 }
30 return -1;
31 }
32
33 public static void main(String[] args) {
34 int[] arr = { 1, 3, 5, 7, 9, 12, 14, 18 };
35 int binarySearchR = binarySearchN(arr, 14);
36 System.out.println(binarySearchR);
37 }
38 }
执行结果
package Algorithm;
/**
* 分治法解決汉诺塔问题
*
* @author LEEWAY
*
*/
public class HanoiTowerProblem {
/**
* 定义移动次数
*/
private static int count;
/**
* 设置移动次数的起始值
*
* @param count
*/
public static void setCount() {
HanoiTowerProblem.count = 1;
}
/**
* 获取移动次数
*
* @return
*/
public static int getCount() {
return count - 1;
}
public static void main(String[] args) {
hanoiTower(4, 'a', 'b', 'c');
System.out.println("共" + count + "步");
}
public static void hanoiTower(int num, char a, char b, char c) {
count++;
if (num == 1) {
System.out.println("第1个盘从" + a + "->" + c);
} else {
// num>=2时，总时可以看成两个盘1，最下边的一个盘2，上面的所有盘
// 1、先把最上面的所有盘A->B，移动过程会使用到C
hanoiTower(num - 1, a, c, b);
// 2、把最下边的盘A->C
System.out.println("第" + num + "个盘从" + a + "->" + c);
// 3、把B塔的所有盘从B->C，移动过程使用到A塔
hanoiTower(num - 1, b, a, c);
}
}
}
执行结果
package Algorithm;
/**
* 动态规划算法
* 背包问题利用了动态规划
* 通过公式运用到上次计算的结果不断递归
* @author LEEWAY
*
*/
public class KnapsackProblem {
public static void main(String[] args) {
int[] w = { 1, 4, 3 };// 物品的重量
int[] val = { 1500, 3000, 2000 };// 物品的价值
int m = 4;// 背包的容量
int n = val.length;// 物品的个数
// 记录放入商品的情况
int[][] path = new int[n + 1][m + 1];
// 创建二维数组，表
int[][] v = new int[n + 1][m + 1];
// 初试化第一行和第一列
for (int i = 0; i < v.length; i++) {
v[i][0] = 0;
}
for (int i = 0; i < v[0].length; i++) {
v[0][i] = 0;
}
// 动态规划处理
for (int i = 1; i < v.length; i++) {
for (int j = 1; j < v[0].length; j++) {
// 公式
if (w[i - 1] > j) {// 公式中w[i]修改成w[i-1]
v[i][j] = v[i - 1][j];
} else {
// v[i][j] = Math.max(v[i - 1][j], val[i - 1]
// + v[i - 1][j - w[i - 1]]);
// 记录放入商品的情况
if (v[i - 1][j] < val[i - 1] + v[i - 1][j - w[i - 1]]) {
v[i][j] = val[i - 1] + v[i - 1][j - w[i - 1]];
path[i][j] = 1;
} else {
v[i][j] = v[i - 1][j];
}
}
}
}
// 输出
for (int i = 0; i < v.length; i++) {
for (int j = 0; j < v[i].length; j++) {
System.out.print(v[i][j] + " ");
}
System.out.println();
}
// 输出放入商品的情况
int i = path.length - 1;
int j = path[0].length - 1;
while (i > 0 && j > 0) {
if (path[i][j] == 1) {
System.out.printf("第%d个商品放入到背包\n", i);
j -= w[i - 1];
}
i--;
}
}
}
执行结果
package Algorithm;
/**
* KPM算法
* 找出部分匹配值 充分利用之前比较信息
* 每次比较失败不是向后移动一个位置
* 而是移动上个位置距离其起点长度减去该位置部分匹配值个位置
* @author LEEWAY
*
*/
public class KMPAlgorithm {
public static void main(String[] args) {
String str1 = "BBC ABCDAB ABCDABCDABDE";
String str2 = "ABCDABD";
// System.out.println("next=" + Arrays.toString(kmpNext(str2)));
System.out.println("index=" + kmpSearch(str1, str2));
}
public static int[] kmpNext(String dest) {
// 创建数组next保留部分匹配值
int[] next = new int[dest.length()];
// 初试化当字符串长度为1时部分匹配值为0
next[0] = 0;
// j作用有二其一作为被比较的指针其二作为next数组值 i作用作为比较的指针
for (int i = 1, j = 0; i < dest.length(); i++) {
// 当dest.charAt(i) != dest.charAt(j)需要从next[j-1]获取新的j
// 直到有dest.charAt(i) == dest.charAt(j)成立才退出
// KPM算法核心
while (j > 0 && dest.charAt(i) != dest.charAt(j)) {
j = next[j - 1];
}
// 当dest.charAt(i) == dest.charAt(j)满足时部分匹配值就是+1
if (dest.charAt(i) == dest.charAt(j)) {
j++;
}
next[i] = j;
}
return next;
}
public static int kmpSearch(String str1, String str2) {
int[] next = kmpNext(str2);
for (int i = 0, j = 0; i < str1.length(); i++) {
// KPM算法核心
while (j > 0 && str1.charAt(i) != str2.charAt(j)) {
j = next[j - 1];
}
if (str1.charAt(i) == str2.charAt(j)) {
j++;
}
// 匹配成功条件
if (j == str2.length()) {
//j不停加i也不停加
return i - j + 1;
}
}
// 匹配不成功返回-1
return -1;
}
}
执行结果
package Algorithm;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
/**
* 贪心算法
* 局部最优 全局不一定最优 但无限接近最优
* @author LEEWAY
*
*/
public class GreedyAlgorithm {
public static void main(String[] args) {
HashMap<String, HashSet<String>> broadcasts = new HashMap<String, HashSet<String>>();
// 将各个电台放入到broadcasts
HashSet<String> hashSet1 = new HashSet<String>();
HashSet<String> hashSet2 = new HashSet<String>();
HashSet<String> hashSet3 = new HashSet<String>();
HashSet<String> hashSet4 = new HashSet<String>();
HashSet<String> hashSet5 = new HashSet<String>();
hashSet1.add("北京");
hashSet1.add("上海");
hashSet1.add("天津");
hashSet2.add("广州");
hashSet2.add("北京");
hashSet2.add("深圳");
hashSet3.add("成都");
hashSet3.add("上海");
hashSet3.add("杭州");
hashSet4.add("上海");
hashSet4.add("天津");
hashSet5.add("杭州");
hashSet5.add("大连");
broadcasts.put("K1", hashSet1);
broadcasts.put("K2", hashSet2);
broadcasts.put("K3", hashSet3);
broadcasts.put("K4", hashSet4);
broadcasts.put("K5", hashSet5);
// 存放所有地区
HashSet<String> allAreas = new HashSet<String>();
allAreas.add("北京");
allAreas.add("上海");
allAreas.add("天津");
allAreas.add("广州");
allAreas.add("深圳");
allAreas.add("成都");
allAreas.add("杭州");
allAreas.add("大连");
// 存放选择的电台
ArrayList<String> selects = new ArrayList<String>();
// 存放遍历过程中电台覆盖的地区和当前还没有覆盖的地区的交集
HashSet<String> tempSet = new HashSet<String>();
String maxKey = null;
// 保存一次遍历过程中能够覆盖最大未覆盖的地区对应的电台
while (allAreas.size() != 0) {
maxKey = null;
for (String key : broadcasts.keySet()) {
tempSet.clear();
HashSet<String> areas = broadcasts.get(key);
tempSet.addAll(areas);
tempSet.retainAll(allAreas);
if (tempSet.size() > 0
&& (maxKey == null || tempSet.size() > broadcasts.get(
maxKey).size())) {// 体现出贪心算法特点
maxKey = key;
}
}
if (maxKey != null) {
selects.add(maxKey);
// 将maxKey指向的广播电台覆盖的地区 从allAreas去掉
allAreas.removeAll(broadcasts.get(maxKey));
}
}
System.out.println("得到的选择结果是" + selects);
}
}
执行结果
package Algorithm;
import java.util.Arrays;
/**
* 普里姆算法
* 最小生成树 将已访问过的点标记
* 每次比较 已访问过的结点和还没有访问的结点权值最小值
*
* @author LEEWAY
*
*/
public class PrimAlgorithm {
public static void main(String[] args) {
char[] data = new char[] { 'A', 'B', 'C', 'D', 'E', 'F', 'G' };
int verxs = data.length;
int[][] weight = new int[][] { { 10000, 5, 7, 10000, 10000, 10000, 2 },
{ 5, 10000, 10000, 9, 10000, 10000, 3 },
{ 7, 10000, 10000, 10000, 8, 10000, 10000 },
{ 10000, 9, 10000, 10000, 10000, 4, 10000 },
{ 10000, 10000, 8, 10000, 10000, 5, 4 },
{ 10000, 10000, 10000, 4, 5, 10000, 6 },
{ 2, 3, 10000, 10000, 4, 6, 10000 }, };// 10000表示不连通
MGraph mGraph = new MGraph(verxs);
MinTree minTree = new MinTree();
minTree.createGraph(mGraph, verxs, data, weight);
minTree.showGraph(mGraph);
minTree.prim(mGraph, 1);
}
}
// 创建最小生成树->村庄的图
class MinTree {
/**
* @param graph
* 图对象
* @param verxs
* 图顶点个数
* @param data
* 图顶点的值
* @param weight
* 图邻接矩阵
* @author LEEWAY
*
*/
public void createGraph(MGraph graph, int verxs, char data[], int[][] weight) {
int i, j;
for (i = 0; i < verxs; i++) {
graph.data[i] = data[i];
for (j = 0; j < verxs; j++) {
graph.weight[i][j] = weight[i][j];
}
}
}
// 显示图的邻接矩阵
public void showGraph(MGraph graph) {
for (int[] link : graph.weight) {
System.out.println(Arrays.toString(link));
}
}
// Prim算法核心代码
public void prim(MGraph graph, int verxs) {
int visited[] = new int[graph.verxs];
visited[verxs] = 1;
int h1 = -1;
int h2 = -1;
int minWeight = 10000;
for (int k = 1; k < graph.verxs; k++) {
// 确定每一次生成的子图和哪个结点的距离最近
for (int i = 0; i < graph.verxs; i++) {// i表示被访问过的结点
for (int j = 0; j < graph.verxs; j++) {// j表示还没有访问的结点
if (visited[i] == 1 && visited[j] == 0
&& graph.weight[i][j] < minWeight) {
// 替换minWeight（寻找被访问过的结点和还没有访问的结点权值最小值）
minWeight = graph.weight[i][j];
h1 = i;
h2 = j;
}
}
}
// 找到一条边是最小
System.out.println("边<" + graph.data[h1] + "," + graph.data[h2]
+ ">权值：" + minWeight);
// 将当前这个节点标记为已经访问过的结点
visited[h2] = 1;
minWeight = 10000;
}
}
}
class MGraph {
int verxs;// 存放图节点个数
char[] data;// 存放结点数据
int[][] weight;// 邻接矩阵存放边
public MGraph(int verxs) {
this.verxs = verxs;
data = new char[verxs];
weight = new int[verxs][verxs];
}
}
执行结果
package Algorithm;
import java.util.Arrays;
/**
* 克鲁斯卡尔算法
* 先按照权值 排序 再依次找权值最小边
* 当出现回路（两个顶点在已有最小生成树中的终点相同）
* 放弃该最小边，直到所有顶点都判断一遍
* @author LEEWAY
*
*/
public class KruskalAlgorithm {
private int edgeNum;// 边的个数
private char[] vertexs;// 顶点数组
private int[][] matrix;// 邻接矩阵
private static final int INF = Integer.MAX_VALUE;
public static void main(String[] args) {
char[] vertexs = { 'A', 'B', 'C', 'D', 'E', 'F', 'G' };
// 克鲁斯卡尔算法的邻接矩阵
int matrix[][] = {
/* A *//* B *//* C *//* D *//* E *//* F *//* G */
/* A */{ 0, 12, INF, INF, INF, 16, 14 },
/* B */{ 12, 0, 10, INF, INF, 7, INF },
/* C */{ INF, 10, 0, 3, 5, 6, INF },
/* D */{ INF, INF, 3, 0, 4, INF, INF },
/* E */{ INF, INF, 5, 4, 0, 2, 8 },
/* F */{ 16, 7, 6, INF, 2, 0, 9 },
/* G */{ 14, INF, INF, INF, 8, 9, 0 } };
KruskalAlgorithm kruskalCase = new KruskalAlgorithm(vertexs, matrix);
EData[] edges = kruskalCase.getEdges();
kruskalCase.sortEdges(edges);
kruskalCase.print();
kruskalCase.kruskal();
}
public KruskalAlgorithm(char[] vertexs, int[][] matrix) {
// 初始化顶点数和边的个数
int vlen = vertexs.length;
this.vertexs = new char[vlen];
for (int i = 0; i < matrix.length; i++) {
this.vertexs[i] = vertexs[i];
}
// 初始化边,使用的是复制拷贝的方式
this.matrix = new int[vlen][vlen];
for (int i = 0; i < vlen; i++) {
for (int j = 0; j < vlen; j++) {
this.matrix[i][j] = matrix[i][j];
}
}
// 统计边数
for (int i = 0; i < vlen; i++) {
for (int j = i + 1; j < vlen; j++) {
if (this.matrix[i][j] != INF) {
edgeNum++;
}
}
}
}
// Kruskal核心算法
public void kruskal() {
int index = 0;
// 保存“已有最小生成树”中的每个顶点再最小生成树中的终点
int[] ends = new int[edgeNum];
// 保存最后的最小生成树
EData[] rets = new EData[edgeNum];
// 获取图中边集合
EData[] edges = getEdges();
sortEdges(edges);
System.out.println("图的边的集合=" + Arrays.toString(edges) + " 共"
+ edges.length);// 12
// 按照边的权值大小排序
sortEdges(edges);
// 遍历 将边添加到最小生成树中时，判断加入边是否形成回路，如果没有就加入rets
for (int i = 0; i < edgeNum; i++) {
// 获取第i条边的第1个顶点(起点)
int p1 = getPosition(edges[i].start);// p1=4
// 获取第i条边的第2个顶点
int p2 = getPosition(edges[i].end);// p2=5
// 获取p1这个顶点在已有最小生成树中的终点
int m = getEnd(ends, p1);// m=4
// 获取p2这个顶点在已有最小生成树中的终点
int n = getEnd(ends, p2);// n=5
if (m != n) {
// 没有构成回路
ends[m] = n;// 设置m在“已有最小生成树”
rets[index++] = edges[i];
}
}
// 统计
System.out.print("最小生成树为=");
for (int i = 0; i < index; i++) {
System.out.print(rets[i] + " ");
}
}
public void print() {
System.out.println("邻接矩阵:\n");
for (int i = 0; i < vertexs.length; i++) {
for (int j = 0; j < vertexs.length; j++) {
System.out.printf("%12d", matrix[i][j]);
}
System.out.println();
}
}
/**
* 功能：对边进行排序处理，冒泡排序
*
* @param edges
* 边的集合
*/
private void sortEdges(EData[] edges) {
for (int i = 0; i < edges.length - 1; i++) {
for (int j = 0; j < edges.length - 1 - i; j++) {
if (edges[j].weight > edges[j + 1].weight) {
EData tmp = edges[j];
edges[j] = edges[j + 1];
edges[j + 1] = tmp;
}
}
}
}
/**
*
* @param ch
* 顶点值，比如‘A’，‘B’
* @return 返回ch顶点对应的下标，如果找不到 ，返回-1
*/
private int getPosition(char ch) {
for (int i = 0; i < vertexs.length; i++) {
if (vertexs[i] == ch) {
return i;
}
}
return -1;
}
/**
* 功能：获取图中边，放到EData[]数组中
*
*/
private EData[] getEdges() {
int index = 0;
EData[] edges = new EData[edgeNum];
for (int i = 0; i < vertexs.length; i++) {
for (int j = i + 1; j < vertexs.length; j++) {
if (matrix[i][j] != INF) {
edges[index++] = new EData(vertexs[i], vertexs[j],
matrix[i][j]);
}
}
}
return edges;
}
/**
* 获取传入下标i顶点的终点下标
*
* @param ends
* @param i
* @return
*/
private int getEnd(int[] ends, int i) {
while (ends[i] != 0) {
i = ends[i];
}
return i;
}
}
// 表示一条边
class EData {
char start;
char end;
int weight;
public EData(char start, char end, int weight) {
super();
this.start = start;
this.end = end;
this.weight = weight;
}
@Override
public String toString() {
return "EData [<" + start + "," + end + ">=" + weight + "]";
}
}
执行结果
package Algorithm;
/**
* 迪杰斯特拉算法
* 从某一点出发到其他点的最短距离
* @author LEEWAY
*
*/
public class DijkstraAlgorithm {
public static final int M = 10000; //代表正无穷
public static void main(String[] args) {
//二维数组每一行代表到A、B、C、D、E各点到其余点的距离
int[][] weight1 = {
{0,4,M,2,M},
{4,0,4,1,M},
{M,4,0,1,3},
{2,1,1,0,7},
{M,M,3,7,0}
};
int start = 0;
int[] shortPath = dijkstra(weight1, start);
for (int i = 0; i < shortPath.length; i++)
System.out.println("从" + start + "出发到" + i + "的最短距离为" + shortPath[i]);
}
/**
* 接收一个有向图的权重矩阵，和一个起点编号start
* 返回一个int[] 数组，表示从start到它的最短路径长度
* @param weight
* @param start
* @return
*/
public static int[] dijkstra(int[][] weight, int start) {
int n = weight.length; // 顶点个数
int[] shortPath = new int[n]; // 保存start到其他各点的最短路径
String[] path = new String[n];// 保存start到其他各点最短路径的字符串表示
for (int i = 0; i < n; i++)
path[i] = new String(start + "-->" + i);
int[] visited = new int[n]; // 标记当前该顶点的最短路径是否已经求出,1表示已求出
// 初始化，第一个顶点已经求出
shortPath[start] = 0;
visited[start] = 1;
for (int count = 1; count < n; count++) { // 要加入n-1个顶点
int k = -1; // 选出一个距离初始顶点start最近的未标记顶点
int dmin = Integer.MAX_VALUE;
for (int i = 0; i < n; i++) {
if (visited[i] == 0 && weight[start][i] < dmin) {
dmin = weight[start][i];
k = i;
}
}
// 将新选出的顶点标记为已求出最短路径，且到start的最短路径就是dmin
shortPath[k] = dmin;
visited[k] = 1;
// 以k为中间点，修正从start到未访问各点的距离
for (int i = 0; i < n; i++) {
//如果 '起始点到当前点距离' + '当前点到某点距离' < '起始点到某点距离', 则更新
if (visited[i] == 0 && weight[start][k] + weight[k][i] < weight[start][i]) {
weight[start][i] = weight[start][k] + weight[k][i];
path[i] = path[k] + "-->" + i;
}
}
}
for (int i = 0; i < n; i++) {
System.out.println("从" + start + "出发到" + i + "的最短路径为：" + path[i]);
}
System.out.println("=====================================");
return shortPath;
}
}
执行结果
package Algorithm;
import java.util.Arrays;
/**
* 弗洛伊德算法 从各个点出发到其他点的最短距离
* pre数组和dis数组分别存路径长度Len和中间结点K
* @author LEEWAY
*
*/
public class FloydAlgorithm {
public static void main(String[] args) {
char[] vertex = { 'A', 'B', 'C', 'D', 'E', 'F', 'G' };
int[][] matrix = new int[vertex.length][vertex.length];
final int N = 65535;
matrix[0] = new int[] { 0, 5, 7, N, N, N, 2 };
matrix[1] = new int[] { 5, 0, N, 9, N, N, 3 };
matrix[2] = new int[] { 7, N, 0, N, 8, N, N };
matrix[3] = new int[] { N, N, 8, N, 0, 5, 4 };
matrix[4] = new int[] { N, N, 8, N, 0, 5, 4 };
matrix[5] = new int[] { N, N, N, 4, 5, 0, 6 };
matrix[6] = new int[] { 2, 3, N, N, 4, 6, 0 };
Graph graph = new Graph(vertex.length, matrix, vertex);
graph.floyd();
graph.show();
}
}
class Graph {
private int[][] dis;
private int[][] pre;
// 构造器
/**
*
* @param length
* 大小
* @param matrix
* 邻接矩阵
* @param vertex
* 顶点数组
*/
public Graph(int length, int[][] matrix, char[] vertex) {
this.dis = matrix;
this.pre = new int[length][length];
// 对pre数组初始化，存放前驱顶点的下标
for (int i = 0; i < vertex.length; i++) {
Arrays.fill(pre[i], i);
}
}
// 显示pre数组和dis数组
public void show() {
char[] vertex = { 'A', 'B', 'C', 'D', 'E', 'F', 'G' };
for (int k = 0; k < dis.length; k++) {
// 先将pre数组输出的一行
for (int i = 0; i < dis.length; i++) {
System.out.print(vertex[pre[k][i]] + " ");
}
System.out.println();
// 输出dis数组的一行数据
for (int i = 0; i < dis.length; i++) {
System.out.print("(" + vertex[k] + "到" + vertex[i] + "的最短路径是"
+ dis[k][i] + ")");
}
System.out.println();
}
}
// Floyd算法
public void floyd() {
int len = 0;
// 对中间顶点遍历，k就是中间顶点的下标[A,B,C,D,E,F,G]
for (int k = 0; k < dis.length; k++) {
for (int i = 0; i < dis.length; i++) {
for (int j = 0; j < dis.length; j++) {
len = dis[i][k] + dis[k][j];
if (len < dis[i][j]) {
dis[i][j] = len;
pre[i][j] = pre[k][j];
}
}
}
}
}
}
执行结果
package Algorithm;
import java.awt.Point;
import java.util.ArrayList;
public class HorseChessboard {
// 棋盘行数 列数
private static int X;
private static int Y;
private static boolean visited[];
private static boolean finished;
public static void main(String[] args) {
System.out.println("骑士周游算法，开始运行~~");
X = 6;
Y = 6;
int row = 2;
int col = 1;
int[][] chessboard = new int[X][Y];
visited = new boolean[X * Y];
long start = System.currentTimeMillis();
traversalChessboard(chessboard, row - 1, col - 1, 1);
long end = System.currentTimeMillis();
System.out.println("共耗时：" + (end - start) + "毫秒");
// 输出棋盘最后情况
for (int[] rows : chessboard) {
for (int step : rows) {
System.out.print(step + "\t");
}
System.out.println();
}
}
/**
* 完成骑士周游问题的算法
*
* @param chessboard
* 棋盘
* @param row
* 马儿当前的位置的行 从0开始
* @param column
* 马儿当前的位置的列 从0开始
* @param step
* 初始位置第一步
*/
public static void traversalChessboard(int[][] chessboard, int row,
int column, int step) {
chessboard[row][column] = step;
visited[row * X + column] = true;
// 获取当前位置可以走的下一个位置的集合
ArrayList<Point> ps = next(new Point(column, row));
while (!ps.isEmpty()) {
Point p = ps.remove(0);// 取出下一个可以走的位置
// 判断该点是否已经访问过
if (!visited[p.y * X + p.x]) {
// 说明还没有访问过
traversalChessboard(chessboard, p.y, p.x, step + 1);
}
}
// 如果没有达到数量，则表示没有完成任务，将整个棋盘置0
// 1、棋盘目前位置仍然没有走完
// 2、棋盘处于一个回溯过程
if (step < X * Y && !finished) {
chessboard[row][column] = 0;
visited[row * X + column] = false;
} else {
finished = true;
}
}
public static ArrayList<Point> next(Point curPoint) {
ArrayList<Point> ps = new ArrayList<Point>();
Point p1 = new Point();
if ((p1.x = curPoint.x - 2) >= 0 && (p1.y = curPoint.y - 1) >= 0) {
ps.add(new Point(p1));
}
if ((p1.x = curPoint.x - 1) >= 0 && (p1.y = curPoint.y - 2) >= 0) {
ps.add(new Point(p1));
}
if ((p1.x = curPoint.x + 1) < X && (p1.y = curPoint.y - 2) >= 0) {
ps.add(new Point(p1));
}
if ((p1.x = curPoint.x + 2) < X && (p1.y = curPoint.y - 1) >= 0) {
ps.add(new Point(p1));
}
if ((p1.x = curPoint.x + 2) < X && (p1.y = curPoint.y + 1) < Y) {
ps.add(new Point(p1));
}
if ((p1.x = curPoint.x + 1) < X && (p1.y = curPoint.y + 2) < Y) {
ps.add(new Point(p1));
}
if ((p1.x = curPoint.x - 1) >= 0 && (p1.y = curPoint.y + 2) < Y) {
ps.add(new Point(p1));
}
if ((p1.x = curPoint.x - 2) >= 0 && (p1.y = curPoint.y + 1) < Y) {
ps.add(new Point(p1));
}
return ps;
}
}
执行结果
