demo.java

学习数据结构的最好辅助工具,快速帮助你熟悉数据结构的相关技术

import java.awt.*;
public class Demo extends Canvas
{
	private int sleepTime = 40;
	//private boolean dir = true;
	private int m_numNodes, m_numPointers = 0;
	private char m_pointerNames[], m_data[];
	private int m_pointerPos[];
	private int m_nodePointer[], m_nodeP;
	private int m_pointerPlace[];
	static final int NullPointer = 99999;
	private int m_pointerMoving;
	private int m_deletedNode = 0, m_deletedP = NullPointer, m_delNodePos;
	private boolean m_deleting = false;
	
	public Demo(int n, char data[])
	{
		m_numNodes = n;
		m_data = data;
		m_pointerNames = new char[5];
		m_pointerPos = new int[5];
		m_nodePointer = new int[m_numNodes+1];
		m_pointerPlace = new int[5];
		for(int i=0; i<m_numNodes; i++) m_nodePointer[i] = 0;
		m_nodePointer[m_numNodes] = NullPointer; // tail pointer
	}
	
	public void reset(int n)
	{
		m_numNodes = n;
		m_numPointers = 0;
		m_pointerMoving = NullPointer;
		m_nodeP = NullPointer;
		for(int i=0; i<m_numNodes; i++) m_nodePointer[i] = 0;
		m_nodePointer[m_numNodes] = NullPointer; // tail pointer
		m_deletedNode = 0;
		m_deletedP = NullPointer;
		m_deleting = false;
		repaint();
	}
	
	public void addPointer(char pointerName)
	{
		m_pointerNames[m_numPointers] = pointerName;
		m_pointerPos[m_numPointers] = 0;
		m_pointerPlace[m_numPointers] = 250/m_numNodes;
		m_numPointers++;
		repaint();
	}
	
	public void addPointer(char newP, char oldP)
	{
		int i=0;
		while( m_pointerNames[i] != oldP ) i++;
		m_pointerNames[m_numPointers] = newP;
		m_pointerPos[m_numPointers] = m_pointerPos[i]+1;
		m_pointerPlace[m_numPointers] = (m_pointerPos[m_numPointers]+1) * 250/m_numNodes;
		m_numPointers++;
		repaint();
	}
	
	public int movePointer(char pointerName)
	{
		int i=0;
		while( m_pointerNames[i] != pointerName ) i++;
		m_pointerMoving = i;
		m_pointerPos[i]++;
		repaint();
		if(m_pointerPos[i] <= m_numNodes) return m_pointerPos[i];
		return NullPointer;
	}
	
	public char getData(char p)
	{
		int i=0;
		while( m_pointerNames[i] != p ) i++;
		return m_data[m_pointerPos[i]-1];
	}
	
	public void setPointer(char p1, char p2)
	{
		int i=0, j=0;
		while( m_pointerNames[i] != p1 ) i++;
		while( m_pointerNames[j] != p2 ) j++;
		if(m_pointerPos[j]<m_numNodes) m_nodePointer[m_pointerPos[i]] = m_pointerPos[j]+1;
		else m_nodePointer[m_pointerPos[i]] = NullPointer;
		repaint();
	}
	
	public void deletePointer(char p)
	{
		int i=0;
		while( m_pointerNames[i] != p ) i++;
		m_deletedP = i;
		m_deletedNode = m_pointerPos[i];
		m_delNodePos = 3;
		m_deleting = true;
		repaint();
	}
	
