23.-29.11 baum tiefe, huffmann

diese woche haben wir die methode getTiefe(), die die tiefe eines binärbaums feststellt implementiert,

und das Huffmann vefahren untersucht bzw. bearbeitet

schwierigkeiten gab es bei mir hier nur bei den beweisen

16.-22.11 binärbaum

diese woche haben wir uns mit dem binärbaum beschäfftigt

public class BinTree
{
  protected Object rootItem = null;

  protected BinTree right = null;
  protected BinTree left = null;

  public BinTree()
  {
  }

  public BinTree(Object o)
  {
    this.setRootItem(o);
    this.setLeftTree(new BinTree());
    this.setRightTree(new BinTree());
  }

  public BinTree(Object o, BinTree l, BinTree r)
  {
    this.setRootItem(o);
    this.setLeftTree(l);
    this.setRightTree(r);
  }

  public boolean isEmpty()
  {
    return (this.getRootItem() == null && this.getLeftTree() == null && this.getRightTree() == null);
  }

  public void clear()
  {
    this.setRootItem(null);
    this.setLeftTree(null);
    this.setRightTree(null);
  }

  public void setRootItem(Object o)
  {
    this.rootItem = o;
  }

  public Object getRootItem()
  {
    return this.rootItem;
  }

  public void setLeftTree(BinTree t)
  {
    this.left = t;
  }

  public BinTree getLeftTree()
  {
    return this.left;
  }

  public void setRightTree(BinTree t)
  {
    this.right = t;
  }

  public BinTree getRightTree()
  {
    return this.right;
  }
}

und der variante des morsebaumsmit co und decodierung

public class MorseCodierer{

  // Anfang Attribute
    BinTree morsebaum;
  // Ende Attribute

    public MorseCodierer(){
      BinTree lBaum4Links = new BinTree(new Character('H'));
      BinTree lBaum4Rechts = new BinTree(new Character('V'));
      BinTree lBaum3Links = new BinTree(new Character('S'),lBaum4Links, lBaum4Rechts);
      lBaum4Links = new BinTree(new Character('F'));
      lBaum4Rechts = new BinTree(new Character('#'));
      BinTree lBaum3Rechts = new BinTree(new Character('U'), lBaum4Links, lBaum4Rechts);
      BinTree lBaum2Links = new BinTree(new Character('I'), lBaum3Links, lBaum3Rechts);
      lBaum4Links = new BinTree(new Character('L'));
      lBaum4Rechts = new BinTree(new Character('#'));
      lBaum3Links = new BinTree(new Character('R'), lBaum4Links, lBaum4Rechts);
      lBaum4Links = new BinTree(new Character('P'));
      lBaum4Rechts = new BinTree(new Character('J'));
      lBaum3Rechts = new BinTree(new Character('W'), lBaum4Links, lBaum4Rechts);
      BinTree lBaum2Rechts = new BinTree(new Character('A'), lBaum3Links, lBaum3Rechts);
      BinTree lBaum1Links = new BinTree(new Character('E'), lBaum2Links, lBaum2Rechts);
      lBaum4Links = new BinTree(new Character('B'));
      lBaum4Rechts = new BinTree(new Character('X'));
      lBaum3Links = new BinTree(new Character('D'), lBaum4Links, lBaum4Rechts);
      lBaum4Links = new BinTree(new Character('C'));
      lBaum4Rechts = new BinTree(new Character('Y'));
      lBaum3Rechts = new BinTree(new Character('K'), lBaum4Links, lBaum4Rechts);
      lBaum2Links = new BinTree(new Character('N'), lBaum3Links, lBaum3Rechts);
      lBaum4Links = new BinTree(new Character('Q'));
      lBaum4Rechts = new BinTree(new Character('Z'));
      lBaum3Links = new BinTree(new Character('G'), lBaum4Links, lBaum4Rechts);
      lBaum4Links = new BinTree(new Character('#'));
      lBaum4Rechts = new BinTree(new Character('#'));
      lBaum3Rechts = new BinTree(new Character('O'),lBaum4Links, lBaum4Rechts);
      lBaum2Rechts = new BinTree(new Character('M'), lBaum3Links, lBaum3Rechts);
      BinTree lBaum1Rechts = new BinTree(new Character('T'), lBaum2Links, lBaum2Rechts);
      morsebaum = new BinTree(new Character('#'), lBaum1Links, lBaum1Rechts);
    }

