auf Panel zeichnen

[tahar]

moin,
ich versuche einen SchwarzRotBaum aufm Panel darzustellen, dafür funktioniert das Algorithm wenn ich mit System.out.println debuge, aber aufm Panel zeichne ich jedes mal vom Root bis zum letzen Knoten, das macht die Methode refresh ,die repaint ruft um einen Knoten als kreis mit einer Zahl in der mitte und eine linie zwischen den Knoten. aber auf Panel zeichnet nicht richtig.
wie kann ich es richtig machen

ich danke euch.

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;

import javax.swing.BorderFactory;
import javax.swing.JPanel;


public class Draw extends JPanel{
	
	
	private int x,y,h,abstand; //Position
	private String data;
	private Color farbe;
	private boolean isRoot;
			
	public Draw(String data){
		this.setPreferredSize(new Dimension(1200,getSize().height-40));
		this.setBorder(BorderFactory.createMatteBorder(4, 4, 4, 4, Color.black));
		this.data = data;
		
	}
	
	public void refrech(Knoten n){
		
		x = n.getX();
		y = n.getY();
		System.out.println("x: "+x+" y: "+y+" elt "+n.getData());
		data = ""+n.getData();
		abstand = n.getlORr()*n.getAbstand();
		farbe = n.getFarbe();
		isRoot = Baum.isRoot;
		h = Baum.h;
		
		repaint();//REPAINT
		//revalidate();
		int a = x-abstand+15,b = y-h+30, c =x+15;
		System.out.println(data+" x1 "+a+" y1 "+b+" x2 "+c+" y2 "+y);
		
		if(n.linkesKind != null){
			
			n = n.linkesKind;
			System.out.println("iflinkrefrech "+n.getData()+" "+n.getX()+","+n.getY()+" "+n.getFarbe());
			refrech(n);
		}
		if(n.rechtesKind != null){
			
			n = n.rechtesKind;
			System.out.println("ifrechtrefrech "+n.getData()+" "+n.getX()+","+n.getY()+" "+n.getFarbe());
			refrech(n);
		}
	}
	
	
	public void paintComponent(Graphics g){
			
			if(Baum.neuElt ){
				g.setColor(farbe);
				g.fillOval(x, y, 30, 30);
				g.setColor(Color.WHITE);
				g.drawString(data, x+10, y+10);
				if(!isRoot){
					g.setColor(Color.black);
					g.drawLine(x-abstand+15, y-h+30, x+15, y);
				}
			}
	}
	
}

 

[bERt0r]

Du solltest die paintComponent Methode nicht rekursiv Verwenden, die wird nämlich vom der JVM selber ziemlich oft aufgerufen, dadurch kannst du da nicht sehr viel steuern. Besser wäre eine Methode void draw(Graphics g, Knoten n) welche du im paintComponent mit der Wurzel aufrufst und dann rekursiv auf das Graphics die Knoten zeichnet.
Es heißt übrigens refresh

 

[tahar]

dankeschön es geklappt,
ich hätte gerne noch das allte Zeichen ausm Panel löschen mit removeAll() hat s nicht funktioniert,
und obwohl ich in Applet klasse validate() habe verschwendet ein Teil des Zeichens wenn das Fenster hide, wie kann ich das Problem lösen.

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;

import javax.swing.BorderFactory;
import javax.swing.JPanel;


public class Draw extends JPanel{
	
	private int x,y,h,abstand; //Position
	private String data;
	private Color farbe;
	private boolean isRoot;
			
	public Draw(String data){
		this.setPreferredSize(new Dimension(1200,getSize().height-40));
		this.setBorder(BorderFactory.createMatteBorder(4, 4, 4, 4, Color.black));
		this.data = data;
	}
	
	public void draw(Graphics g, Knoten n){
		
		if(n != null){
			x = n.getX();
			y = n.getY();
			data = ""+n.getData();
			abstand = n.getlORr()*n.getAbstand();
			farbe = n.getFarbe();
			isRoot = Baum.isRoot;
			h = Baum.h;
			
			g.setColor(farbe);
			g.fillOval(x, y, 30, 30);
			g.setColor(Color.WHITE);
			g.drawString(data, x+10, y+10);
			
			if(!isRoot){
				g.setColor(Color.black);
				g.drawLine(x-abstand+15, y-h+30, x+15, y);
			}

			draw(g,n.linkesKind);
			draw(g,n.rechtesKind);
		}
	}
	
