关于Swing打印二叉树

最新推荐文章于 2024-04-10 11:07:56 发布
最新推荐文章于 2024-04-10 11:07:56 发布 · 277 阅读 · 0
文章标签：

#数据结构与算法 #java

[img][/img]最近研究二叉树一类的树结构，总用调试的办法去搞好麻烦，想用界面显示树结构，想看是不是AVL啊，（红黑树那个还在弄，太麻烦），于是就想弄出界面来，考虑了下准备用flex做也网页图形的，毕竟研究过用flex绘图等简单的东西，又想想swing这东西还一直没弄过呢，学java的不会swing惭愧啊，就是今天给按钮加个点击事件都纠结了半天。。。。唉 性格所致 ，越是不会的东西越要去折腾。反正也是做的玩玩，于是就用swing去折腾，虽然我从没用过，但我想还不是一个绘图类画画直线啥的。

关于绘制树的思路：从最简单的二叉树搞起。每个节点增加坐标属性(x,y)，然后 遍历树的话也就是那4种遍历方法。前序、中序、后序、层次，或许有其他的遍历方法，目前只知道这几种简单的方法来遍历树。

下面上代码，代码写的很随意，未整理。

package sunfa.tree;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
import java.util.Random;
import java.util.Set;

public class TreeXY<K, V> {
	public static void main(String[] args) {
		TreeXY<String, Object> tree = new TreeXY<String, Object>(null,
				new BaseXY(600, 0, 20, 10));
		int n = 10;
		Random ran = new Random();
		for (int i = 0; i < n; i++) {
			int o = ran.nextInt(100);
			System.out.print(o + ",");
			tree.put(Integer.toString(o), o);
		}
		System.out.println("printTree:");
		tree.printTree(tree.root);
	}

	private Comparator<K> comp;
	private Entry<K, V> root;
	private BaseXY baseXY;

	public TreeXY(Comparator<K> c, BaseXY baseXY) {
		if (c != null)
			comp = c;
		this.baseXY = baseXY;
	}

	public Entry<K, V> getRoot() {
		return root;
	}

	private List<Entry<K, V>> equalsXY = new ArrayList<Entry<K, V>>();
	private Set<String> xyHash = new HashSet<String>();

	public void printTree(Entry<K, V> node) {
		if (node == null)
			return;
		printTree(node.left);
		System.out.print(node.key+",");// + "[" + node.xy + "],");
		String key = node.xy.x + "_" + node.xy.y;
		if (xyHash.contains(key)) {
			equalsXY.add(node);
		} else {
			xyHash.add(key);
		}
		printTree(node.right);
	}

	public void put(K key, V value) {
		if (root == null) {
			root = new Entry<K, V>(key, value, new XYPosition(baseXY.rootX,
					baseXY.rootY), null);
			return;
		}
		Entry<K, V> node = root;
		while (true) {
			int n = compare(key, node.key);
			if (n == 0) {
				node.value = value;
				return;
			} else if (n < 0) {
				if (node.left != null) {
					node = node.left;
				} else {
					node.left = new Entry<K, V>(key, value, new XYPosition(
							node.xy.x - baseXY.xgap, node.xy.y + baseXY.ygap),
							node);
					return;
				}
			} else {
				if (node.right != null) {
					node = node.right;
				} else {
					node.right = new Entry<K, V>(key, value, new XYPosition(
							node.xy.x + baseXY.xgap, node.xy.y + baseXY.ygap),
							node);
					return;
				}
			}
		}
	}

	private int compare(K k1, K k2) {
		return comp != null ? (comp.compare(k1, k2)) : (((Comparable<K>) k1)
				.compareTo(k2));
	}

	public static class Entry<K, V> {
		public Entry<K, V> parent;
		public Entry<K, V> left;
		public Entry<K, V> right;
		public XYPosition xy;
		public K key;
		public V value;

		public Entry(K key, V value, XYPosition xy, Entry<K, V> parent) {
			super();
			this.key = key;
			this.value = value;
			this.xy = xy;
			this.parent = parent;
		}
	}

	public static class XYPosition {
		public int x;
		public int y;

		public XYPosition(int x, int y) {
			super();
			this.x = x;
			this.y = y;
		}

		public String toString() {
			return this.x + "," + this.y;
		}
	}
}


上面是一颗简单的二叉树，节点含有坐标属性。


package sunfa.tree;

public class BaseXY {
	int rootX;// 根节点的X
	int rootY;// 根节点的Y
	// int size;// 单元格子大小

	// 水平和垂直间距
	int xgap;
	int ygap;

