Heap NE RADI

class Heap[Item: Manifest](maxsize: Int, less: (Item,Item) => Boolean) {

      private var curr: Int = 1

      def getSize(): Int = curr-1

      val arr = new Array[Item](maxsize+1)

      def insert(newItem: Item): Unit = {
        arr(curr) = newItem
        fixInsertion(curr)
        curr += 1
        //println(arr.dropRight(arr.length - curr).mkString(","))
      }

      def += (newItem: Item): Unit = {
        insert(newItem)
      }


      def top(remove: Boolean = true): Item =  {
        if(!remove)
          return arr(1)
        curr -= 1
        swap(1, curr)
        fixRemoval(1)
        //println(arr.drop(1).dropRight(arr.length - curr).mkString(","))
        arr(curr)
      }

      def remove(item: Item, i: Int = 1): Unit = {
        if (i < curr) {
          if (arr(i) == item) {
            curr -= 1
            swap(i, curr)
            fixRemoval(i)
          }
          else
            remove(item, i+1)
        }
        else
          throw new NoSuchElementException("Element not found")
      }

      def isEmpty: Boolean =  {
        curr == 1
      }

      private def fixInsertion(i: Int): Unit = {
        if (i > 1 && less(arr(i),arr(i/2))) {
          swap(i, i/2)
          fixInsertion(i/2)
        }
      }

      private def fixRemoval(i: Int): Unit = {
        if (i * 2 < curr) {
            val next = if (i*2 < curr-1) { if (less(arr(i*2), arr(i*2+1))) i*2 else i*2+1} else i*2
            if (less(arr(next), arr(i))) {
                swap(i, next)
                fixRemoval(next)
            }
        }
      }

      private def swap(a: Int, b: Int): Unit = {
         val swap = arr(b)
        arr(b) = arr(a)
        arr(a) = swap
      }


    }