	public void paintComponent(Graphics g){
		if(Baum.neuElt ){
			Knoten n = SchwarzRotAlg.rootOfTree;
			draw(g,n );
		}
	}
	
}

Edit:
ja bei zweitem Problem habe ich mit dem überschreiben der Methode update(Graphics){g.clearRec ,dann paint()}. bleibt aber das löschen des Fensters vor dem neu Zeichen, leider clearRec hat nicht geholfen.

 

[L-ectron-X]

Versuchs mal so:

    public void paintComponent(Graphics g){
        super.paintComponent(g);
        if(Baum.neuElt ){
            Knoten n = SchwarzRotAlg.rootOfTree;
            draw(g,n );
        }
    }

 

[tahar]

danke , es hat mir viel geholfen. so ist das Applet fertig
hier das fertige Code.

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;




import javax.swing.JApplet;
import javax.swing.JButton;
import javax.swing.JPanel;
import javax.swing.JTextField;

public class Baum extends JApplet 
{
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;

	static int x,y,abstand,h;
	static String elt;
	static boolean neuElt;
	JPanel panel;
	static Draw node;
	SchwarzRotAlg alg;
	static Knoten knoten;
	static Color farbe;
	JTextField eingabe;
	JButton einfuegen;
	
	public void init() {
		
		setSize(1200,600);
		setLayout(new BorderLayout());
		panel = new JPanel();
		panel.setPreferredSize(new Dimension(getSize().width,40));
		eingabe = new JTextField("",3);
		einfuegen = new JButton("Einf\u00fcgen");
		panel.add(eingabe);
		panel.add(einfuegen);
		getContentPane().add(panel,BorderLayout.SOUTH);
		node = new Draw("");
		getContentPane().add(node,BorderLayout.CENTER);
		alg = new SchwarzRotAlg();
		knoten = new Knoten();
		einfuegen.addActionListener(new ActionListener(){
			public void actionPerformed(ActionEvent e){
							
								try{
									elt = eingabe.getText();
									
									if(!elt.equals("")){
										neuElt = true;
										SchwarzRotAlg.Einfuegen(elt);
										if(SchwarzRotAlg.Draw){ //das eingefügte Element ist auf baum vorhanden dann nix machen
											node.repaint();
											node.revalidate();
											validate();
										}
									}
								}catch (Exception ex){
									ex.printStackTrace();
								}
			}
		});
	}
}

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Image;

import javax.swing.BorderFactory;
import javax.swing.JPanel;
import javax.swing.RepaintManager;


public class Draw extends JPanel{
	
	private int x,y,h,abstand; //Position
	private String data;
	private Color farbe;
	Image offscreen;
	Graphics bf;
			
	public Draw(String data){
		this.setPreferredSize(new Dimension(1200,getSize().height-40));
		this.setBorder(BorderFactory.createMatteBorder(4, 4, 4, 4, Color.black));
		this.data = data;
	}
	
	public void draw(Graphics g, Knoten n){
		if(n != null){
			x = n.getX();
			y = n.getY();
			data = ""+n.getData();
			abstand = n.getlORr()*n.getAbstand();
			farbe = n.getFarbe();
			h = Baum.h;
			
			g.setColor(farbe);
			g.fillOval(x, y, 30, 30);
			g.setColor(Color.WHITE);
			g.drawString(data, x+8, y+15);
			
			if(n.vater != null){
				g.setColor(Color.black);
				g.drawLine(x-abstand+15, y-h+30, x+15, y);
			}

			draw(g,n.linkesKind);
			draw(g,n.rechtesKind);
		}
	}
	
	public void update(Graphics g){
		paint(g);
	}
	
	public void paintComponent(Graphics g){
		super.paintComponent(g);
		if(Baum.neuElt ){
			Knoten n = SchwarzRotAlg.rootOfTree;
			draw(g,n );
		}
	}
	
}

