java写的 8数码程序

思路：
先要解决下列问题：
如何表示节点？
如何扩展节点？
如何判断找到了目标节点?
最终路径是什么？

我设计了如下的类 ：
EightPuzzle（算法类，有深度优先算法，宽度优先算法，A启发式搜索，打印结果的方法等,内部有open，closed表，
  目标状态，初始状态）
Node (节点类，内部包含指向父节点的引用 parent，和指向子节点的引用 Children 是一个集合，fn,dn
  wn 并实现了Comparable 接口，支持排序)
Chart （8数码类，继承自Node类，包含计算 不再位数目的方法，上下左右移动的方法，扩展节点的方法，
  判断是否为父节点的方法（递归实现），打印的方法）
Position （位置类，包含位置坐标和位于其上的数字，0代表空格）每一个chart都有9个position
Graph (图类，用于保存所有节点)

如果不在位数目为0 则认为找到了目标节点。
通过移动空格 生成不同的Chart 就是子节点
最终路径 closed表中的节点。

在这些问题解答之后，可以写一个宽度优先算法，然后在宽度优先算法的基础上，写A启发式搜索算法。

参见教参（《人工智能》马少平，朱小燕 编著）

EightPuzzle 类
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;

/**
* @author Sunmoonone
*
*/

enum Algorithms {
BreadthFirst, DepthFirst, AHeuristic
}