	public BaseXY(int rootX, int rootY, int xgap, int ygap) {
		super();
		this.rootX = rootX;
		this.rootY = rootY;
		this.xgap = xgap;
		this.ygap = ygap;
	}

}


这个是初始化树的时候传递的基础坐标和间距的类。

package sunfa.tree.draw;

import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Container;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.font.FontRenderContext;
import java.awt.font.TextLayout;
import java.awt.geom.Line2D;
import java.awt.geom.RoundRectangle2D;
import java.awt.image.BufferedImage;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Queue;
import java.util.Random;
import java.util.concurrent.ArrayBlockingQueue;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;

import sunfa.tree.BaseXY;
import sunfa.tree.TreeXY;
import sunfa.tree.TreeXY.Entry;

public class GrapDemo1 extends JFrame implements ActionListener {
	private static final long serialVersionUID = 1L;
	JButton btn1;
	Container c;

	public GrapDemo1() {
		super("map");
		c = getContentPane();
		setSize(1000, 600);
		MapPanel comp = new MapPanel();
		comp.setSize(400, 400);
		btn1 = new JButton("text");
		btn1.setSize(100, 30);
		// btn1.action(MouseEvent.MOUSE_CLICKED, this);
		btn1.addActionListener(this); // 注册bt的监听者对象this
		getContentPane().add(btn1);
		getContentPane().add(comp);
	}

	public static void main(String[] args) {
		GrapDemo1 frame = new GrapDemo1();
		frame.setVisible(true);
	}

	public void actionPerformed(ActionEvent e) {
		if (e.getSource() == btn1) {
			Random ran = new Random();
			btn1.setText("btn1" + ran.nextInt(111));
			MapPanel comp = new MapPanel();
			comp.setSize(400, 400);
			c.add(comp);
		}
	}
}

class MapPanel extends JPanel {
	private static final long serialVersionUID = 1L;

	@Override
	protected void paintComponent(Graphics g) {
		// test(g);
		Graphics2D grap = (Graphics2D) g;// 绘图对象
		grap.clearRect(0, 0, 400, 400);
		// drawGrid(grap);

		// DrawTree();
		// render(400, 400, grap);
		DrawTree(grap);
	}

	private void DrawTree(Graphics2D grap) {
		BufferedImage srcImg = new BufferedImage(800, 800,
				BufferedImage.TYPE_INT_RGB);
		Graphics2D imageG2 = srcImg.createGraphics();
		String text = "aa";
		Font font = new Font("宋体", Font.BOLD, 28);
		FontRenderContext frc = grap.getFontRenderContext();
		TextLayout tl = new TextLayout(text, font, frc);

		// 设置白底黑字
		imageG2.setBackground(Color.WHITE);
		imageG2.clearRect(0, 0, 800, 800);
		imageG2.setColor(Color.BLACK);

		TreeXY<Integer, Object> tree = new TreeXY<Integer, Object>(
				new Comparator<Integer>() {
					public int compare(Integer o1, Integer o2) {
						return o1 - o2;
					}
				}, new BaseXY(400, 30, 100, 40));
		int n = 50;
		list.clear();
		list2.clear();
		Random ran = new Random();
		for (int i = 0; i < n; i++) {
			int o = ran.nextInt(100);
			System.out.print(o + ",");
			tree.put(o, o);
		}
		System.out.println("printTree:");
		// tree.printTree(tree.getRoot());
		// drawTree(grap);
		printTree(tree.getRoot(), imageG2);

		String ss = "";
		for (int i = 0; i < list2.size(); i++) {
			ss += list2.get(i).toString() + ",";
		}
		imageG2.drawString(ss, 10, 20);

		tl.draw(imageG2, 0, 0);
		grap.drawImage(srcImg, 100, 10, srcImg.getWidth(), srcImg.getHeight(),
				null);
	}

	public void render(int w, int h, Graphics2D g2) {
		BufferedImage srcImg = new BufferedImage(w, h,
				BufferedImage.TYPE_INT_RGB);
		Graphics2D imageG2 = srcImg.createGraphics();

		// 设置白底黑字
		imageG2.setBackground(Color.RED);
		imageG2.clearRect(0, 0, w, h);
		imageG2.setColor(Color.BLACK);

		String text = "标题：订货单位";
		Font font = new Font("宋体", Font.BOLD, 28);
		FontRenderContext frc = g2.getFontRenderContext();
		TextLayout tl = new TextLayout(text, font, frc);
		tl.draw(imageG2, 50, 50);

		// 文字的宽度将压缩一半显示
		g2.drawImage(srcImg, 0, 0, srcImg.getWidth() / 2, srcImg.getHeight(),
				null);
		// 文字正常显示
		g2.drawImage(srcImg, 0, srcImg.getHeight(), srcImg.getWidth(),
				srcImg.getHeight(), null);
	}