  // Anfang Methoden
    public BinTree getTree(){
      return morsebaum;
    }

    public String codierterText(String pText) {
      pText = pText.toUpperCase();
      String code = new String();

      for (int i = 0; i < pText.length(); i++) {
        code += codiere(pText.charAt(i), "", morsebaum) + "/";
      }

      return (code + "/");
    }

    private String codiere(char pChar, String pString, BinTree pTree) {
      if (pTree.isEmpty()) {
        return "";
      } else if (pTree.getRootItem().equals(pChar)) {
        return pString;
      }

      String gefunden = codiere(pChar, (pString + "."), pTree.getLeftTree());

      if (gefunden.equals("")) {
        gefunden = codiere(pChar, (pString + "-"), pTree.getRightTree());
      }

      return gefunden;
    }

    public String decodierterText(String pCode) {
      String[] code = pCode.split("/");
      char[] buchstaben = new char[code language="".length""][/code][/code];

      for (int i = 0; i < code.length; i++) {
        buchstaben[i] = (decodiere(code[i], morsebaum).toCharArray())[0];
      }

      return (new String(buchstaben));
    }

    private String decodiere(String pString, BinTree pTree) {

      if (pString.length() == 0) return (pTree.getRootItem().toString());

      if (pString.substring(0,1).equals(".")) {
        return decodiere(pString.substring(1), pTree.getLeftTree());
      } else {
        return decodiere(pString.substring(1), pTree.getRightTree());
      }
    }

  // Ende Methoden
}

9.-15.11 die sortierte liste

diese woche heben wir uns mit einer sortierten version der liste beschäftigt

public class SortedList{
  List inhalt;

  public SortedList(){
     inhalt = new List();
  }

  public void sortInsert(String pInhalt){
     inhalt.toFirst();
     while(!inhalt.isBehind()&&pInhalt.compareToIgnoreCase((String)inhalt.getItem())>=0){
       inhalt.next();
     }
     inhalt.insertInFrontOf(pInhalt);
  }

  public boolean search(String pInhalt){
     inhalt.toFirst()
     while((inhalt.isBehind=!)&&(inhalt.getItem!=pInhalt)){
       inhalt.next();}
     if(inhalt.getItem()=pInhalt) return true;
     return false;

  }

  public void remove(String pInhalt){
    if(this.search(pInhalt)){
     Inhalt.remove();
      }//Quelltext erg�nzen
  }

  public void print(){
    inhalt.toFirst();
    while(!inhalt.isEmpty()&&!inhalt.isBehind()){
      System.out.println((String)inhalt.getItem());
      inhalt.next();
    }
  }

  public static void main(String[] args){
    SortedList liste=new SortedList();
    liste.print();
    liste.sortInsert("hallo");
    liste.sortInsert("wie");
    liste.sortInsert("geht");
    liste.sortInsert("es");
    liste.sortInsert("dir");
    liste.print();
    System.out.println(liste.search("es"));
    System.out.println(liste.search("di"));
    liste.remove("es");
    liste.remove("di");
    liste.print();
  }
}

2-8. 11listen verfeinerung

zusätzlich haben wir in dieser woche noch die liste so verfeinert das sie mit verschiedenen datentypen funktioniert

Kritik an der Aufgabenstellung zur List

Die in der Aufgabenstellung zum Abitur 2009 geforderte Umsetzung der Klasse List bittet eine Menge Platz für Kritik

• Der interne Positionszeiger in der Liste verkompliziert deren Gebrauch enorm und macht sie fast nicht nutzbar.
• Die Methode zum ersetzen eines Objekts ist nicht vorhanden und muss deswegen extern programmiert werden.
• Bei manchen Sorten der Implementierung  kommt es auch vor das ein Element zweckentfremdet wird.(Um als Randmarkierung benutzt zu werden)

1.11.09 list, queue

