Java Puzzle项目

项目介绍:

该项目类似于课堂讲解的迷宫项目实现。采用栈对puzzle中,从头走到尾巴的行走路径进行打印。

项目功能:

初始正方形中的带圆圈的数字是可以移动到沿着行的其他正方形的

项目所用知识点:

使用Java面向对象思想，用递归或栈或者队列实现编程。

项目实现思路:

在拼图的每个步骤，可以移动标记的正方形中由当前占据的整数指示的方格数。标记可以沿着该行向左或向右移动，但可以不移动经过任- -端。例如, 唯一合法的第一 步是将标记向右移动三个方格， 因为没有空间向左移动三个空格。如果圆圈能够移动到最后0的位置，返回true,否则返回false。如何检测不能解决的结构，是否存在可以改善执行时间的方法。程序运行,然后打印出方格，再打印详细的移动路径。下图示例演示跳转过程：一位数组4 8 5 2 3 5 1 6

1. 测试类

public class TestDemo {
    public static void main(String[] args) {
        Puzzle puzzle = new Puzzle();
        puzzle.goPuzzle();
    }
}

2. PuzzleNode类

public class PuzzleNode {
    private int value;
    private int index;
    private boolean isLeft;//左边是否可走
    private boolean isRight;//右边是否可走

    public PuzzleNode(int value, int index) {
        this.value = value;
        this.index = index;
    }

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }

    public int getIndex() {
        return index;
    }

    public void setIndex(int index) {
        this.index = index;
    }

    public boolean isLeft() {
        return isLeft;
    }

    public void setLeft(boolean left) {
        isLeft = left;
    }

    public boolean isRight() {
        return isRight;
    }

    public void setRight(boolean right) {
        isRight = right;
    }
}

3. Puzzle类

import java.util.Scanner;
import java.util.Stack;

public class Puzzle {
    private PuzzleNode[] puzzleNodes;
    private static final int NODESIZE = 10;
    private Stack<PuzzleNode> stack = new Stack<>();
    private static Scanner scanner = new Scanner(System.in);

    public Puzzle() {
        this.puzzleNodes =new PuzzleNode[NODESIZE];
    }
    private void initPuzszle(){//初始化数组
        //随机生成数组
        System.out.println("请输入方格中的值：");
        for(int i=0;i<puzzleNodes.length;i++){
            puzzleNodes[i] = new PuzzleNode(scanner.nextInt(),i);
        }
    }
    private void adjustDirection(){//调整每个节点左右方向是否可走
        for (int i=0;i<puzzleNodes.length;i++){
            //左边
            if(i-puzzleNodes[i].getValue()>=0){
                puzzleNodes[i].setLeft(true);
            }
            //右边
            if (i + puzzleNodes[i].getValue()<puzzleNodes.length){
                puzzleNodes[i].setRight(true);
            }
        }
    }
    public void goPuzzle(){
        initPuzszle();
        adjustDirection();

        stack.push(puzzleNodes[0]);
        while (!stack.isEmpty()){
            //下一个
            PuzzleNode top = stack.peek();
            int value = top.getValue();
            int index = top.getIndex();
            if(value == 0 && index == puzzleNodes.length-1){
                System.out.println("成功找到路径");
                break;
            }
            if(top.isRight()){//右边可走
                //将右边节点入栈
                stack.push(puzzleNodes[index+value]);
                top.setRight(false);
            }else if(top.isLeft()){
                //将左边方向入栈
                stack.push(puzzleNodes[index-value]);
                top.setLeft(false);
            }else{//左右不可走
                stack.pop();
            }
        }
        if(stack.isEmpty()){
            System.out.println("无路可走");
        }else{
            show();
        }
    }
    private void show(){
        while (!stack.isEmpty()){
            System.out.print(stack.peek().getValue()+"⬅");
            stack.pop();
        }
    }
}