	int n = 10;

	private void drawTree(Graphics2D grap) {
		if (n == 0) {
			return;
		}
		grap.drawArc(100, 200, 110, 110, 0, 360);
		n--;
		drawTree(grap);
	}

	// private List<TreeXY.Entry> equalsXY = new ArrayList<TreeXY.Entry>();
	// private Set<String> xyHash = new HashSet<String>();
	private List<String> list = new ArrayList<String>();
	private List<String> list2 = new ArrayList<String>();

	// 中序周游打印二叉树
	public void printTree(TreeXY.Entry node, Graphics2D grap) {
		if (node == null)
			return;
		printTree(node.left, grap);
		// ---------start
		String key = node.xy.x + "_" + node.xy.y;
		int r = 30;
		// int tmp = node.xy.x - r;
		boolean isExits = false;
		for (int i = 0; i < list.size(); i++) {
			if (list.get(i).toString().equals(key)) {
				isExits = true;
			}
		}
		if (isExits) {
			// node.xy.x += 40;
			// tmp += 20;
			System.out.print("存在：" + key + ",");
		} else {
			list.add(key);
		}
		// if (xyHash.contains(key)) {
		// // equalsXY.add(node);
		// node.xy.x +=40;
		// tmp += 20;
		// System.out.print("存在："+key+",");
		// } else {
		// xyHash.add(key);
		// }
		int circleX = node.xy.x + r / 2 - 5;// 圆心
		int circleY = node.xy.y + r / 2 + 5;
		grap.drawArc(node.xy.x, node.xy.y, r, r, 0, 360);
		grap.drawString(node.key.toString(), circleX, circleY);
		if (node.parent != null) {
			int circleX2 = node.parent.xy.x + r - 5;
			int circleY2 = node.parent.xy.y + r + -5 - r / 2;
			grap.drawLine(circleX2, circleY2, circleX, circleY);
		}
		System.out.print(node.key + "[" + node.xy + "],");
		list2.add(node.key.toString());
		// -------------end
		printTree(node.right, grap);
	}

	private Queue<TreeXY.Entry> queue = new ArrayBlockingQueue<TreeXY.Entry>(10);

	// 层次打印二叉树
	public void printTree2(TreeXY.Entry node, Graphics2D grap) {
		queue.offer(node);
		while (queue.size() > 0) {
			node = queue.poll();
			if (node == null) {
				System.out.println("结束");
				return;
			}
			String key = node.xy.x + "_" + node.xy.y;
			int r = 30;
			// int tmp = node.xy.x - r;
			boolean isExits = false;
			for (int i = 0; i < list.size(); i++) {
				if (list.get(i).toString().equals(key)) {
					isExits = true;
				}
			}
			if (isExits) {
				node.xy.x += 40;
				// tmp += 20;
				System.out.print("存在：" + key + ",");
			} else {
				list.add(key);
			}
			int circleX = node.xy.x + r / 2 - 5;// 圆心
			int circleY = node.xy.y + r / 2 + 5;
			grap.drawArc(node.xy.x, node.xy.y, r, r, 0, 360);
			grap.drawString(node.key.toString(), circleX, circleY);
			if (node.parent != null) {
				int circleX2 = node.parent.xy.x + r - 5;
				int circleY2 = node.parent.xy.y + r + -5 - r / 2;
				grap.drawLine(circleX2, circleY2, circleX, circleY);
			}
			if (node.left != null)
				queue.offer(node.left);
			if (node.right != null)
				queue.offer(node.right);
		}
	}

	private void printTree2_0(ArrayBlockingQueue<TreeXY.Entry> queue,
			Graphics2D grap) {
		while (queue.size() > 0) {
			Entry o = queue.poll();
			if (o == null) {
				break;
			}
			if (o.left != null)
				queue.offer(o.left);
			if (o.right != null)
				queue.offer(o.right);
		}
	}