Diese Woche haben wir die Klasse Queue in 4er-Gruppen um einige Funktionen erweitert. Unsere Gruppe schrieb eine Funktion, die es ermöglichte, ein Objekt vor einem anderen im Queue einzureihen.
Hausaufgabe war es die Klasse Liste zu erstellen, die Julian und ich zusammen in 2 Freistunden erledigt haben.
Zusatz Code für die Queue:

Element suche (searchObject;erster);
}
public Element suche(Object searchObject;Element aktuell){
  if(aktuell==null)return null;
  if(aktuell=!null){
    if(aktuell.getInhalt()==searchObject){
      return aktuell;
    }
    suche (searchObject ;aktuell.getNext);
  }
}

das neue Element für die Liste

/*******************************\
  @Author   Conny, Jules
  @Class    Element
  @Project  List
  @Date     29.10.09, 15:16
\*******************************/

public class Element
{
  private Object data;
  private Element next;
  private Element prev;

  public Element(Object o)
  {
    data = o;
  }

  public Object getContent()
  {
    return this.data;
  }

  public void setContent(Object o)
  {
    this.data = o;
  }

  public Element getNext()
  {
    return this.next;
  }

  public Element getPrev()
  {
    return this.prev;
  }

  public void setNext(Element e)
  {
    this.next = e;
  }

  public void setPrev(Element e)
  {
    this.prev = e;
  }
}

und hier die Liste

/*******************************\
  @Author   Conny, Jules
  @Class    List
  @Project  List
  @Date     29.10.09, 15:16
\*******************************/

public class List
{
  private enum PointerState
  {
    PreList,
    PostList,
    InList
  }

  private Element first;
  private Element last;
  private Element current;
  private List.PointerState position;

  public List()
  {
    this.toFirst();
  }

  public boolean isEmpty()
  {
    return (this.first == null);
  }

  public boolean isInFrontOf()
  {
    if (this.current == null && this.position == PointerState.PreList)
    {
      return true;
    }

    return false;
  }

  public boolean isBehind()
  {
    if (this.current == null && this.position == PointerState.PostList)
    {
      return true;
    }

    return false;
  }

  public void next()
  {
    if (this.isEmpty() || this.isBehind())
       return;

    if (this.current.getNext() == null)
    {
      this.position = PointerState.PostList;
    }
    else
    {
      this.position = PointerState.InList;
    }

    this.current = this.current.getNext();
  }

  public void previous()
  {
    if (this.isEmpty() || this.isInFrontOf())
       return;

    if (this.current.getPrev() == null)
    {
      this.position = PointerState.PreList;
    }
    else
    {
      this.position = PointerState.InList;
    }

    this.current = this.current.getPrev();
  }

  public void toFirst()
  {
    if (this.isEmpty())
    {
       this.position = PointerState.PostList;
    }
    else
    {
      this.position = PointerState.InList;
      this.current = this.first;
    }
  }

  public void toLast()
  {
    if (this.isEmpty())
    {
       this.position = PointerState.PreList;
    }
    else
    {
      this.position = PointerState.InList;
      this.current = this.last;
    }
  }

  public Object getItem()
  {
    if (this.isEmpty() || this.position != PointerState.InList)
       return null;

    return this.current.getContent();
  }

  public void replace(Object o)
  {
    if (this.isEmpty() || this.position != PointerState.InList)
       return;

    this.current.setContent(o);
  }

  public void insertInFrontOf(Object o)
  {
    if (this.position == PointerState.PreList)
       return;

    Element n = new Element(o);

    if (this.position == PointerState.PostList)
    {
      n.setPrev(this.last);
      if (this.last != null)
      {
        this.last.setNext(n);
      }
    }
    else
    {
      n.setPrev(this.current.getPrev());
      if (this.current.getPrev() != null)
      {
         this.current.getPrev().setNext(n);
      }
    }

    n.setNext(this.current);

    if (this.current != null)
    {
      this.current.setPrev(n);
    }

    if (n.getPrev() == null)
    {
      this.first = n;
    }
    if (n.getNext() == null)
    {
      this.last = n;
    }
  }

