demo.java

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

import java.awt.*;
public class Demo extends Canvas 
{	
	private final int NO_START	=-1;
	private final int HAS_START	=0;
	private final int HAS_OVER	=1;	
	
	
	private final int	BX		=20;
	private final int   BY		=20;		
	private		  int   DX		=30;		
	private final int   DY		=15;
	private final int	WIDTH	=20;
	private final int   HEIGHT	=30;
	
	private int		m_nNum;
	private int		m_nIIndex;
	private int		m_nJIndex;
	
	private int		m_nLast;
	private int		m_nCur;

	
	
	private String	m_sOldData;
	private char[]	m_sData		=new char [12];
	
	private int		m_nStatus	=NO_START;
	private boolean m_bSortType	=true;
	
	private Graphics	m_Graph;
	private Graphics	m_offG;
	private Image		m_offImg;
	
	
	
	
		
	public void setData(String sData,boolean bool)
	{
		
		m_sOldData	=sData;	
		m_bSortType	=bool;
		
		m_nStatus	=NO_START;
		
		m_nNum		=m_sOldData.length ();
		m_sData[0]	=0x20;
		if(m_nNum!=0)
			DX		=300/m_nNum;
		else
			DX=300;
		
		for(int i=1;i<=m_nNum;i++)
			m_sData[i]=sData.charAt (i-1);
		
		m_nLast		=0;
		m_nJIndex	=0;
		m_nIIndex	=0;
	
		m_nCur		=0;
	
		if(m_Graph==null) m_Graph=getGraphics();
	}
	private boolean compare(char ch1,char ch2)
	{
		if(m_bSortType)
			return(ch1<ch2);
		return(ch1>ch2);		
	}
	public void init()
	{
		setData("",true);		
		m_Graph.clearRect (0,0,getSize().width ,getSize().height);
	}	
	public int proceed(int nStep)
	{
		int nextStep=-1;
		int j=0;
		switch(nStep)
		{
				case -1://draw the init data
						m_nStatus	=HAS_START;
						nextStep	=0;
						break;				
				case 0:	//draw the init data and sorting data
						nextStep	=2;
						m_nIIndex	=-1;
						break;								   
				case 2://
						m_nIIndex	=m_nNum;
						nextStep	=3;
						break;
				case 3://
						if(m_nIIndex<=1)
							nextStep=14;
						else
							nextStep=5;
						break;			
				case 5://
						m_nLast		=1;	
						m_nJIndex	=0;
						nextStep	=6;
						break;
				case 6:
						m_nJIndex++;
						if(m_nJIndex<m_nIIndex)
							nextStep=7;						
						else
							nextStep=12;
						break;
				case 7:	j			=m_nJIndex;
						for(int i=0;i<3;i++)
						{
							drawNode(m_sData[j],j,10,Color.red ,Color.yellow ,getGraphics());
							drawNode(m_sData[j+1],j+1,10,Color.red ,Color.yellow ,getGraphics());					
							delay(120);
							drawNode(m_sData[j],j,10,Color.cyan ,Color.yellow ,getGraphics());
							drawNode(m_sData[j+1],j+1,10,getBackground() ,Color.yellow ,getGraphics());					
							delay(120);					
						}
						if(compare(m_sData[j+1],m_sData[j]))
							nextStep=9;
						else
							nextStep=11;						
						break;				
				case 9:
						//swap
						swapNode(m_nJIndex,Color.lightGray ,Color.yellow );
						
						j			=m_nJIndex;
						char ch		=m_sData[j];
						m_sData[j]	=m_sData[j+1];
						m_sData[j+1]=ch;
						nextStep	=10;
						break;
				case 10:
						m_nLast		=m_nJIndex;
						nextStep	=11;
						break;
				case 11:					
						nextStep	=6;
						break;
				case 12:
						m_nIIndex	=m_nLast;;
						nextStep	=13;
						break;
				case 13:
						nextStep	=3;						
						break;
				case 14:
						m_nStatus	=HAS_OVER;						
						nextStep	=-1;
						break;
		}
		repaint();
		return nextStep;		
	}	
	
	public void paint(Graphics g)
	{
		m_offG.clearRect (0,0,getSize().width ,getSize().height );
		switch(m_nStatus)
			{
				case NO_START://null paint 						
								break;			
				case HAS_START://draw init data
								drawData(false,m_offG);
								
								Color color;
								for(int i=1;i<m_nNum+1;i++)
								{
									if(m_nCur!=i)
									{
										if(i!=m_nIIndex&&i!=m_nJIndex) 
											color=Color.black ;
										else 
											color=Color.yellow ;
										drawNode(m_sData[i],i,10,getBackground(),color,m_offG);
									}
								}													
								if(m_nIIndex>=2)
									drawArrow('i',m_nIIndex,10,Color.red,m_offG);							
								if(m_nJIndex>=1&&m_nJIndex<m_nIIndex)
									drawArrow('j',m_nJIndex,10,Color.red ,m_offG);
								
								g.drawImage (m_offImg,0,0,this);
								break;
			
				case HAS_OVER:	drawData(true,m_offG);			//draw init data
								g.drawImage (m_offImg,0,0,this);								
								break;			
			}		
	}
	