import java.awt.Color;


public class  Knoten{
	
	private int x , y;
	private int ebene ,abstand;
	int lORr; // link oder Recht
	private int elt;
	private Color farbe;
	Knoten linkesKind , rechtesKind , vater;
	
	public Knoten(){
		farbe = Color.red;
		linkesKind = null;
		rechtesKind = null;
	}
	public Knoten(String nill){
		farbe = Color.black;
		linkesKind = null;
		rechtesKind = null;
	}
	
	public int comp(int elt){
		return (this.elt< elt ? 1 :this.elt > elt ? -1 : 0);
	}
	
	public void setPosition(int x, int y){
		this.x = x;
		this.y = y;
	}
	public void setFarbe(Color color){
		this.farbe = color;
		
	}
	public void setData(int data){
		this.elt = data;
	}
	public void setAbstand(int abstand){
		this.abstand = abstand;
	}
	public void setEbene(int ebene){
		this.ebene = ebene;
	}
	public void setVater(Knoten n){
		vater = n;
	}
	public Knoten getVater(){return vater;}
	public Knoten grandparent() {
	     return this.vater.vater;
	 }
	public Knoten uncle() {
		
	     return (this.vater == this.grandparent().linkesKind) ? this.grandparent().rechtesKind : this.grandparent().linkesKind;
	 }
	public void setlORr(int i){lORr = i;}
	public int getlORr(){return lORr;}
	public void copy(Knoten s){
		this.setPosition(s.getX(), s.getY());
		this.ebene = s.getEbene();
		this.abstand = s.getAbstand();
		this.elt = s.getData();
		this.farbe = s.getFarbe();
	}

	public int getX(){return x;}
	public int getY(){return y;}
	public Color getFarbe(){return farbe;}
	public int getData(){return elt;}
	public int getEbene(){return ebene;}
	public int getAbstand(){return abstand;}
	public boolean isRedNode(){
		return (farbe == Color.red ? true : false);
	}
	

}

import java.awt.Color;
import java.util.Iterator;
import java.util.Vector;



/**
 * SchwarzRotAlg ist zum Sortieren anhand Schwarz_Rot_Baum Algorithmus
 */
public class SchwarzRotAlg {
	
