你可以先new一个JPanel上面使用GridLayout(7,15)布局管理器，依次add组件。空白位置add(new JPanel())，需要文本框覆盖的位置add文本框或者文本域组件。
然后预览后发现这些文本框按照你的想法都排列在哪里。
这时候再截图（仅这个java窗口），然后把截图放到ps里面，然后设置预览比例为100%。进行1:1比例画图吧。保存图片。
然后再java程序里，为JFrame添加图片，位置和分辨率就可以设置为(0,0,x,y)，x和y是JFrame的长和宽。
二叉树的相关操作，包括创建，中序、先序、后序（递归和非递归），其中重点的是java在先序创建二叉树和后序非递归遍历的的实现。package com.algorithm.tree
import java.io.File
import java.io.FileNotFoundException
import java.util.Queue
import java.util.Scanner
import java.util.Stack
import java.util.concurrent.LinkedBlockingQueue
public class Tree {
private Node root
public Tree() {
}
public Tree(Node root) {
this.root = root
}
//创建二叉树
public void buildTree() {
Scanner scn = null
try {
scn = new Scanner(new File("input.txt"))
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace()
}
root = createTree(root,scn)
}
//先序遍历创建二叉树
private Node createTree(Node node,Scanner scn) {
String temp = scn.next()
if (temp.trim().equals("#")) {
return null
} else {
node = new Node((T)temp)
node.setLeft(createTree(node.getLeft(), scn))
node.setRight(createTree(node.getRight(), scn))
return node
}
}
//中序遍历(递归)
public void inOrderTraverse() {
inOrderTraverse(root)
}
public void inOrderTraverse(Node node) {
if (node != null) {
inOrderTraverse(node.getLeft())
System.out.println(node.getValue())
inOrderTraverse(node.getRight())
}
}
//中序遍历(非递归)
public void nrInOrderTraverse() {
Stack<Node>stack = new Stack<Node>()
Node node = root
while (node != null || !stack.isEmpty()) {
while (node != null) {
stack.push(node)
node = node.getLeft()
}
node = stack.pop()
System.out.println(node.getValue())
node = node.getRight()
}
}
//先序遍历(递归)
public void preOrderTraverse() {
preOrderTraverse(root)
}
public void preOrderTraverse(Node node) {
if (node != null) {
System.out.println(node.getValue())
preOrderTraverse(node.getLeft())
preOrderTraverse(node.getRight())
}
}
//先序遍历（非递归）
public void nrPreOrderTraverse() {
Stack<Node>stack = new Stack<Node>()
Node node = root
while (node != null || !stack.isEmpty()) {
while (node != null) {
System.out.println(node.getValue())
stack.push(node)
node = node.getLeft()
}
node = stack.pop()
node = node.getRight()
}
}
//后序遍历(递归)
public void postOrderTraverse() {
postOrderTraverse(root)
}
public void postOrderTraverse(Node node) {
if (node != null) {
postOrderTraverse(node.getLeft())
postOrderTraverse(node.getRight())
System.out.println(node.getValue())
}
}
//后续遍历(非递归)
public void nrPostOrderTraverse() {
Stack<Node>stack = new Stack<Node>()
Node node = root
Node preNode = null//表示最近一次访问的节点
while (node != null || !stack.isEmpty()) {
while (node != null) {
stack.push(node)
node = node.getLeft()
}
node = stack.peek()
if (node.getRight() == null || node.getRight() == preNode) {
System.out.println(node.getValue())
node = stack.pop()
preNode = node
node = null
} else {
node = node.getRight()
}
}
}
//按层次遍历
public void levelTraverse() {
levelTraverse(root)
}
public void levelTraverse(Node node) {
Queue<Node>queue = new LinkedBlockingQueue<Node>()
queue.add(node)
while (!queue.isEmpty()) {
Node temp = queue.poll()
if (temp != null) {
System.out.println(temp.getValue())
queue.add(temp.getLeft())
queue.add(temp.getRight())
}
}
}
}
//树的节点
class Node {
private Node left
private Node right
private T value
public Node() {
}
public Node(Node left,Node right,T value) {
this.left = left
this.right = right
this.value = value
}
public Node(T value) {
this(null,null,value)
}
public Node getLeft() {
return left
}
public void setLeft(Node left) {
this.left = left
}
public Node getRight() {
return right
}
public void setRight(Node right) {
this.right = right
}
public T getValue() {
return value
}
public void setValue(T value) {
this.value = value
}
}
测试代码：
package com.algorithm.tree
public class TreeTest {
/**
* @param args
*/
public static void main(String[] args) {
Tree tree = new Tree()
tree.buildTree()
System.out.println("中序遍历")
tree.inOrderTraverse()
tree.nrInOrderTraverse()
System.out.println("后续遍历")
//tree.nrPostOrderTraverse()
tree.postOrderTraverse()
tree.nrPostOrderTraverse()
System.out.println("先序遍历")
tree.preOrderTraverse()
tree.nrPreOrderTraverse()
//
}
}
首先我想问为什么要用LinkedList 来建立二叉树呢? LinkedList 是线性表,树是树形的, 似乎不太合适。
其实也可以用数组完成，而且效率更高.
关键是我觉得你这个输入本身就是一个二叉树啊，
String input = "ABCDE F G"
节点编号从0到8. 层次遍历的话:
对于节点i.
leftChild = input.charAt(2*i+1)//做子树
rightChild = input.charAt(2*i+2)//右子树
如果你要将带有节点信息的树存到LinkedList里面, 先建立一个节点类:
class Node{
public char cValue
public Node leftChild
public Node rightChild
public Node(v){
this.cValue = v
}
}
然后遍历input,建立各个节点对象.
LinkedList tree = new LinkedList()
for(int i=0i<input.lengthi++)
LinkedList.add(new Node(input.charAt(i)))
然后为各个节点设置左右子树:
for(int i=0i<input.lengthi++){
((Node)tree.get(i)).leftChild = (Node)tree.get(2*i+1)
((Node)tree.get(i)).rightChild = (Node)tree.get(2*i+2)
}
这样LinkedList 就存储了整个二叉树. 而第0个元素就是树根，思路大体是这样吧。