public class EightPuzzle {
Graph graph;
Node goal, initial;
ArrayList<Node> openList, closedList;
final int fail = 0, success = 1;

Algorithms algor = Algorithms.AHeuristic;

// ;
/**
*
*/
public EightPuzzle(int[] numForGoal, int[] numForInitial, int algorithmsType) {
this.goal = new Chart(numForGoal);
this.initial = new Chart(numForInitial);
this.openList = new ArrayList<Node>();
this.closedList = new ArrayList<Node>();
graph = new Graph();

System.out.println("Final Chart:");
((Chart) this.goal).print();
System.out.println();
System.out.println("Initial Chart:");
((Chart) this.initial).print();
System.out.println();


switch (algorithmsType) {
case 0:
this.algor = Algorithms.BreadthFirst;
this.BreadthFirst();
break;
/*
case 5:
this.algor = Algorithms.DepthFirst;
//this.DepthFirst();
break;
*/
case 1:
this.algor = Algorithms.AHeuristic;
this.AHeuristic();
break;
default:
this.algor = Algorithms.AHeuristic;
this.AHeuristic();
break;

}
}
/**
* Bread First Search
* @return
*/
public int BreadthFirst() {
System.out.println("Bread First Search");
graph.nodes.clear();
this.closedList.clear();
this.openList.clear();

graph.nodes.add(this.initial);
this.openList.add(this.initial);
System.out.println("add initial node to open list");

Node transNode;
while (true) {
if (this.openList.isEmpty()){
System.out.println("open list is empty");
return fail;
}

transNode = this.openList.get(0);
System.out.println("get first node from open list:");
transNode.print();
if (hit(transNode)){
System.out.println("Succeed");
return success;
}
this.closedList.add(transNode);
this.openList.remove(transNode);
//expand node
transNode.expandNode();

System.out.println("expand node:");
Iterator<Node> iter=transNode.children.iterator();
while(iter.hasNext()){
Node node=iter.next();
//modify parent reference of children
node.parent=transNode;
node.print();
}
this.graph.AddNodes(transNode.children);
//append nodes to the open list
//which are not contained the open list or the closed list
appendOpenList(transNode.children);
}
}

/**
* Depth First Search
* @return
*/
public int DepthFirst() {
return fail;
}
/**
* A Heuristic search
* @return
*/
public int AHeuristic() {
System.out.println("A Heuristic search");
//graph.nodes.clear();
this.closedList.clear();
this.openList.clear();

//graph.nodes.add(this.initial);
this.openList.add(this.initial);
this.initial.fn=0+Chart.nonSuited((Chart)this.initial, (Chart)this.goal);
System.out.println("add initial node to open list");

Node transNode;
while (true) {
if (this.openList.isEmpty()){
System.out.println("open list is empty");
return fail;
}

transNode = this.openList.get(0);
System.out.println("get first node from open list:");
transNode.print();
if (hit(transNode)){
System.out.println("Succeed");
return success;
}
this.closedList.add(transNode);
this.openList.remove(transNode);
//expand node
transNode.expandNode();
//calculate f(n,mi),f(n,mj),f(n,ml) and modify references
modifyReference(transNode,transNode.children);
//sort by fn of nodes
sort(this.openList);
System.out.println("open list sorted by fn:");
printFns();
}
}

private void printFns() {
Iterator<Node> iter=this.openList.iterator();
while(iter.hasNext()){
System.out.print(iter.next().fn+" ");
}
System.out.println();
}
private void sort(ArrayList<Node> openList2) {

Collections.sort(openList2);
}
private void modifyReference(Node transNode, ArrayList<Node> children) {

Iterator<Node> iter=children.iterator();
while(iter.hasNext()){
Node node=iter.next();
//add mj to open list and set parent reference to transNode
if(!this.openList.contains(node)&&!this.closedList.contains(node)){
this.openList.add(node);
node.parent=transNode;
node.dn=node.parent.dn+1;
node.wn=Chart.nonSuited((Chart)node,(Chart)this.goal);
node.fn=node.dn+node.wn;
System.out.println("append:mj");
}
//mk
else if(this.openList.contains(node)){
if(transNode.dn+1+node.wn<node.fn){
node.parent=transNode;
node.fn=transNode.dn+1+node.wn;
node.dn=transNode.dn+1;
System.out.println("modified fn and referece:mk");
}
}
//ml
else if(this.closedList.contains(node)){
if(transNode.dn+1+node.wn<node.fn){
node.fn=transNode.dn+1+node.wn;
node.dn=transNode.dn+1;
node.parent=transNode;
this.openList.add(node);
this.closedList.remove(node);
System.out.println("modified fn and referece and add it back to open list:ml");
}
}
}
}
/**
* add collection of nodes to the open list
* operation is different depending on the
* different Algorithms
* @param nodes
*/
private void appendOpenList(ArrayList<Node> nodes) {
System.out.println("append nodes to open list:");
Iterator<Node> iter = nodes.iterator();
while (iter.hasNext()) {
if (this.algor == Algorithms.BreadthFirst) {
Node temp = iter.next();
if (!this.openList.contains(temp)
&& !this.closedList.contains(temp)) {
//append node to the end of the open list
this.openList.add(temp);
temp.print();
}
}
}
}

private boolean hit(Node transNode) {
if (Chart.nonSuited((Chart) transNode, (Chart) goal) == 0) {
return true;
}
return false;
}

/**
* print search path
*/
public void print() {
System.out.println("Initial Chart:");
((Chart) this.initial).print();
System.out.println();
System.out.println("Final Chart:");
((Chart) this.goal).print();
System.out.println("---------------Search path---------------------");
Iterator<Node> iter = this.closedList.iterator();
while (iter.hasNext()) {
iter.next().print();
System.out.println();
}
System.out.println("-----------------Graph-------------------");
System.out.println("graph nodes count:"+this.graph.nodes.size());
this.graph.print();
}
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;

/**
* @author Sunmoonone
*
*/

enum Algorithms {
BreadthFirst, DepthFirst, AHeuristic
}

public class EightPuzzle {
Graph graph;
Node goal, initial;
ArrayList<Node> openList, closedList;
final int fail = 0, success = 1;

Algorithms algor = Algorithms.AHeuristic;

// ;
/**
*
*/
public EightPuzzle(int[] numForGoal, int[] numForInitial, int algorithmsType) {
this.goal = new Chart(numForGoal);
this.initial = new Chart(numForInitial);
this.openList = new ArrayList<Node>();
this.closedList = new ArrayList<Node>();
graph = new Graph();

System.out.println("Final Chart:");
((Chart) this.goal).print();
System.out.println();
System.out.println("Initial Chart:");
((Chart) this.initial).print();
System.out.println();


switch (algorithmsType) {
case 0:
this.algor = Algorithms.BreadthFirst;
this.BreadthFirst();
break;
/*
case 5:
this.algor = Algorithms.DepthFirst;
//this.DepthFirst();
break;
*/
case 1:
this.algor = Algorithms.AHeuristic;
this.AHeuristic();
break;
default:
this.algor = Algorithms.AHeuristic;
this.AHeuristic();
break;

}
}
/**
* Bread First Search
* @return
*/
public int BreadthFirst() {
System.out.println("Bread First Search");
graph.nodes.clear();
this.closedList.clear();
this.openList.clear();

graph.nodes.add(this.initial);
this.openList.add(this.initial);
System.out.println("add initial node to open list");

Node transNode;
while (true) {
if (this.openList.isEmpty()){
System.out.println("open list is empty");
return fail;
}

transNode = this.openList.get(0);
System.out.println("get first node from open list:");
transNode.print();
if (hit(transNode)){
System.out.println("Succeed");
return success;
}
this.closedList.add(transNode);
this.openList.remove(transNode);
//expand node
transNode.expandNode();

System.out.println("expand node:");
Iterator<Node> iter=transNode.children.iterator();
while(iter.hasNext()){
Node node=iter.next();
//modify parent reference of children
node.parent=transNode;
node.print();
}
this.graph.AddNodes(transNode.children);
//append nodes to the open list
//which are not contained the open list or the closed list
appendOpenList(transNode.children);
}
}

/**
* Depth First Search
* @return
*/
public int DepthFirst() {
return fail;
}
/**
* A Heuristic search
* @return
*/
public int AHeuristic() {
System.out.println("A Heuristic search");
//graph.nodes.clear();
this.closedList.clear();
this.openList.clear();

//graph.nodes.add(this.initial);
this.openList.add(this.initial);
this.initial.fn=0+Chart.nonSuited((Chart)this.initial, (Chart)this.goal);
System.out.println("add initial node to open list");

Node transNode;
while (true) {
if (this.openList.isEmpty()){
System.out.println("open list is empty");
return fail;
}

transNode = this.openList.get(0);
System.out.println("get first node from open list:");
transNode.print();
if (hit(transNode)){
System.out.println("Succeed");
return success;
}
this.closedList.add(transNode);
this.openList.remove(transNode);
//expand node
transNode.expandNode();
//calculate f(n,mi),f(n,mj),f(n,ml) and modify references
modifyReference(transNode,transNode.children);
//sort by fn of nodes
sort(this.openList);
System.out.println("open list sorted by fn:");
printFns();
}
}

private void printFns() {
Iterator<Node> iter=this.openList.iterator();
while(iter.hasNext()){
System.out.print(iter.next().fn+" ");
}
System.out.println();
}
private void sort(ArrayList<Node> openList2) {

Collections.sort(openList2);
}
private void modifyReference(Node transNode, ArrayList<Node> children) {

Iterator<Node> iter=children.iterator();
while(iter.hasNext()){
Node node=iter.next();
//add mj to open list and set parent reference to transNode
if(!this.openList.contains(node)&&!this.closedList.contains(node)){
this.openList.add(node);
node.parent=transNode;
node.dn=node.parent.dn+1;
node.wn=Chart.nonSuited((Chart)node,(Chart)this.goal);
node.fn=node.dn+node.wn;
System.out.println("append:mj");
}
//mk
else if(this.openList.contains(node)){
if(transNode.dn+1+node.wn<node.fn){
node.parent=transNode;
node.fn=transNode.dn+1+node.wn;
node.dn=transNode.dn+1;
System.out.println("modified fn and referece:mk");
}
}
//ml
else if(this.closedList.contains(node)){
if(transNode.dn+1+node.wn<node.fn){
node.fn=transNode.dn+1+node.wn;
node.dn=transNode.dn+1;
node.parent=transNode;
this.openList.add(node);
this.closedList.remove(node);
System.out.println("modified fn and referece and add it back to open list:ml");
}
}
}
}
/**
* add collection of nodes to the open list
* operation is different depending on the
* different Algorithms
* @param nodes
*/
private void appendOpenList(ArrayList<Node> nodes) {
System.out.println("append nodes to open list:");
Iterator<Node> iter = nodes.iterator();
while (iter.hasNext()) {
if (this.algor == Algorithms.BreadthFirst) {
Node temp = iter.next();
if (!this.openList.contains(temp)
&& !this.closedList.contains(temp)) {
//append node to the end of the open list
this.openList.add(temp);
temp.print();
}
}
}
}

private boolean hit(Node transNode) {
if (Chart.nonSuited((Chart) transNode, (Chart) goal) == 0) {
return true;
}
return false;
}

/**
* print search path
*/
public void print() {
System.out.println("Initial Chart:");
((Chart) this.initial).print();
System.out.println();
System.out.println("Final Chart:");
((Chart) this.goal).print();
System.out.println("---------------Search path---------------------");
Iterator<Node> iter = this.closedList.iterator();
while (iter.hasNext()) {
iter.next().print();
System.out.println();
}
System.out.println("-----------------Graph-------------------");
System.out.println("graph nodes count:"+this.graph.nodes.size());
this.graph.print();
}
}

class Node implements Comparable<Node>{
    public static int count=0;
    int id;
    Node parent;
    ArrayList<Node> children;
    int fn=0;
    int dn=0;
    int wn=0;
    public Node() {
        this.id=count;
        count++;
        this.children = new ArrayList<Node>();
    }