  public void insertBehind(Object o)
  {
    if (this.position == PointerState.PostList)
       return;

    Element n = new Element(o);

    if (this.position == PointerState.PreList)
    {
      n.setNext(this.first);
      if (this.first != null)
      {
        this.first.setPrev(n);
      }
    }
    else
    {
      n.setNext(this.current.getNext());
      if (this.current.getNext() != null)
      {
         this.current.getNext().setPrev(n);
      }
    }

    n.setPrev(this.current);

    if (this.current != null)
    {
      this.current.setNext(n);
    }

    if (n.getPrev() == null)
    {
      this.first = n;
    }
    if (n.getNext() == null)
    {
      this.last = n;
    }
  }

  public void remove()
  {
    if (this.position != PointerState.InList)
       return;

    Element prev = this.current.getPrev();
    Element next = this.current.getNext();

    if (prev != null)
    {
      prev.setNext(next);
    }

    if (next != null)
    {
      next.setPrev(prev);
    }

    if (this.current == this.first)
    {
      this.first = next;
    }
    if (this.current == this.last)
    {
      this.last = prev;
    }

    this.current = next;
    if (this.current == null)
    {
      this.position = PointerState.PostList;
    }
  }

  public void addList(List l)
  {
    Element c = this.current;
    PointerState p = this.position;

    l.toFirst();
    this.toLast();

    while (!l.isEmpty())
    {
      this.insertBehind(l.getItem());
      this.next();
      l.remove();
    }

    l = null;

    this.current = c;
    this.position = p;
  }
}

doodle

dieses programmm am wir diese woche mit scratch geschrieben
nachreichung:
wir haben auch noch die Klasse Queue :

public class queue() {

  // Anfang Attribute
  private element erster;
  private element letzter;
  // Ende Attribute

  public queue(element erster, element letzter) {//construckto setzt erster und letzter auf null
    erster=null;
    letzter=null;
  }

  // Anfang Methoden
  public void enqueue(Object pObjekt) { // etwas anfügen
    Element neu=new Element(pObject); //das neu anzufügende element wird erzeugt
    if(!=isEmpty()){ //wenndie queue nicht leer ist:
      letzter.setNext(neu);// dann wird der zeiger vom letzten auf das neu elment gesetzt
      letzter=neu;// und das letzteelement wird zu neu
    }else{//ansonsten: werden erster und letzter zu neu
      letzter=neu;
      erster=neu;
    }
  }

  public void dequeue() {//ersten entfernen:
    if(!=isEmpty()){//wenn die queue nicht leer ist ,
      erster=erster.getNext();// dann wird erster zu dem worauf sein zeiger zeigt
    }
  }

  public boolean isEmpty() {
    return erster.getinhalt!=null;// uberprüfung obetwas im queue ist
  }

  public void front() {// auslesung des inhalts des ersten
    if(!=isEmpty()){
      erster.getinhalt();
    }
  }

  // Ende Methoden
}

hello world 2

und hier sag ich mal der welt hallo:)
und zeig der welt den element und den Stack quellcode

public class Element {

  // Anfang Variablen
  private Object inhalt;
  private Element next;
  // Ende Variablen

  public Element(Object pInhalt) {
    inhalt=pInhalt;
    next=null;
  }

  // Anfang Ereignisprozeduren

  public void setinhalt(Object inhalt) {
    this.inhalt = inhalt;
  }

  public void setnext(Element next) {
    this.next = next;
  }

  public Object getinhalt() {
    return inhalt;
  }

  public Element getnext() {
    return next;
  }

  // Ende Ereignisprozeduren
}

das war das Element und jetzt der stack:

public class Stack {

  // Anfang Variablen
  private Element oben;
  // Ende Variablen

  public Stack() {
   oben= null;
  }

  // Anfang Ereignisprozeduren
  public void push(Object pObject) {
    Element inhalt=new Element(pObject);
    if(isEmpty()){
      oben=inhalt;
    }else{
      inhalt.setnext(oben);
      oben=inhalt;
    }
  }

  public void pop() {
    if(!isEmpty()){
      oben=oben.getnext();
    }
  }

  public Object top() {
    if (!isEmpty()){
    return oben.getinhalt();
    }
    return null;
  }

  public boolean isEmpty(){
    return oben==null;
  }

  // Ende Ereignisprozeduren
}

Hello world!

Welcome to WordPress.com. This is your first post. Edit or delete it and start blogging!