Guest User

Untitled

a guest
Oct 20th, 2011
118
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. /*
  2. Feladat:
  3. --------
  4.  
  5. Valósitsd meg a LinkedList osztályt az alábbi feltételek mellett:
  6. Helyez a LinkedList osztályodat egy LinkedList.java állományban. Az osztály a gyak05.adt csomagban van.
  7. A listát egy double tömb reprezentálja. Ez osztályon kívülrõl elérhetetlen.
  8. Új elem beszúrása esetén allokáljuk újra a tömböt, már ezzel az új elemmel kiegészítve.
  9. Implementáld az alábbi metódusokat:
  10. insert(elem); insert(double[]); remove(index); remove(startindex, endindex);
  11. eq(LinkedList); subList(LinkedList); get(index); subSet(LinkedList);
  12. toString() : String:
  13. elem | elem | elem ...
  14.  
  15. Main.java
  16. Main osztály a gyak05 csomagban.
  17. Használjuk benne a LinkedListet és mutassuk be a metódusainak a mûködését.
  18. args: ellenõrizzük, hogy kapunk-e paramétert, és ha kapunk, akkor azokat szúrjuk be a listába.
  19. Ez mûködjön az args méretétõl függetlenül.
  20. */
  21.  
  22. package gyak05.adt;
  23.  
  24. public class LinkedList {
  25.     private double[] list;
  26.  
  27.     public LinkedList() {
  28.         this.list = new double[0];
  29.     }
  30.  
  31.     public void insert(double e) {
  32.         double[] tmp = list; // tmp ua mint a list! Csak elemek másolódnak.
  33.         list = new double[tmp.length + 1]; // +1 hely az új elemnek.
  34.         for(int i=0; i < tmp.length; ++i) {
  35.             list[i] = tmp[i];
  36.         }
  37.         list[list.length-1] = e;
  38.     }
  39.  
  40.     public void insert(double[] pList) {
  41.         double[] tmp = this.list;
  42.         this.list = new double[tmp.length + pList.length];
  43.         for(int i=0; i<tmp.length; ++i) {
  44.             this.list[i] = tmp[i];
  45.         }
  46.         for(int i=0; i<pList.length; ++i) {
  47.             this.list[tmp.length + i] = pList[i];
  48.         }  
  49.     }
  50.  
  51.     public int size() {
  52.         return this.list.length;
  53.     }
  54.    
  55.     public double get(int index) {
  56.         return list[index];
  57.     }
  58.  
  59.     public void remove(int index) {
  60.         if(index < this.list.length) {
  61.             double[] tmp = list;
  62.             for(int i = index; i < list.length - 1; ++i) {
  63.                 tmp[i] = tmp[i+1];
  64.             }  
  65.             list = new double[tmp.length - 1];
  66.             for(int i=0; i<list.length; ++i) {
  67.                 list[i] = tmp[i];
  68.             }
  69.         }
  70.     }
  71.  
  72.     // endindex-en levo elem bent marad!!!
  73.     public void remove(int startindex, int endindex) {
  74.         double[] tmp = this.list;
  75.         this.list = new double[this.list.length - endindex + startindex];
  76.         for(int i=0; i<startindex; ++i) {
  77.             this.list[i] = tmp[i];
  78.             System.out.println(this.list[i]);
  79.         }
  80.         for(int i=endindex; i<tmp.length; ++i) {
  81.             this.list[i - startindex + 1] = tmp[i];
  82.         }
  83.  
  84.     }
  85.  
  86.     public boolean eq(LinkedList ll) {
  87.         for(int i=0; i<this.list.length; ++i) {
  88.             if(this.list[i] != ll.get(i)) {
  89.                 return false;
  90.             }
  91.         }
  92.         return true;
  93.     }
  94.  
  95.     // Nem ellenorzom, hgy a sublist hosszabb-e mint a list-em.
  96.     public boolean subList(LinkedList ll) {
  97.         outer:
  98.         for(int i=0; i<this.list.length - ll.size(); ++i) {
  99.             for(int j=i; j<i+ll.size(); ++j) {
  100.                 if(this.list[j] != ll.get(j-i)) {
  101.                         continue outer;
  102.                 }  
  103.             }
  104.             return true;
  105.         }
  106.         return false;
  107.     }
  108.  
  109.     public boolean subSet(LinkedList ll) {
  110.         double[] thisSet = getSet(this);
  111.         double[] pSet = getSet(ll);
  112.         outer:
  113.         for(double p : pSet) {
  114.             for(double d : thisSet) {
  115.                 if ( d == p ) {
  116.                     continue outer;
  117.                 }
  118.             }
  119.             return false;
  120.         }
  121.         return true;
  122.     }
  123.  
  124.     @Override
  125.     public String toString() {
  126.         StringBuilder sb = new StringBuilder();
  127.         for(double d : list) {
  128.             sb.append(d); sb.append("|");
  129.         }
  130.         return sb.toString();
  131.     }
  132.  
  133.     private double[] getSet(LinkedList ll) {
  134.         double[] setOfThis = new double[0];
  135.         outer:
  136.         for(int i=0; i<ll.size(); ++i) {
  137.             for(int j=0; j<setOfThis.length; ++j) {
  138.                 if(ll.get(i) == setOfThis[j]) {
  139.                     continue outer;
  140.                 }
  141.             }
  142.             double[] tmp = setOfThis;
  143.             setOfThis = new double[tmp.length + 1];
  144.             for(int k=0; k<tmp.length; ++k) {
  145.                 setOfThis[k] = tmp[k];
  146.             }
  147.             setOfThis[setOfThis.length - 1] = ll.get(i);   
  148.         }
  149.         return setOfThis;
  150.     }
  151.  
  152. }
  153.  
  154.  
RAW Paste Data