	// 绘制表格
	private void drawGrid(Graphics grap) {
		// grap = (Graphics2D) g;// 绘图对象
		int x1 = 0, y1 = 0, x2 = 0, y2 = 0, size = 40, row = 14, col = 17;
		int x3 = 0, y3 = 0;// 圆的坐标
		for (int i = 0; i < row; i++) {
			grap.drawLine(x1, y1, (col - 1) * size, y1);

			x3 = x1 + size >>> 1;
			y3 = y1 + size - (size >>> 1);
			grap.drawString((x1 + size >>> 1) + ","
					+ (y1 + size - (size >>> 1)), x3, y3);

			// 绘制的圆是按坐标点绘制弧形成圆的，无法得到圆心坐标点...
			grap.drawArc(x3, y3, size, size, 0, 360);
			y1 += size;
		}
		y1 = 0;
		for (int i = 0; i < col; i++) {
			grap.drawLine(x1, y1, x1, (row - 1) * size);
			x1 += size;
		}

		System.out.println("grap:" + grap);
	}

	// 学习笔记
	private void test(Graphics g) {
		Graphics2D grap = (Graphics2D) g;// 绘图对象
		grap.setPaint(new Color(255));// 设置绘图颜色
		grap.setStroke(new BasicStroke(15));// 设置笔的粗细

		// 在指定坐标处写文字
		grap.drawString("java绘图", 40, 240);
		// 线条
		Line2D.Float line = new Line2D.Float(100.0f, 100.0f, 200.0f, 200.0f);
		grap.draw(line);// 所有的图形都需要添加到绘图对象中才能显示到界面上

		// 矩形
		RoundRectangle2D.Double round = new RoundRectangle2D.Double(150, 140,
				100, 100, 1f, 1f);
		grap.setStroke(new BasicStroke(2));
		grap.draw(round);

		grap.setStroke(new BasicStroke(10));
		// 绘制一个覆盖指定矩形的圆弧或椭圆弧边框。 弧度可以指定从0-360,那么这就是一个圆
		grap.drawArc(20, 20, 20, 20, 0, 360);
		// 调用继承于Graphics类的方法绘制基本的图形，比如直线、矩形区域等
		grap.drawLine(10, 10, 120, 20);
	}
}


这个是绘制二叉树的绘图类，绘图类的代码比较乱没整理，现在也懒得去整理了，因为遇到了一个问题，纠结之。
[img]http://jqsl2012.iteye.com/upload/picture/pic/101090/8bd1ea61-7a97-38dc-89df-e4faf8152651.jpg[/img]
这张图就是最后绘制出来的效果，很遗憾的是存在交叉的地方，重叠了。虽然想了好几种方法去解决，但都没有好的效果，一下午的时间就在那折腾这个，还好没啥子任务要做。

[color=red]关于交叉部分的处理办法：
方法一：打印的时候处理。尝试过，效果差还很麻烦，并且和打印的代码混到了一起以后不好分离出来。
方法二：添加节点的时候处理。成功添加一个节点后，拿新添加的节点和其他所有的节点的坐标比较(可以把树的节点左边放到一个hashmap中，这里就直接get了，不用遍历树了)，如果存在重叠，这个时候注意观察，怎样才能让他们不重叠呢？办法其实很简单，先搞清楚新添加的节点相对于根节点而言是在根节点的左边还是在根节点的右边。如果是在根节点的左边就使根节点的左子节点向左移动(右边就使根节点的右子节点向右移动)，具体平移多少，示打印效果而定，可以平移一个单位或二个单位等等。

写这篇文章的时候我就在想，要不要使根节点的孙子节点也做对应的移动？还是不需要了，如果树的层次多的话，电脑的屏幕也装不下，也就失去了意义了，一般10来个层的树也就比较大了。所以使根节点的左右子树平移已经能满足基本的需求了。[/color]

或许也可以做成类似于企业人员结构图的形式。