    public void expandNode() {

    }

    public void print() {

    }

    /**
     * whether a node is one of the parents of this node this method is used to
     * verify a child node that will be added as child node of this node
     * 
     * @param node
     * @return true if nod is one of the parents of this node
     */
    public boolean parentContains(Node node) {
        return false;
    }

    public int compareTo(Node o) {
        if(this.fn<o.fn)
            return -1;
        else if(this.fn==o.fn)
            return 0;
        return 1;
    }
}

class Chart extends Node {

    Position[] positions = new Position[9];

    public Chart() {
        super();

    }

    /**
     * construct a Chart instance with 9 numbers
     * 
     * @param numbers
     *            9 numbers([0-8]) ,0 represents white space
     */
    public Chart(int[] numbers) {
        super();
        Position pos;
        int cursor = 0;
        for (int i = 0; i < 3; i++)
            for (int j = 0; j < 3; j++) {
                //j is x coordinate, i is y coordinate
                pos = new Position(j, i, numbers[cursor]);
                this.positions[cursor] = pos;
                cursor++;
            }
    }
    
    /**
     * print this chart
     */
    public void print() {
        
        int cursor = 0;
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                System.out.print(this.positions[cursor].toString() + " ");
                cursor++;
            }
            System.out.println();
        }
        System.out.println("id:"+this.id);
        System.out.print("Parent:");
        if(this.parent!=null)
            System.out.print(this.parent.id);
        System.out.println();
        System.out.print("Children:");
        Iterator<Node> iter=this.children.iterator();
        while(iter.hasNext()){
            System.out.print(iter.next().id+" ");
        }
        System.out.println();
        System.out.println("-----");
    }

    /**
     * creates and returns a copy of this object the new cloned object also has
     * a copy of the data of this object
     */
    public Chart clone() {
        Chart newchart = new Chart();
        
        //newchart.positions = (Position[]) this.positions.clone();
        //System.arraycopy(this.positions, 0, newchart.positions, 0, this.positions.length);
        //because Position is a class
        for(int i=0;i<this.positions.length;i++){
            newchart.positions[i]=(Position)this.positions[i].clone();
        }
        
        return newchart;
    }

    /**
     * get index of a position by number placed in it.
     * 
     * @param number
     *            number placed in this position
     * @return get index of a position
     */
    public int getPosition(int number) {
        for (int i = 0; i < this.positions.length; i++) {
            if (this.positions[i].getNum() == number) {
                return i;
            }
        }
        return -1;
    }

    /**
     * get index of a position by coordinate
     * 
     * @param x
     *            x coordinate
     * @param y
     *            x coordinate
     * @return index of a position
     */
    public int getPosition(int x, int y) {
        for (int i = 0; i < this.positions.length; i++) {
            if (this.positions[i].getX() == x && this.positions[i].getY() == y) {
                return i;
            }
        }
        return -1;
    }

    public Chart moveLeft() {
        //at the left edge
        if (this.positions[this.getPosition(0)].getX() == 0) {
            return null;
        } else {
            Chart newChart = this.clone();

            newChart.switchPosition(newChart.getPosition(0), newChart.getPosition(0)-1);
            return newChart;
        }
    }

    public Chart moveRight() {
        //at the right edge
        if (this.positions[this.getPosition(0)].getX() == 2) {
            
            return null;
        } else {
            Chart newChart = this.clone();
            newChart.switchPosition(newChart.getPosition(0), newChart.getPosition(0)+1);
            return newChart;
        }
    }

    public Chart moveUp() {
        //in the top line
        if (this.positions[this.getPosition(0)].getY() == 0) {
            return null;
        } else {
            Chart newChart = this.clone();
            newChart.switchPosition(newChart.getPosition(0), newChart.getPosition(0)-3);
            return newChart;
        }
    }

    public Chart moveDown() {
        //in the bottom line 
        if (this.positions[this.getPosition(0)].getY() == 2) {
            return null;
        } else {
            Chart newChart = this.clone();
            newChart.switchPosition(newChart.getPosition(0), newChart.getPosition(0)+3);
            return newChart;
        }
    }
    /**
     * switch number displayed in these two positions of this chart
     * but not the coordinate
     * @param i index of position
     * @param j index of position
     */
    private void switchPosition(int i,int j){
        int temp;
        temp=this.positions[i].getNum();
        this.positions[i].setNum(this.positions[j].getNum());
        this.positions[j].setNum(temp);
    }
    /**
     * expand this node
     */
    public void expandNode() {

        Chart chLeft, chRight, chUp, chDown;
        chLeft = this.moveLeft();
        chRight = this.moveRight();
        chUp = this.moveUp();
        chDown = this.moveDown();

        if (chLeft != null && !this.parentContains(chLeft)) {
            this.children.add(chLeft);
        }

        if (chRight != null && !this.parentContains(chRight)) {
            this.children.add(chRight);
        }
        if (chUp != null && !this.parentContains(chUp)) {
            this.children.add(chUp);
        }
        if (chDown != null && !this.parentContains(chDown)) {
            this.children.add(chDown);
        }
    }

    /**
     * get count of non suited numbers
     * 
     * @param trans
     *            transient chart
     * @param goal
     *            destination
     * @return
     */
    public static int nonSuited(Chart trans, Chart goal) {
        int result = 0;
        for (int i = 0; i < goal.positions.length; i++) {
            if (goal.positions[i].getNum() != trans.positions[i].getNum()) {
                result++;
            }

        }
        System.out.println("w(n)="+result);
        return result;
    }

    public boolean parentContains(Node node) {
        if (this.parent != null) {
            if (this.parent.equals(node))
                return true;
            else
                return this.parent.parentContains(node);
        }
        return false;
    }

    public boolean equals(Object o) {
        Chart chart = (Chart) o;
        if (this.positions.equals(chart.positions))
            return true;
        else
            return false;
    }
}

