Programmieren mit Harald R. Haberstroh

1. Am Ende einer (einfach verketteten) Liste einfügen und löschen.

void append(Data data);   /* anhängen */
void delEnd();            /* entfernen des letzten Elements */

2. Sortiertes Einfügen in eine doppelt verkettete Liste

void insert_sort(Data data);

3. Löschen eines bestimmten Elements

boolean del(Data data);

4. Ändern eines Elements in einer einfach verketteten Liste

void change(Data old, Data newdata);

5. Sortiertes Einfügen

1. Iteratives sortiertes Einfügen und iteratves Ausgeben
2. Rekursives sortieres Einfügen und rekursives Ausgeben

Labels: Aufgabe, Java, PR2

# Eingestellt von Harald R. Haberstroh @ 08:15 0 Kommentare

Labels: Robotik

# Eingestellt von Harald R. Haberstroh @ 21:44 0 Kommentare

>>> from random import seed, random
>>> seed("23")
>>> random()
0.41111702255082994

>>> from random import seed, random
>>> seed("23")
>>> random()
0.09256672412670508

>>> "23".__hash__()
6400038450057767

>>> "23".__hash__()
308105767

>>> seed(23)
>>> random()
0.92486525162594524

>>> seed(23)
>>> random()
0.92486525162594524

Labels: allgemeines, Fehler, Python

# Eingestellt von Harald R. Haberstroh @ 11:47 0 Kommentare

Labels: allgemeines, Links

# Eingestellt von Harald R. Haberstroh @ 17:49 0 Kommentare

Labels: android, PR5

# Eingestellt von Harald R. Haberstroh @ 09:59 0 Kommentare

Labels: Aufgabe, PR5

# Eingestellt von Harald R. Haberstroh @ 10:14 0 Kommentare

class Element {
 Element next;
 int data;
 Element(int data) {
   this.data = data;
 }
}

Element anker = null; // leere Liste

Element n = new Element(1);
n.next = anker;
anker = n;

n = new Element(2);
n.next = anker;
anker = n;

n = new Element(3);
n.next = anker;
anker = n;

System.out.println("liste");
for (Element e = anker; e != null; e = e.next) {
 System.out.println(e.data);
}

// 1. Element entfernen
anker = anker.next;
System.out.println("liste");
for (Element e = anker; e != null; e = e.next) {
 System.out.println(e.data);
}

public class Liste {

 private class Element {
   Element next;
   int data;

   Element(int data) {
     this.data = data;
   }
 }

 private Element anker = null;

 // private Element ende = null;

 public void append(int data) {
   if (anker == null) {
     anker = new Element(data);
   } else {
     // suche Ende
     Element e = anker;
     while (e.next != null) {
       e = e.next;
     }
     // e ist das letzte Element (Ende)
     e.next = new Element(data);
   }
 }

 public void insertFirst(int data) {
   Element n = new Element(data);
   n.next = anker;
   anker = n;
 }

 public void deleteFirst() {
   assert (anker != null);
   anker = anker.next;
 }

 public void printList() {
   System.out.print("[");
   for (Element e = anker; e != null; e = e.next) {
     System.out.print(e.data + " ");
   }
   System.out.println("]");
 }

 public void push(int data) {
   insertFirst(data);
 }

 public int pop() {
   assert (anker != null);
   Element e = anker;
   anker = anker.next;
   return e.data;
 }

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

 /**
  * @param args
  */
 public static void main(String[] args) {
   Liste liste = new Liste();
   liste.printList();
   // liste.insertFirst(1);
   // liste.insertFirst(2);
   // liste.insertFirst(3);
   liste.append(1);
   liste.append(2);
   liste.append(3);
   liste.printList();
   liste.deleteFirst();
   liste.printList();

   Liste stack = new Liste();
   stack.push(23);
   stack.push(3);
   while (!stack.isEmpty()) {
     System.out.println(stack.pop());
   }
 }

}

public class Node {
  Node next;
  String data;

  public Node(String data) {
    this.data = data;
  }
  public Node() {
    data = null;
  }
  public String toString() {
    return data;
  }
}

public class Liste {
  private Node anker = null;
  private Node last = null;

  /**
   * hängt Knoten n am Ende der Liste an (für Queue).
   * 
   * @param n
   *          neuer Knoten
   */
  public void put(Node n) {
    if (last == null) { // erstes Element
      anker = n;
      last = n;
    } else {
      last.next = n;
      last = n;
    }
  }

  /**
   * liefert erstes Element und entfernt dieses aus der Liste
   * 
   * @return erster Knoten oder null
   */
  public Node get() {
    Node ret = null;
    if (anker != null) {
      ret = anker;
      anker = anker.next;
      if (anker == null) { // war das das letzte Element?
        last = null;
      }
    }
    return ret;
  }

  /**
   * pop() für Verwendung als Stack.
   * 
   * @return erstes Element
   */
  public Node pop() {
    return get();
  }

  /**
   * fügt Knoten vorne ein (für Stack).
   * 
   * @param n
   *          neuer Knoten
   */
  public void push(Node n) {
    if (anker == null) {
      anker = n;
      last = anker;
    } else {
      n.next = anker;
      anker = n;
    }
  }

  /**
   * liefert Liste als String.
   * 
   * @return "[erstes,zweites,...]", "[]" bei leerer Liste (KEINE Leerzeichen)
   */
  public String toString() {
    String ret = "[";
    Node n;
    for (n = anker; n != null && n.next != null; n = n.next) {
      ret += n + ",";
    }
    if (n != null) {
      ret += n;
    }
    ret += "]";
    return ret;
  }
}

Labels: Java, PR2

# Eingestellt von Harald R. Haberstroh @ 08:35 0 Kommentare

• Telefonnummern mit Vorwahlen (/) und Durchwahlen (-)
• Postleitzahlen
• Autokennzeichen (österreichische)

boolean accept(String input)

Labels: Aufgabe, Java, PR2

# Eingestellt von Harald R. Haberstroh @ 08:28 0 Kommentare

• Telefonnummern mit Vorwahlen (/) und Durchwahlen (-)
• Postleitzahlen
• Autokennzeichen (österreichische)

boolean accept(String input)

Labels: Aufgabe, Java, PR2

# Eingestellt von Harald R. Haberstroh @ 08:10 0 Kommentare