未完。。。
java--从txt文件中读取完全二叉树数据建立二叉树并打印出遍历结果
Aguangg_6655_la的博客
04-15 3302
详细看注释： import java.io.*; import javax.swing.JOptionPane; import java.util.*; /** * 功能：读入文件里的数据存入二叉树中，然后进行3种方式的遍历 * * 参考资料0:数据结构(C语言版)严蔚敏 */ /** * 外部类：节点 * * @author ocaicai@yeah.net @date
逻辑运算表达式（*=逻辑与，+=逻辑或，!=逻辑非)转化为二叉树
fengzhishang2019的专栏
12-15 2538
package Test; import java.util.Stack; public class Expression {     public Expression(String src)     {         // TODO Auto-generated constructor stub         this.src = src;         des = ne
JAVA用awt画二叉树
09-16
用JAVA写的二叉树，大一的作品，很多细节没有弄好，仅供初学者参考，
二叉树
SwingGUI的博客
09-09 298
1，什么是二叉树 每个节点最多只有两个节点的树形结构 2，遍历 二叉树的遍历是从根节点出发，依次访问所有的二叉树节点，每个节点有且之访问一次。 （1） 前序遍历 若树为空，则返回空操作，否则先访问根节点，然后左子树，最后右子树。 （2） 中序遍历 若树为空，返回空操作，先从根节点开始（注意并不是先访问根节点），中序遍历根节点的左子树，然后是访问根节点，最后中序遍...
画二叉树 java实现
08-14 1551
最近无聊，写了一个画二叉树的程序。
swing树形图
jacke121的专栏
05-14 2060
swing树形图
Java 平衡二叉树初实现
掬水月在手，弄花香满衣
04-04 109
  (12.21.12)之前有人问到排序不正确的问题，是因为String.compareTo(String)是由左至右按逐个字符ASCII码大小排序的，所以10比9小。 要区分数字和字符串，可参考以下代码 1 //使到数字按数字大小排序，字符按字典大小排序，数字永远比字符小 2 protected boolean compare(String s1, String s...
二叉树随机建树与先序遍历程序演示
先序遍历的特点是，一旦遇到一个节点，就会首先对其进行操作（比如打印节点值），这使得先序遍历对于构建前缀表达式等非常有用。 ### Java实现二叉树先序遍历 Java是一种广泛使用的面向对象编程语言，非常适合实现...
掌握二叉树构建与输出技巧
同样以C++语言为例，二叉树的打印可以通过递归实现，以下是一个简化的示例代码片段，使用递归函数按照前序遍历方式打印二叉树： ```cpp void printTreePreOrder(TreeNode* root) { if (root == nullptr) return; ...
二叉树 单文档 （数据结构上机作业）
05-27
1. GUI框架：可能需要使用如Qt、wxWidgets、Java Swing或.NET Windows Forms等图形库来创建用户界面。 2. 事件处理：当用户在界面上执行操作（如点击按钮）时，需要捕获和处理这些事件。这可能涉及到添加监听器和...
数据结构 二叉排序树 java图形界面实现
02-20
数据结构 二叉排序树 二叉搜索树 java swing图形界面实现
数据结构 二叉树 java图形界面实现
02-20
内容涵盖二叉树的各种操作 包括新建二叉树后以多种方式输出 插入结点 删除结点等等
java可视化二叉树代码
05-11
java二叉树代码，该二叉树为可视化二叉树，可视化为swing中group的嵌套，通过点击add按钮添加子叶，通过点击delete删除子叶，同时会删除它下面的所有子树。图形化的操作非常适合二叉树的理解。
java GUI 的二叉树 和 平衡树（链式和数组形式都实现了）
03-29
利用java写了两个案例是关于二叉树和平衡树的分别为数组的和链式的。 功能： 1.三种历遍方式的输出。 2.平衡树的重构。 3.节点的添加以及删除。 4.平均查找长度的计算。
二叉树可视化Java语言实现（完整版，打开即可运行）
11-14
二叉树可视化Java语言实现，包含四个字文件、BinaryNode、Show1_12、Display_Tree、TreeControl。直接可以运行，方便快捷。
树~java递归实现二叉树先、中、后序遍历
yuzhiyun3536的专栏
09-16 476
前言：大三了，正在努力复习大一大二的知识，坑爹呀，由于做得项目里很少用到这些重要的基础知识，比如数据结构、算法，项目只会涉及简单的算法、数据结构知识，所以该忘的都给忘了，必须复习。节点类package BinaryTree;public class Node { // 左子节点 Node leftNode; // 右子节点 Node rightNode; // 节点值
java实现二叉树可视化_二叉树的实现及其可视化
weixin_31434215的博客
03-02 813
BinaryTree.javapackage com.binarytree.test;import java.util.*;public class BinaryTree>{private TreeNode root;private int size=0;public BinaryTree() {}public BinaryTree(E[] objects) {for (int i = ...
Eclipse+Java+Swing，每次面试必问的二叉树的设计与编码
最新发布
碧海朝天素
04-10 878
外链图片转存中…(img-mM7iDpjT-1712718461862)][外链图片转存中…(img-djUtNjGT-1712718461862)][外链图片转存中…(img-iCWTw91g-1712718461863)][外链图片转存中…(img-PbbAcwgH-1712718461863)][外链图片转存中…(img-VoU3b8lB-1712718461863)][外链图片转存中…(img-21UFKzVn-1712718461864)]
用C++实现按形状打印二叉树的方法
根据提供的文件信息，可以了解到需要详细阐述的知识点集中在如何使用C++语言来实现按照二叉树的结构形状进行打印。下面将详细介绍这一过程所涉及的理论知识和实现方法。 ### 知识点一：二叉树的概念 首先需要理解...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值