SHARE
TWEET

Untitled

a guest Oct 20th, 2019 67 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. import java.io.BufferedReader;
  2. import java.io.IOException;
  3. import java.io.InputStreamReader;
  4. import java.util.Iterator;
  5. import java.util.NoSuchElementException;
  6.  
  7.  
  8. public class SLLJoinLists {
  9.     public static void main(String[] args) throws IOException {
  10.        
  11.        
  12.         SLL<Integer> lista1 = new SLL<Integer>();
  13.         SLL<Integer> lista2 = new SLL<Integer>();
  14.         BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));
  15.         String s = stdin.readLine();
  16.         int N = Integer.parseInt(s);
  17.         s = stdin.readLine();
  18.         String[] pomniza = s.split(" ");
  19.         for (int i = 0; i < N; i++) {
  20.             lista1.insertLast(Integer.parseInt(pomniza[i]));
  21.         }
  22.  
  23.         s = stdin.readLine();
  24.         N = Integer.parseInt(s);
  25.         s = stdin.readLine();
  26.         pomniza = s.split(" ");
  27.         for (int i = 0; i < N; i++) {
  28.             lista2.insertLast(Integer.parseInt(pomniza[i]));
  29.         }
  30.  
  31.         SLL<Integer> spoeni = new SLL<Integer>();
  32.         spoeni = spoenii(lista1, lista2);
  33.         Iterator<Integer> it = spoeni.iterator();
  34.         while (it.hasNext()) {
  35.             System.out.print(it.next());
  36.             if(it.hasNext())
  37.                 System.out.print(" ");
  38.         }
  39.         System.out.println();
  40.     }
  41.    
  42.     public static SLL<Integer> spoenii(SLL<Integer> lista1, SLL<Integer> lista2){
  43.         SLL<Integer> rezultat = new SLL<Integer>();
  44.         SLLNode<Integer> node1 = lista1.getFirst();
  45.         SLLNode<Integer> node2 = lista2.getFirst();
  46.        
  47.         while(node1 != null&&node2 != null) {
  48.             if(node1.element.compareTo(node2.element)<0) {
  49.                 rezultat.insertLast(node1.element);
  50.                 node1 = node1.succ;
  51.             }
  52.             else {
  53.                 rezultat.insertLast(node2.element);
  54.                 node2 = node2.succ;
  55.             }
  56.         }
  57.        
  58.         if(node1 != null) {
  59.             while(node1 != null) {
  60.                 rezultat.insertLast(node1.element);
  61.                 node1 = node1.succ;
  62.             }
  63.         }
  64.         if(node2 != null) {
  65.             while(node2 != null) {
  66.                 rezultat.insertLast(node2.element);
  67.                 node2 = node2.succ;
  68.             }
  69.         }
  70.         return IzbrisiDuplikati(rezultat);
  71.     }
  72.    
  73.     public static SLL<Integer> IzbrisiDuplikati(SLL<Integer> lista1){
  74.         SLLNode<Integer> temp;
  75.         SLLNode<Integer> node1 = lista1.getFirst();
  76.        
  77.         while(node1.succ != null) {
  78.             if(node1.element == node1.succ.element) {
  79.                 temp = node1.succ.succ;
  80.                 node1.succ = null;
  81.                 node1.succ = temp;
  82.             }
  83.             else {
  84.                 node1 = node1.succ;
  85.             }
  86.         }
  87.         return lista1;
  88.     }
  89. }
  90.  
  91. class SLL<E> {
  92.     private SLLNode<E> first;
  93.    
  94.     public SLL() {
  95.         // Construct an empty SLL
  96.         this.first = null;
  97.     }
  98.  
  99.     public void deleteList() {
  100.         first = null;
  101.     }
  102.  
  103.     public int length() {
  104.         int ret;
  105.         if (first != null) {
  106.             SLLNode<E> tmp = first;
  107.             ret = 1;
  108.             while (tmp.succ != null) {
  109.                 tmp = tmp.succ;
  110.                 ret++;
  111.             }
  112.             return ret;
  113.         } else
  114.             return 0;
  115.  
  116.     }
  117.  
  118.     @Override
  119.     public String toString() {
  120.         String ret = new String();
  121.         if (first != null) {
  122.             SLLNode<E> tmp = first;
  123.             ret += tmp + "->";
  124.             while (tmp.succ != null) {
  125.                 tmp = tmp.succ;
  126.                 ret += tmp + "->";
  127.             }
  128.         } else
  129.             ret = "Prazna lista!!!";
  130.         return ret;
  131.     }
  132.  
  133.     public void insertFirst(E o) {
  134.         SLLNode<E> ins = new SLLNode<E>(o, first);
  135.         first = ins;
  136.     }
  137.  
  138.     public void insertAfter(E o, SLLNode<E> node) {
  139.         if (node != null) {
  140.             SLLNode<E> ins = new SLLNode<E>(o, node.succ);
  141.             node.succ = ins;
  142.         } else {
  143.             System.out.println("Dadenot jazol e null");
  144.         }
  145.     }
  146.  
  147.     public void insertBefore(E o, SLLNode<E> before) {
  148.        
  149.         if (first != null) {
  150.             SLLNode<E> tmp = first;
  151.             if(first==before){
  152.                 this.insertFirst(o);
  153.                 return;
  154.             }
  155.             //ako first!=before
  156.             while (tmp.succ != before)
  157.                 tmp = tmp.succ;
  158.             if (tmp.succ == before) {
  159.                 SLLNode<E> ins = new SLLNode<E>(o, before);
  160.                 tmp.succ = ins;
  161.             } else {
  162.                 System.out.println("Elementot ne postoi vo listata");
  163.             }
  164.         } else {
  165.             System.out.println("Listata e prazna");
  166.         }
  167.     }
  168.  
  169.     public void insertLast(E o) {
  170.         if (first != null) {
  171.             SLLNode<E> tmp = first;
  172.             while (tmp.succ != null)
  173.                 tmp = tmp.succ;
  174.             SLLNode<E> ins = new SLLNode<E>(o, null);
  175.             tmp.succ = ins;
  176.         } else {
  177.             insertFirst(o);
  178.         }
  179.     }
  180.  
  181.     public E deleteFirst() {
  182.         if (first != null) {
  183.             SLLNode<E> tmp = first;
  184.             first = first.succ;
  185.             return tmp.element;
  186.         } else {
  187.             System.out.println("Listata e prazna");
  188.             return null;
  189.         }
  190.     }
  191.  
  192.     public E delete(SLLNode<E> node) {
  193.         if (first != null) {
  194.             SLLNode<E> tmp = first;
  195.             if(first ==node){
  196.                 return this.deleteFirst();
  197.             }
  198.             while (tmp.succ != node&&tmp.succ.succ != null)
  199.                 tmp = tmp.succ;
  200.             if (tmp.succ == node) {
  201.                 tmp.succ = tmp.succ.succ;
  202.                 return node.element;
  203.             } else {
  204.                 System.out.println("Elementot ne postoi vo listata");
  205.                 return null;
  206.             }
  207.         } else {
  208.             System.out.println("Listata e prazna");
  209.             return null;
  210.         }
  211.  
  212.     }
  213.  
  214.     public SLLNode<E> getFirst() {
  215.         return first;
  216.     }
  217.    
  218.     public SLLNode<E> find(E o) {
  219.         if (first != null) {
  220.             SLLNode<E> tmp = first;
  221.             while (tmp.element != o && tmp.succ != null)
  222.                 tmp = tmp.succ;
  223.             if (tmp.element == o) {
  224.                 return tmp;
  225.             } else {
  226.                 System.out.println("Elementot ne postoi vo listata");
  227.             }
  228.         } else {
  229.             System.out.println("Listata e prazna");
  230.         }
  231.         return first;
  232.     }
  233.    
  234.     public Iterator<E> iterator () {
  235.     // Return an iterator that visits all elements of this list, in left-to-right order.
  236.         return new LRIterator<E>();
  237.     }
  238.  
  239.     // //////////Inner class ////////////
  240.  
  241.     private class LRIterator<E> implements Iterator<E> {
  242.  
  243.         private SLLNode<E> place, curr;
  244.  
  245.         private LRIterator() {
  246.             place = (SLLNode<E>) first;
  247.             curr = null;
  248.         }
  249.  
  250.         public boolean hasNext() {
  251.             return (place != null);
  252.         }
  253.  
  254.         public E next() {
  255.             if (place == null)
  256.                 throw new NoSuchElementException();
  257.             E nextElem = place.element;
  258.             curr = place;
  259.             place = place.succ;
  260.             return nextElem;
  261.         }
  262.  
  263.         public void remove() {
  264.             //Not implemented
  265.         }
  266.     }
  267.    
  268.     public void mirror(){
  269.         if (first != null) {
  270.             //m=nextsucc, p=tmp,q=next
  271.             SLLNode<E> tmp = first;
  272.             SLLNode<E> newsucc = null;
  273.             SLLNode<E> next;
  274.            
  275.             while(tmp != null){
  276.                 next = tmp.succ;
  277.                 tmp.succ = newsucc;
  278.                 newsucc = tmp;
  279.                 tmp = next;
  280.             }
  281.             first = newsucc;
  282.         }
  283.        
  284.     }
  285.    
  286.     public void merge (SLL<E> in){
  287.         if (first != null) {
  288.             SLLNode<E> tmp = first;
  289.             while(tmp.succ != null)
  290.                 tmp = tmp.succ;
  291.             tmp.succ = in.getFirst();
  292.         }
  293.         else{
  294.             first = in.getFirst();
  295.         }
  296.     }
  297. }
  298.  
  299. class SLLNode<E> {
  300.     protected E element;
  301.     protected SLLNode<E> succ;
  302.  
  303.     public SLLNode(E elem, SLLNode<E> succ) {
  304.         this.element = elem;
  305.         this.succ = succ;
  306.     }
  307.  
  308.     @Override
  309.     public String toString() {
  310.         return element.toString();
  311.     }
  312. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top