FONForum

public class Lista {
   Cvor Glava;

   Cvor Tekuci;

   public Lista() {
      Glava = null;
      Tekuci = null;
   }

   public void Add(int br) {
      Glava = new Cvor(br, Glava);
      Tekuci = Glava;
   }

   public void Show() {
      Cvor tmp = Glava;
      while (tmp != null) {
         System.out.print(tmp.br + " ");
         tmp = tmp.sl;
      }
      System.out.println();
   }

   public static Lista Sastavi(Lista l1, Lista l2) {
      Lista tmp = new Lista();
      l1.Tekuci = l1.Glava;
      l2.Tekuci = l2.Glava;
      while (l1.Tekuci != null && l2.Tekuci != null) {
         if ((l1.Tekuci.br < l2.Tekuci.br)) {
            tmp.Add(l1.Tekuci.br);
            l1.Tekuci = l1.Tekuci.sl;
         } else {
            tmp.Add(l2.Tekuci.br);
            l2.Tekuci = l2.Tekuci.sl;
         }

      }
      while (l1.Tekuci != null) {
         tmp.Add(l1.Tekuci.br);
         l1.Tekuci = l1.Tekuci.sl;
      }

      while (l2.Tekuci != null) {
         tmp.Add(l2.Tekuci.br);
         l2.Tekuci = l2.Tekuci.sl;
      }

      return tmp;
   }
}

public int min(Node node){
        if (node==null)
                return Integer.MAX_VALUE;//ukoliko nod ne postoji vrati maksimalnu vrenost da ne bi taj nod bio minimum

        int minLeftSubtree = min(node.left);//minimum levog podstabla dobijen rekurzijom
        int minRightSubtree = min(node.right);//=||= desnog =||=

        int minSubtrees = Math.min(minLeftSubtree,minRightSubtree);
       
        return Math.min(node.data,minSubtrees);//vraca minimum sebe,levog i desnog podstabla
}

public void printToMin(Node node){

        if(node==null)
                return;

        System.out.println(node.data);
 
        if(min(node.left)<min(node.right))
                printToMin(node.left);
        else
                printToMin(node.right);
}

public class HashingUlancavanje {

   public int pretrazi(HashTable[] niz, int target){
        int index=target%102;
        if(niz[index].getBroj()==target)
            return index;
        else{
            while(niz[index].naredni!=null){
                niz[index]=niz[index].naredni;
                if(niz[index].getBroj()==target)
                    return index;
            }
        }
        return -1;

    }

    public void ubaci(HashTable[] niz,int target){
        int index=target%102;
        if(niz[index]==null)
            niz[index]=new HashTable(target);
        else{
         HashTable temp=niz[index];
            while(temp.naredni!=null){
                temp=temp.naredni;
            }
            temp.naredni=new HashTable(target);
        }
    }

    public static void main(String[] args){
        HashTable[] niz=new HashTable[102];
        HashingUlancavanje proba=new HashingUlancavanje();
        proba.ubaci(niz,12);
        proba.ubaci(niz,12);
        proba.ubaci(niz,13);
        proba.ubaci(niz,122);
        proba.ubaci(niz,224);
        System.out.println(proba.pretrazi(niz,224));
    }
}

class HashTable{
    private int broj;
    HashTable naredni;
    public HashTable(int b){
        broj=b;
        naredni=null;
    }

    public HashTable(int b,HashTable p){
        broj=b;
        naredni=p;
    }
    public int getBroj(){
        return broj;
    }
}

private static int hashFunction(int k, int i) {
      return (k%102 + i) % 102;
   }

   /**
    * @param array
    * @param element
    * @return indeks u nizu ili -1 ako nije nadjen
    */
   public static int hashSearchOpenAddressing(int[] array, int element) {
      int i = 0;
      int index = hashFunction(element, i);

      while (i < array.length) {
         if (array[index] == element)
            return index;
         index = hashFunction(element, ++i);
      }
      return -1;
   }