class Position {
    // coordinate
    private int x, y;

    public int getY() {
        return y;
    }

    public int getX() {
        return x;
    }


    /**
     * number placed in this position 0 represents white space
     */
    private int num;

    /**
     * get number placed in this position 0 represents white space
     */
    public int getNum() {
        return num;
    }

    /**
     * set number placed in this position 0 represents white space
     */
    public void setNum(int num) {
        this.num = num;
    }

    /**
     * 
     * @param x
     *            x coordinate
     * @param y
     *            y coordinate
     * @param number
     *            number placed in this position
     */
    public Position(int x, int y, int number) {
        this.x = x;
        this.y = y;
        this.num = number;
    }
    
    public Position() {
        // TODO Auto-generated constructor stub
    }

    public Object clone(){
        return new Position(this.getX(),this.getY(),this.getNum());
    }
    public String toString() {
        if (this.getNum() == 0)
            return " ";
        return String.valueOf(this.getNum());
    }
}

class Graph {
    ArrayList<Node> nodes;

    public Graph() {
        nodes = new ArrayList<Node>();
    }

    /**
     * add collections of nodes to this graph
     * 
     * @param nodes
     */
    public void AddNodes(ArrayList<Node> nodes) {
        Iterator<Node> iter = nodes.iterator();
        while (iter.hasNext()) {
            this.nodes.add(iter.next());
        }
    }
    public void print(){
        Iterator<Node> iter=this.nodes.iterator();
        while(iter.hasNext()){
            iter.next().print();
        }
    }
}

public class Main {

    /**
     * @param args
     */
    public static void main(String[] args) {

        try {

            System.out
                    .println("Type numbers([0-8]) and Algorithms type in format 2 8 3 1 6 4 7 0 5,1 2 3 8 0 4 7 6 5,1");
            System.out.println("The first 9 numbers are for the final state,the last integer is for Algorithms type.");
            System.out.println("0:BreadthFirst; 1:AHeuristic.");
            String str;
            BufferedReader inStream = new BufferedReader(new InputStreamReader(
                    System.in));
            str = inStream.readLine();
            String[] strs = str.split(",");

            String[] intstrs1 = strs[0].split(" ");
            int[] ints1 = new int[9];
            for (int i = 0; i < 9; i++) {
                ints1[i] = Integer.parseInt(intstrs1[i]);
            }
            String[] intstrs2 = strs[1].split(" ");
            int[] ints2 = new int[9];
            for (int i = 0; i < 9; i++) {
                ints2[i] = Integer.parseInt(intstrs2[i]);
            }

            int type = Integer.parseInt(strs[2]);
            //
            EightPuzzle ep = new EightPuzzle(ints1, ints2, type);
            
            ep.print();
        } catch (IOException e) {
            System.out.println(e.getMessage());
        }

    }
}