	private static int x;
	private static int y;
	static Knoten node,knoten;
	static Knoten rootOfTree;
	static int ebene,abstand,hoehe;
	static boolean Draw;
	
	
	public SchwarzRotAlg(){
		x = 500;
		y = 10;
		ebene = 1;
		abstand = 500;
		hoehe = 80;
		node = null;
		rootOfTree = null;
		
	}
	/**
	 * Fügt einen Knoten zum Baum, zuerst sucht die Stelle zum Einfügen in der While-Schleife
	 * und merkt der Vater des einfügenden roten Knoten in der Variable hilfsVar.
	 * je nach der stelle links oder recht ruft die Methode positionLinks oder positionRechts
	 * 
	 * @param data: die zum Einfügen Zahl als ZeichenKette
	 */
	static void Einfuegen(String data){
		int elt = Integer.parseInt(data);
		Knoten hilfsVar = null;
		if(rootOfTree != null){
			node = rootOfTree;
			hilfsVar = node;
			while (node != null && hilfsVar.comp(elt)!= 0){
				hilfsVar = node;
				if (elt < node.getData()) node = node.linkesKind;
				else if(elt > node.getData()) node = node.rechtesKind;
			}
			switch(hilfsVar.comp(elt)){
			case -1:
				Draw = true;
				hilfsVar.linkesKind = new Knoten();
				hilfsVar.linkesKind.setData(elt);
				hilfsVar.linkesKind.setVater(hilfsVar);
				positionLinks(hilfsVar);
				
				Baum.abstand = -1;
				Baum.h = hoehe;
				knoten = hilfsVar.linkesKind;
				break;
			case 0:
				Draw = false;
				break;
			case 1:
				Draw = true;
				hilfsVar.rechtesKind = new Knoten();
				hilfsVar.rechtesKind.setData(elt);
				hilfsVar.rechtesKind.setVater(hilfsVar);
				positionRechts(hilfsVar);
				
				Baum.abstand = 1;
				Baum.h = hoehe;
				knoten = hilfsVar.rechtesKind;
				break;
			}
		}
		else{// Root einfügen
			Draw = true;
			hilfsVar = new Knoten();
			hilfsVar.setVater(null);
			hilfsVar.setData(elt);
			hilfsVar.setFarbe(Color.black);
			hilfsVar.setAbstand(abstand);
			hilfsVar.setPosition(x, y);
			rootOfTree = hilfsVar;
			knoten = rootOfTree;
		}
		if(Draw){
			insert_case1(knoten);
			refresh(rootOfTree);
		}
	}
	
	
	/**
	 * positionLinks rechnet für das Applet die Position x,y,ebene,abstand (abstand zum BruderKnoten)
	 * des nach links einfügenden Knoten aus die Position
	 * vom VaterKnoten, in der Fall die Variable des Knoten links_OR_recht  lORr=-1.
	 * @param s : VaterKnoten des nach links einfügenden Knoten
	 */
	private static void positionLinks(Knoten s){
		if(s.linkesKind != null){
			ebene = s.getEbene()+1;
			s.linkesKind.setEbene(ebene);
			abstand = s.getAbstand()/2;
			s.linkesKind.setAbstand(abstand);
			x = s.getX() - abstand;
			y = s.getY() + hoehe;
			s.linkesKind.setPosition(x, y);
			s.linkesKind.setlORr(-1);
		}
	}
	
	
	/**
	 * positionRechts rechnet für das Applet die Position x,y,ebene,abstand (abstand zum BruderKnoten) 
	 * des nach rechts einfügenden Knoten aus die Position
	 * vom VaterKnoten, in der Fall die Variable des Knoten links_OR_recht lORr=1.
	 * @param s: VaterKnoten des nach rechts einfügenden Knoten
	 */
	private static void positionRechts(Knoten s){
		if(s.rechtesKind != null){
			ebene = s.getEbene()+1;
			s.rechtesKind.setEbene(ebene);
			abstand = s.getAbstand()/2;
			s.rechtesKind.setAbstand(abstand);
			x = s.getX() + abstand;
			y = s.getY() + hoehe;
			s.rechtesKind.setPosition(x, y);
			s.rechtesKind.setlORr(1);
		}
	}
	
	/**
	 * nach den Rotationen rechnet die Methode die koordinaten der Knoten, weil sie ihre Positionen ändern
	 * für jeden Knoten werden seine Koordnaten aus dessen Vater s Koordinaten berechnet
	 * @param vater: der vaterKnoten  
	 */
	private static void refresh(Knoten vater){
		if(vater != null){
			positionLinks(vater);
			positionRechts(vater);
			refresh(vater.linkesKind);
			refresh(vater.rechtesKind);
		}
	}
	
	/**
	 * Prüft ob der Vater eines roten Knoten null ist.
	 * wenn es der Fall wäre, färbte diesen roten Knoten schwarz und setzte ihn als root des Baums.
	 * anders Fall ruft sie die Methode insert_case2
	 * @param n: roter Knoten
	 */
	public static void insert_case1(Knoten n) {
		System.out.println("insert_case1");
	     if (n.vater == null){
	         n.setFarbe(Color.black);
	         rootOfTree = n;
	     }
	     else
	         insert_case2(n);
	 }
	
	
	/**
	 * Prüft ob der Vater eines roten Knoten schwarz oder rot
	 * wenn der Vater schwarz wäre, ist alles OK
	 * wenn er rot ist, ruft sie die Methode insert_case3
	 * 
	 * @param n: roter Knoten
	 */