	public void update(Graphics g)
	{
		paint(g); 
	} 
	public void addNotify()
	{ 
		super.addNotify(); 
		m_offImg = createImage(getSize().width, getSize().height);
		m_offG = m_offImg.getGraphics(); 
	} 

	
	private void drawData(boolean bool,Graphics g)
	{
		g.drawString ("初始数据:",BX,BY);		
		Color bk=getBackground();				
		for(int i=0;i<m_sOldData.length ();i++)
		{
			drawNode(m_sOldData.charAt (i),i+1,1,bk,Color.black ,g);
		}			
		if(bool)
		{
			g.drawString ("排序结果:",BX,BY+DY*10-20);
			for(int i=1;i<m_nNum+1;i++)
				drawNode(m_sData[i],i,10,getBackground(),Color.black ,g);			
		}
	}
	
	
	private void drawNode(char ch,int i,int j,Color bkColor,Color fgColor,Graphics g)
	{	
		Color old=g.getColor ();			
		
		g.drawRect (BX+i*DX, BY+j*DY, WIDTH, HEIGHT);	
		
		g.setColor (bkColor);	
		g.fillRect (BX+i*DX+1, BY+j*DY+1, WIDTH-1, HEIGHT-1);			
		
		char c[]={' ',' '};	c[0]=ch;			
		g.setColor (fgColor)			;
		g.drawChars(c,0,1,BX+i*DX+WIDTH/3+1,BY+j*DY+HEIGHT*2/3);		
		g.setColor (old);			
	}
	private void drawNode(char ch,float i,float j,Color bkColor,Color fgColor,Graphics g)
	{	
		Color old=g.getColor ();			
		
		g.drawRect ((int)(BX+i*DX), (int)(BY+j*DY), WIDTH, HEIGHT);	
		
		g.setColor (bkColor);	
		g.fillRect ((int)(BX+i*DX+1), (int)(BY+j*DY+1), WIDTH-1, HEIGHT-1);			
		
		char c[]={' ',' '};	c[0]=ch;			
		g.setColor (fgColor)			;
		g.drawChars(c,0,1,(int)(BX+i*DX+WIDTH/3+1),(int)(BY+j*DY+HEIGHT*2/3));		
		g.setColor (old);			
	}
	public void drawArrow(char ch,int i,int j,Color color,Graphics g)
	{
		
		Color old=g.getColor ();
		g.setColor(color);
		char c[]={' ',' '};
		c[0]=ch;		
		int x=BX+i*DX+WIDTH/3+4;
		int y=BY+j*DY+HEIGHT+5;
		g.drawChars(c,0,1,x-8,y+15);			
		g.drawLine (x,y,x,y+25);		
		g.drawLine (x,y,x+2,y+5);
		g.drawLine (x,y,x-3,y+5);
		g.setColor (old);	
	}
	
	
	public void swapNode(int J,Color bkColor, Color fgColor)
	{
		Graphics g	=getGraphics();	
		Color	bk	=getBackground();	    		
		Color	old	=g.getColor();
		
		char	ch1	=m_sData[J];
		char	ch2	=m_sData[J+1];		
		int		y	=10;
					
		g.setColor (bk);					
		g.fillRect (BX+J*DX-1, BY+y*DY-1, WIDTH+2, HEIGHT+2);		
		g.setColor(old);
		drawNode(ch1,(float)(J+0.5),(float)(y-3),bk,fgColor,g);		
		delay(150);
		g.setColor (bk);
		g.fillRect (BX+(J+1)*DX-1, BY+y*DY-1, WIDTH+2, HEIGHT+2);				
		g.setColor (old);
		drawNode(ch2,J,y,bk,fgColor,g);
		delay(150);		
		g.setColor (bk);
		g.fillRect ((int)(BX+(J+0.5)*DX-1), (int)(BY+(y-3)*DY-1), WIDTH+2, HEIGHT+2);						
		g.setColor (old);
		drawNode(ch1,J+1,y,bk,fgColor,g);		
		delay(150);			

	}
	
	private void delay()
	{
		try{ Thread.sleep(80); }
		catch(InterruptedException e){}		
	}
	private void delay(int time)
	{
		try{ Thread.sleep(time); }
		catch(InterruptedException e){}
	}
}