public clsCvorS CvorNajmanjeLeve()
{
   if(koren==null)
         return null;
   if((koren.left==null)&(koren.right==null))
      return koren;
   int najmanjaLeva = Suma(koren.left);
   clsCvorS s =koren;
   CvorNajmanjeLeve(koren,ref najmanjaLeva, ref s);
   return s;
}
private void CvorNajmanjeLeve(clsCvorS cvor, ref int najmanjaLeva,ref clsCvorS s)
{   
   if(cvor==null)
      return;
   if(Suma(cvor.left)<najmanjaLeva)
   {
      najmanjaLeva=Suma(cvor.left);
      s=cvor;
   }
   CvorNajmanjeLeve(cvor.left,ref najmanjaLeva,ref s);
   CvorNajmanjeLeve(cvor.right,ref najmanjaLeva,ref s);
}
private int Suma(clsCvorS cvor)
{
   if(cvor==null)
      return 0;
   return cvor.data+Suma(cvor.left)+Suma(cvor.right);
}

   public int treeHeight(TreeNode aNode) {
      if (aNode == null)
         return 0;
      return 1 + Math.max(treeHeight(aNode.Left), treeHeight(aNode.Right));
   }

   public boolean isAVL(TreeNode aNode) {
      if (aNode == null)
         return true;
      if (Math.abs(treeHeight(aNode.Left) - treeHeight(aNode.Right)) <= 1)
         return (isAVL(aNode.Left) && isAVL(aNode.Right));
      return false;
   }

   public int countNotAVL(TreeNode aNode) {
      if (aNode == null)
         return 0;
      if (!isAVL(aNode)) {
         return 1 + countNotAVL(aNode.Left) + countNotAVL(aNode.Right);
      }
      if (isAVL(aNode)) {
         return countNotAVL(aNode.Left) + countNotAVL(aNode.Right);
      }
   }

public class Zadatak{
   
   public static int height(Node root){
      if(root==null)
         return 0;
      return 1+Math.max(height(root.left),height(root.right));
   }

   public static int absDiff(Node node){
      if(node==null)
         return 0;
      return Math.abs(height(node.left)-height(node.right));
   }
   
   public static void findMax(Node root,Max max){
      if(root==null)
         return;
      /*
      ovde nije moglo max=root i da metodi prosledjujemo kao parametre 2 noda
      jer onda samo setujemo parametar a u pozivaocu se nista ne menja.
      na ovaj nacin se i u pozivaocu menja jer i ovde i u pozivaocu prostupamo
      istoj instanci klase Max sto znaci da ce maxNode da bude onaj koji zelimo.
      */
      if(absDiff(root)>absDiff(max.maxNode))
         max.maxNode=root;   

      findMax(root.left,max);
      findMax(root.right,max);
   }


   //glavna metoda..nju korisnik poziva
   public static Node getMax(Node root){
      if(root==null)
         throw new RuntimeException("root node je null");

      Max max=new Max();

      findMax(root,max);

      return max.maxNode;
   }



/*
             test programa treba da vrati node3
             
             stablo izgleda

                       5
                      / \
                     3   4
                    /   / \
                   8   10  9
                  / \
                 7   6

                node 3 ima razliku 2 node 5 ima razliku 1 a svi ostali imaju razliku 0
*/
   public static void main(String[] args){

      Node node7=new Node(null,null,7);
      Node node6=new Node(null,null,6);
      Node node8=new Node(node7,node6,8);
      Node node3=new Node(node8,null,3);

      Node node9=new Node(null,null,9);
      Node node10=new Node(null,null,10);
      Node node4=new Node(node9,node10,4);

      Node node5=new Node(node3,node4,5);

      System.out.println("max abs"+getMax(node5).data);   
   }
}

class Node{

   Node left;
   Node right;
   int data;

   Node(Node left,Node right,int data){
      this.left=left;
      this.right=right;
      this.data=data;
   }
}

class Max{
   Node maxNode;
}

public static void kloniraj (Stack izvor,Stack klon){
    (!izvor.isEnpty()){
        Object data = izvor.pop();
        kloniraj(izvor,klon);
        klon.push(data);
    }
}