diff --git a/naloga3/src/AVLDrevo.java b/naloga3/src/AVLDrevo.java
index 0f9c9a9..0650f2b 100644
--- a/naloga3/src/AVLDrevo.java
+++ b/naloga3/src/AVLDrevo.java
@@ -1,12 +1,13 @@
 @SuppressWarnings("SuspiciousNameCombination")
 public class AVLDrevo {
-    static class Item {
-        public int value;
-        public int count;
+    static class Node {
+        int value;
+        int count = 1;
+        Node left, right;
+        int height = 1;
 
-        public Item(int value) {
+        public Node(int value) {
             this.value = value;
-            this.count = 1;
         }
 
         @Override
@@ -15,18 +16,8 @@ public class AVLDrevo {
         }
     }
 
-    static class Node {
-        Item item;
-        Node left, right;
-        int height = 1;
-
-        public Node(int value) {
-            item = new Item(value);
-        }
-    }
-
     Node root;
-    StringBuilder traversal;
+    private StringBuilder traversal = new StringBuilder();
 
     private int getHeight(Node node) {
         if (node == null) {
@@ -60,10 +51,10 @@ public class AVLDrevo {
         return y;
     }
 
-    private Node minValueNode(Node node) {
+    private Node maxValueNode(Node node) {
         Node current = node;
-        while (current.left != null) {
-            current = current.left;
+        while (current.right != null) {
+            current = current.right;
         }
         return current;
     }
@@ -101,10 +92,10 @@ public class AVLDrevo {
             return new Node(value);
         }
 
-        if (value == node.item.value) {
-            node.item.count++;
+        if (value == node.value) {
+            node.count++;
             return node;
-        } else if (value < node.item.value) {
+        } else if (value < node.value) {
             node.left = vstavi(node.left, value);
         } else {
             node.right = vstavi(node.right, value);
@@ -121,26 +112,26 @@ public class AVLDrevo {
         System.out.println(traversal.substring(0, traversal.length() - 1));
     }
 
-    private void najdi(Node node, int value) {
+    private Node najdi(Node node, int value) {
         if (node == null) {
             traversal.append("x").append(",");
-            return;
+            return null;
         }
 
-        if (value == node.item.value) {
-            traversal.append(node.item.value).append(",");
-            return;
-        } else if (value < node.item.value) {
-            traversal.append(node.item.value).append(",");
-            najdi(node.left, value);
+        if (value == node.value) {
+            traversal.append(node.value).append(",");
+            return node;
+        } else if (value < node.value) {
+            traversal.append(node.value).append(",");
+            return najdi(node.left, value);
         } else {
-            traversal.append(node.item.value).append(",");
-            najdi(node.right, value);
+            traversal.append(node.value).append(",");
+            return najdi(node.right, value);
         }
     }
 
     public void izbrisi(int kljuc) {
-        izbrisi(root, kljuc);
+        root = izbrisi(root, kljuc);
     }
 
     private Node izbrisi(Node node, int value) {
@@ -148,28 +139,27 @@ public class AVLDrevo {
             return null;
         }
 
-        if (value < node.item.value) {
+        if (value < node.value) {
             node.left = izbrisi(node.left, value);
-        } else if (value > node.item.value) {
+        } else if (value > node.value) {
             node.right = izbrisi(node.right, value);
         } else {
-            if (node.item.count > 1) {
-                node.item.count--;
+            if (node.count > 1) {
+                node.count--;
                 return node;
             }
 
-            Node tmp;
             if (node.left == null) {
-                tmp = node.right;
-                return tmp;
+                return node.right;
             } else if (node.right == null) {
-                tmp = node.left;
-                return tmp;
+                return node.left;
             }
 
-            tmp = minValueNode(node.right);
-            node.item = tmp.item;
-            node.right = izbrisi(node.right, tmp.item.value);
+            Node max = maxValueNode(node.left);
+            node.value = max.value;
+            node.count = max.count;
+            max.count = 1;
+            node.left = izbrisi(node.left, max.value);
         }
 
         node.height = 1 + Math.max(getHeight(node.left), getHeight(node.right));
@@ -191,18 +181,23 @@ public class AVLDrevo {
         if (node == null) {
             return;
         }
-        traversal.append(node.item).append(",");
+        traversal.append(node).append(",");
         premiPregled(node.left);
         premiPregled(node.right);
     }
 
     public void najnizjiSkupniPredhodnik(int a, int b) {
+        if (najdi(root, a) == null || najdi(root, b) == null) {
+            System.out.println("x");
+            return;
+        }
+
         Node node = lca(root, a, b);
         if (node == null) {
             System.out.println("x");
             return;
         }
-        System.out.println(node.item.value);
+        System.out.println(node.value);
     }
 
     private Node lca(Node node, int a, int b) {
@@ -210,9 +205,9 @@ public class AVLDrevo {
             return null;
         }
 
-        if (a < node.item.value && b < node.item.value) {
+        if (a < node.value && b < node.value) {
             return lca(node.left, a, b);
-        } else if (a > node.item.value && b > node.item.value) {
+        } else if (a > node.value && b > node.value) {
             return lca(node.right, a, b);
         }
 
@@ -230,8 +225,8 @@ public class AVLDrevo {
         }
 
         int sum = 0;
-        if (node.item.value >= lower && node.item.value <= upper) {
-            sum += node.item.value * node.item.count;
+        if (node.value >= lower && node.value <= upper) {
+            sum += node.value * node.count;
         }
 
         sum += sumBounds(node.left, lower, upper);
@@ -255,11 +250,23 @@ public class AVLDrevo {
         if (k == null) {
             return null;
         }
-        k -= node.item.count;
+        k -= node.count;
         if (k <= 0) {
-            System.out.println(node.item.value);
+            System.out.println(node.value);
             return null;
         }
         return kSmallest(node.right, k);
     }
+
+    static void beautyPrint(AVLDrevo.Node node, int l) {
+        if (node == null)
+            return;
+
+        for (int i = 0; i < l; i++) {
+            System.out.print("\t");
+        }
+        System.out.println(node);
+        beautyPrint(node.left, l + 1);
+        beautyPrint(node.right, l + 1);
+    }
 }
diff --git a/naloga3/src/Main.java b/naloga3/src/Main.java
index 3534b8f..d6d87e7 100644
--- a/naloga3/src/Main.java
+++ b/naloga3/src/Main.java
@@ -1,16 +1,28 @@
+import java.util.Random;
+
 public class Main {
     public static void main(String[] args) {
+        Random rng = new Random(10);
         AVLDrevo tree = new AVLDrevo();
-        tree.vstavi(8);
-        tree.vstavi(3);
-        tree.vstavi(10);
-        tree.vstavi(1);
-        tree.vstavi(6);
-        tree.vstavi(14);
-        tree.vstavi(6);
-        tree.vsotaVMejah(3, 6);
-        tree.najdi(9);
-        tree.ktiNajmanjsi(2);
-        tree.najnizjiSkupniPredhodnik(1, 6);
+        int min = -1000;
+        int max = 1000;
+        for (int i = 1; i < 2000; i++) {
+            for (int j = 0; j < 10; j++) {
+                tree.vstavi(rng.nextInt(2000) - 1000);
+            }
+            for (int k = 0; k < 4; k++) {
+                for (int j = 0; j < 30; j++) {
+                    tree.izbrisi(rng.nextInt(2000) - 1000);
+                }
+            }
+        }
+        tree.premiPregled();
+        for (int i = 1; i < 200; i++) {
+            tree.ktiNajmanjsi(i);
+        }
+        for (int i = 0; i < 100; i++) {
+            int val = rng.nextInt(max - min) + min;
+            tree.vsotaVMejah(val, val + 200);
+        }
     }
 }