	public void paint(Graphics p1)
	{
		int baseline = 125;
		// draw head node
		int d = 250/m_numNodes;
		p1.drawRect(d-15, baseline-10, 30, 20);
		p1.drawLine(d, baseline-10, d, baseline+10);
		if( m_nodePointer[0] == 0 )
		{
			p1.drawLine( d+5, baseline, 2*d-15, baseline );
			p1.drawLine( 2*d-15, baseline, 2*d-20, baseline-5 );
			p1.drawLine( 2*d-15, baseline, 2*d-20, baseline+5 );
		}
		else if( m_nodePointer[0] < NullPointer )
		{
			p1.drawLine( d+5, baseline, d+20, baseline );
			p1.drawLine( d+20, baseline, d+20, baseline+40 );
			int x = (m_nodePointer[0]+1) * d - 7;
			p1.drawLine( d+20, baseline+30, x, baseline+40 );
			p1.drawLine( x, baseline+40, x, baseline+10 );
			p1.drawLine( x, baseline+10, x-5, baseline+15 );
			p1.drawLine( x, baseline+10, x+5, baseline+15 );
		}
		
		// draw other nodes
		for(int i=1;i<=m_numNodes;i++)
		{
			int x = d * (i+1);
			if(i!=m_deletedNode)
			{
				p1.drawRect(x-15, baseline-10, 30, 20);
				p1.drawChars(m_data, i-1, 1, x-10, baseline+5);
				p1.drawLine(x, baseline-10, x, baseline+10);
				if( m_nodePointer[i] == 0 )
				{
					p1.drawLine( x+5, baseline, x+d-15, baseline );
					p1.drawLine( x+d-15, baseline, x+d-20, baseline-5 );
					p1.drawLine( x+d-15, baseline, x+d-20, baseline+5 );
				}
				else if( m_nodePointer[i] < NullPointer )
				{
					p1.drawLine( x+5, baseline, x+20, baseline );
					p1.drawLine( x+20, baseline, x+20, baseline+40 );
					int y = (m_nodePointer[i]+1) * d - 7;
					p1.drawLine( x+20, baseline+40, y, baseline+40 );
					p1.drawLine( y, baseline+40, y, baseline+10 );
					p1.drawLine( y, baseline+10, y-5, baseline+15 );
					p1.drawLine( y, baseline+10, y+5, baseline+15 );
				}
			}
			else if(m_deleting)
			{
				p1.drawRect(x-15, baseline-m_delNodePos-10, 30, 20);
				p1.drawChars(m_data, i-1, 1, x-10, baseline-m_delNodePos+5);
				p1.drawLine(x, baseline-m_delNodePos-10, x, baseline-m_delNodePos+10);
			}
		}
			
		// draw pointers
		for(int i=0; i<m_numPointers; i++)
		{
			int x = m_pointerPlace[i];
			if(i!=m_deletedP)
			{
				p1.drawLine(x-10, baseline-30, x-10, baseline-10);
				p1.drawChars(m_pointerNames, i ,1, x-10, baseline-34);
				p1.drawLine(x-10, baseline-10, x-15, baseline-15);
				p1.drawLine(x-10, baseline-10, x-5, baseline-15);
			}
			else if(m_deleting)
			{
				p1.drawLine(x-10, baseline-m_delNodePos-30, x-10, baseline-m_delNodePos-10);
				p1.drawChars(m_pointerNames, i ,1, x-10, baseline-m_delNodePos-34);
				p1.drawLine(x-10, baseline-m_delNodePos-10, x-15, baseline-m_delNodePos-15);
				p1.drawLine(x-10, baseline-m_delNodePos-10, x-5, baseline-m_delNodePos-15);
			}
		}
		
		// handle pointer movement
		if(m_pointerMoving != NullPointer)
		{
			m_pointerPlace[m_pointerMoving] += 3;
			if( m_pointerPlace[m_pointerMoving] >=
				(m_pointerPos[m_pointerMoving]+1) * 250/m_numNodes )
			{
				m_pointerPlace[m_pointerMoving] =
				(m_pointerPos[m_pointerMoving]+1) * 250/m_numNodes;
				m_pointerMoving = NullPointer;
			}
			try
			{
				Thread.sleep( sleepTime );
			}
			catch(InterruptedException e){}
			repaint();
		}
		// handel pointer destroying
		else if(m_deleting)
		{
			m_delNodePos += 3;
			if(m_delNodePos>50) m_deleting = false;
			try
			{
				Thread.sleep( sleepTime );
			}
			catch(InterruptedException e){}
			repaint();
		}
	}
}