FONForum

3.

   (40)               (40)              (40)               (70)
  /   \   +70 =      /    \    +55=     /   \     +150=    /  \
(20) (90)         (20)    (90)      (20)    (70)        (40)   (90)
                         /                  /  \         / \      \
                       (70)               (55) (90)   (20) (55)   (150)


//// dovde je ok onda greska , jer moze da se ostavi onako kako je ako je razlika izmedju visine levog i desnog podstbla 1 tako da bi ja ovako
            (70)
+100=      /    \
       (40)      (90)
       / \           \
   (20)  (55)       (150)
                     /
                  (100)
visina levog je 2 a visina desnog 3 ==> |3-2|=1 sto nije vece od 1

6.
a)

ovde greska u startu , ovako bi ja
 
       (130)              (30,130)                       (30,130)
        /  \     +25=    /   |    \         +100=      /    |      \
  (30,50)   (200)    (25)   (50)  (200)            (25)  (50,100)  (200)


            (30,130)                     
+180=      /   |    \             
       (25) (50,100) (180,200)     

 
                  (  100  )
                /          \
+120=    ( 30 )             ( 130 )
         /   \              /      \
     (25)   (50)       (120)       (180.200)

                (  100  )
                /          \
+150=    ( 30 )             ( 130.180 )
         /   \              /    |     \
      (25)   (50)        (120) (150)   (200)

b)

        (130)             (50)                 
        /   \    -200=    /   \    -50= (30,130) -30= (130)
  (30,50)   (200)     (30)    (130)         

Dat je pokazivač na koren binarnog stabla čiji čvorovi sadrže cele brojeve. Napisati funkciju koja će vratiti najmanji (najveći) broj sadržan u stablu.

public int MinTree(TreeNode aNode){
  int min = minInt;
  if(aNode != null)
    min = Math.min(aNode.Data, MinTree(aNode.Left.Data), MinTree(aNode.Right.Data));
  return min;
}
// za najveci samo Math.max umesto Math. min
// u stvari, u celom kodu zameniti svako max sa min

min = Math.min(Math.min(aNode.Data, MinTree(aNode.Left.Data)), Math.min(MinTree(aNode.Right.Data)));

Dat je pokazivač na koren binarnog stabla čiji čvorovi sadrže cele brojeve. Napisati funkciju koja će vratiti pokazivač na čvor u stablo kod koga je najmanja suma sadržaja njegovog levog podstabla.
public int minZbirLevi(TreeNode aNode){
        if(aNode == null)
          return null;
        TreeNode subLevo = aNode.Left;
        int zbir = subLevo.Left.Data + subLevo.Right.Data;
        return Math.min(zbir, minZbirDesni(subLevo)); // za najveci koristiti Math.max
      }

int zbir = subLevo.Left.Data + subLevo.Right.Data;

if(aNode == null)
          return null;

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

public static int olancavanje(LinkedList[] niz, int kljuc){
   int i = kljuc%niz.length;
   if (niz[i].mHead.Data == kljuc)
      return i;
      else {
      ListNode vr = niz[i].mHead.Next;
      while (vr.Data != kljuc && vr.Next != null)
         vr = vr.Next;
      if (vr.Data == kljuc)
         return i;
      if (vr == null)
         return -1; //trazeni element nije nadjen
      }
}

B* stablo

      (150)       +20      (80)           +120     (80,150)
         / \                 / \                       / | \
    (50,80) (250)       (20,50) (150,250)     (20,50) (120) (220,250)

B stablo

    (100)         +15   (100)         +90      (50,100)
     /  \                / \                    / | \
 (50) (150,180)     (15,50) (150,180)       (15) (90) (150,180)
 
 +200
 
        (100)
        /  \
    (50)    (180)
    / \      / \
 (15) (90) (150) (200)

public static int otvAdr(int[] niz, int kljuc){
   int j = kljuc%niz.length;
   if (niz[j] == kljuc)
      return j;
      else {
        j +=1;
        for (j; j<niz.length; j++){
         if (niz[j] == kljuc)
            return j;
        } else
         return -1; //element nije nadjen
      }
}

>>Dat je pokazivač na koren binarnog stabla čiji čvorovi sadrže cele brojeve. Napisati funkciju koja će vratiti pokazivač na čvor list koji je na najvećoj dubini u stablu.

public TreeNode najDubList ( TreeNode aNode ){
   if ( aNode == null )
      return null;
   
   if ( (aNode.Right == null) && (aNode.Left == null) )
      return aNode;

// Naravno , predpostavlja se da imamo definisanu funkciju height
   
    if ( height(aNode.Left) > height(aNode.Right) )
      return najDubList ( aNode.Left );
   
      else
      return najDubList ( aNode.Right );
}

public void Push(Object aData) {
   if (mHead == null) {
      mHead = mTail = new DoubleLinkedListNode(aData);
   } else {
      DoubleLinkedListNode stariHead = mHead;
      mHead = new DoubleLinkedListNode(aData, stariHead);
      stariHead.Previous = mHead;
   }
}

public Object Pop() {
   if (mHead == null){
      return null;
   }
   Object podatak = mHead.Data;
   DoubleLinkedListNode stariHead = mHead;
   if (mHead.Next != null) {
      mHead = stariHead.Next;
      mHead.Previous = null;
   } else {
      mHead = mTail = null;
   }
   return podatak;
}