	static void insert_case2(Knoten n) {
		System.out.println("insert_case2");
	     if (n.vater.getFarbe() == Color.black){
	    	 return;
	     }
	     else
	         insert_case3(n);
	 }
	
	
	/**
	 * Prüft of der roten Knoten einen roten Onkel hat
	 * wenn ja: der Vater und der Onkel werden Schwarz, der Großvater aber rot,
	 * 			und ruft die Methode insert_case1 mit Großvater als eingabeparameter
	 * wenn nein: ruft sie die Methode insert_case4 
	 * 
	 * @param n: roter Knoten
	 */
 	static void insert_case3(Knoten n) {
		System.out.println("insert_case3");
		 if (n.uncle() != null && n.uncle().getFarbe() == Color.red) {
	         n.vater.setFarbe(Color.black) ;
	         n.uncle().setFarbe(Color.black);
	         n.grandparent().setFarbe(Color.red);
	         //Baum.node.repaint();
	         insert_case1(n.grandparent());
	     }
	     else
	         insert_case4(n);
	 }
 	
 	/**
 	 * fall 1.knoten ist rechts am vater und vater links am großvater
 	 * 			rotate_left mit dem Vater als Eingabeparameter und setzt n mit seinem linken Kind ein
 	 * fall 2.knoten ist links am vater und vater rechts am großvater
 	 * 			rotate_right mit dem Vater als Eingabeparameter und setzt n mit seinem rechten Kind ein
 	 * zum Schluß ruft insert_case5 mit dem Eingabeparameter n
 	 * 
 	 * @param n: roter Knoten
 	 */
	static void insert_case4(Knoten n) {
		System.out.println("insert_case4");
	     if (n == n.vater.rechtesKind && n.vater == n.grandparent().linkesKind) {
	         rotate_left(n.vater);
	         n = n.linkesKind;
	     } 
	     else if (n == n.vater.linkesKind && n.vater == n.grandparent().rechtesKind) {
	         rotate_right(n.vater);
	         n = n.rechtesKind;
	     }
	     insert_case5(n);
	 }
	
	/**
	 * macht den Vater schwarz , der Großvater rot und 
	 * wenn knoten links am vater ist und vater links am großvater, rechte Rotation vom Großvater
	 * wenn knoten rechts am vater ist und vater rechts am großvater, linke Rotation vom Großvater 
	 * 		
	 * @param n: roter Knoten
	 */
	static void insert_case5(Knoten n) {
		System.out.println("insert_case5");
		 n.vater.setFarbe(Color.black);
	     n.grandparent().setFarbe(Color.red);
	     if (n == n.vater.linkesKind && n.vater == n.grandparent().linkesKind) 
	         rotate_right(n.grandparent());
	     else 
	         rotate_left(n.grandparent());
	 }
	
	/**
	 * Rotation links
	 * 
	 * @param n : roter Knoten
	 */
	static void rotate_left(Knoten n){
		System.out.println("rotate_left");
		Knoten y = n.rechtesKind;
		if(y.linkesKind != null){
			n.rechtesKind = y.linkesKind;
			y.linkesKind.setVater(n);
		}
		else n.rechtesKind = null; 
		y.setVater(n.vater);
		if(n.vater == null){
			y.setFarbe(Color.black); /// Root
			rootOfTree = y;
			y.setPosition(n.getX(), n.getY());
			y.setAbstand(n.getAbstand());
		}
		else if(n == n.vater.linkesKind)
			n.vater.linkesKind = y;
		else
			n.vater.rechtesKind = y;
			
		y.linkesKind = n;
		n.setVater(y);
	}
	
	/**
	 * Rotation recht
	 * 
	 * @param n : roter Knoten
	 */
	
	static void rotate_right(Knoten n){
		System.out.println("rotate_right");
		Knoten y = n.linkesKind;
		
		if(y.rechtesKind != null){
			n.linkesKind = y.rechtesKind;
			y.rechtesKind.setVater(n);
		}
		else n.linkesKind = null;
		
		y.setVater(n.vater);
		if(n.vater == null){
			y.setFarbe(Color.black); /// Root
			rootOfTree = y;
			y.setPosition(n.getX(), n.getY());
			y.setAbstand(n.getAbstand());
		}
		else if(n == n.vater.rechtesKind)
			n.vater.rechtesKind = y;
		else
			n.vater.linkesKind = y;
					
		y.rechtesKind= n;
		n.setVater(y);
	}

}