public void put(long key, T t) {

    int index = getIndex(key);

    Node<T> top = nodes[index];

    if (top == null) {
      Node newNode = new Node();
      newNode.key = key;
      newNode.data = t;
      nodes[index] = newNode;
      return;
    }

    if (top.key == key) {
      // replace top
      top.data = t;
      return;
    }

    // traverse until null and add it
    while (top.next != null) {
      top = top.next;
      if (top.key == key) {
        top.data = t;
        return;
      }
    }

    Node newNode = new Node();
    newNode.key = key;
    newNode.data = t;
    top.next = newNode;
  }
Example #2
0
  /**
   * Recursive delete method. post: The item is equal to the deleted item as it was stored in the
   * tree or null if the item was not found.
   *
   * @param root The root of the current subtree
   * @param target The item to be deleted
   * @return The modified root that does not contain the item
   */
  private Node<E> delete(Node<E> root, E target) {
    if (root == null) {
      deleteReturn = null;
      return root;
    }
    int r = target.compareTo(root.data);

    if (r < 0) {
      root.left = delete(root.left, target);
      return root;
    } else if (r > 0) {
      root.right = delete(root.right, target);
      return root;
    } else {
      deleteReturn = root.data;
      if (root.left == null) {
        return root.right;
      } else if (root.right == null) {
        return root.left;
      } else {
        if (root.left.right == null) {
          root.data = root.left.data;
          root.left = root.left.left;
          return root;
        } else {
          root.data = findLargestChild(root.left);
          return root;
        }
      }
    }
  }
  public void swap(Node x, Node y) {
    int temp;

    temp = x.data;
    x.data = y.data;
    y.data = temp;
  }
Example #4
0
 private static Node makeLinkedList(int[] data, int n) {
   Node head = new Node();
   head.data = data[0];
   Node pre = head;
   Node cur = null;
   for (int i = 1; i < n; ++i) {
     cur = new Node();
     cur.data = data[i];
     pre.next = cur;
     pre = cur;
   }
   return head;
 }
Example #5
0
 public void add(T value) {
   if (value.compareTo(data) < 0 && left == null) {
     left = new Node();
     left.data = value;
   } else if (value.compareTo(data) > 0 && right == null) {
     right = new Node();
     right.data = value;
   } else if (value.compareTo(data) < 0 && left != null) {
     left.add(value);
   } else if (value.compareTo(data) > 0 && right != null) {
     right.add(value);
   }
   // dont't do anything if the value is equal to data
 }
Example #6
0
  /**
   * Deletes the node specified by the parameter toDelete. parent specifies the parent of the node
   * to be deleted.
   */
  private void deleteNode(Node toDelete, Node parent) {
    if (toDelete.left != null && toDelete.right != null) {
      // Case 3: toDelete has two children.
      // Find a replacement for the item we're deleting -- as well as
      // the replacement's parent.
      // We use the smallest item in toDelete's right subtree as
      // the replacement.
      Node replaceParent = toDelete;
      Node replace = toDelete.right;
      while (replace.left != null) {
        replaceParent = replace;
        replace = replace.left;
      }

      // Replace toDelete's key and data with those of the
      // replacement item.
      toDelete.key = replace.key;
      toDelete.data = replace.data;

      // Recursively delete the replacement item's old node.
      // It has at most one child, so we don't have to
      // worry about infinite recursion.
      deleteNode(replace, replaceParent);
    } else {
      // Cases 1 and 2: toDelete has 0 or 1 child
      Node toDeleteChild;
      if (toDelete.left != null) toDeleteChild = toDelete.left;
      else toDeleteChild = toDelete.right; // null if it has no children

      if (toDelete == root) root = toDeleteChild;
      else if (toDelete.key < parent.key) parent.left = toDeleteChild;
      else parent.right = toDeleteChild;
    }
  }
Example #7
0
 /** Create a set with only one element. */
 public void makeSet(long data) {
   Node node = new Node();
   node.data = data;
   node.parent = node;
   node.rank = 0;
   map.put(data, node);
 }
  /**
   * Recurse down the binary tree and delete the specified node
   *
   * @param node Start Node
   * @param data Node to be deleted
   * @return
   */
  public Node delete(Node node, int data) {
    /**
     * A Node can be one of the following types: 1. Leaf Node 2. With one child 3. With two child
     */
    if (data < node.data) {
      node.leftChild = delete(node.leftChild, data);

    } else if (data > node.data) {

      node.rightChild = delete(node.rightChild, data);

    } else {
      /** Leaf Node */
      if (node.rightChild == null && node.leftChild == null) node = null;

      /** Node with one child */
      else if (node.leftChild == null) node = node.rightChild;
      else if (node.rightChild == null) node = node.rightChild;
      else {
        /**
         * Node with 2 child. Replace the node with any of its sibling and then delete the sibling
         */
        node.data = node.leftChild.data;
        node.leftChild = null;
      }
    }
    return node;
  }
Example #9
0
  Node Insert(Node head, int data) {
    if (head == null) {
      head = new Node();
      head.data = data;
    } else {
      while (head.next != null) {
        head = head.next;
      }
      head.next = new Node();

      head = head.next;
      head.data = data;
    }

    return head;
  }
Example #10
0
  // Задание 2.2.3
  public void combineLists(List<Item> list2) {
    Node l1 = this.head;
    Node l2 = list2.head;

    this.push(l2.data); // добавить эл-т из второго списка в начало первого
    l2 = l2.next;
    int position = 1; // позиция в первом списке

    while (l2 != null && l1 != null) {
      if (position % 2 != 0) { // если нечётная позиция
        Node newNode = new Node(); // вставляемый узел
        newNode.data = l2.data;

        // вставка в первый список после текущего
        newNode.next = l1.next;
        l1.next = newNode;

        l1 = l1.next;
        l2 = l2.next;
        position++;
      } else { // если позиция чётная
        l1 = l1.next;
        position++;
      }
    }
    if (l2 != null && l1 == null) {
      while (l2 != null) {
        this.addLast(l2.data);
        l2 = l2.next;
      }
    }
  }
Example #11
0
  public Node delete(int data, Node node) {

    if (node == null) return null;

    if (node.data == data) {

      // case 1 : no child nodes
      if (node.left == null && node.right == null) {
        return null;
      } else if (node.left == null) {
        return node.right;
      } else if (node.right == null) {
        return node.left;
      } else {
        Node successor = getSuccessor(node);
        node.data = successor.data;
        successor = null;
        return node;
      }

    } else {

      if (data <= node.data) {
        node.left = delete(data, node.left);
      } else {
        node.right = delete(data, node.right);
      }

      return node;
    }
  }
 private Node getNewNode(final int val) {
   Node temp = new Node();
   temp.left = null;
   temp.right = null;
   temp.data = val;
   return temp;
 }
Example #13
0
 private Node insert(Node root, String data, int pos) {
   if (pos == data.length()) {
     return root;
   }
   if (root == null) {
     root = new Node();
     root.data = data.charAt(pos);
     root.eq = insert(root.eq, data, pos + 1);
     if (pos == (data.length() - 1)) {
       root.isLeaf = true;
     }
   } else {
     if (root.data == data.charAt(pos)) {
       root.eq = insert(root.eq, data, pos + 1);
       if (pos == (data.length() - 1)) {
         root.isLeaf = true;
       }
     } else if (root.data < data.charAt(pos)) {
       root.right = insert(root.right, data, pos);
     } else {
       root.left = insert(root.left, data, pos);
     }
   }
   return root;
 }
  /**
   * Inserts <code>element</code> at <code>index</code>.
   *
   * @throws IndexOutOfBoundsException if <code>index</code> &lt; 0 or is &gt; <code>size</code>.
   */
  public void add(int index, Object element) {

    if (index == size()) {
      add(element); // Add to the end of this.
    }

    // If index > size() an exception should be thrown with a slightly
    // different message than the exception thrown by getInternal.
    else if (index > size()) {
      throw new IndexOutOfBoundsException("Index out of bounds: " + index + " > " + size());
    } else {
      Node current = getInternal(index);
      Node newNext = new Node(current.data, current.next);

      current.data = element;
      current.next = newNext;

      elementCount++;

      // If they inserted at the last valid index, then a new last element
      // was created, therfore update the last pointer
      if (last == current) {
        last = newNext;
      }
    }
  }
Example #15
0
 private void prepend(int i, T t) {
   Node<T> n = new Node<T>();
   n.data = t;
   n.index = i;
   n.next = this.list;
   this.list = n;
 }
  // Insert a node at a specific position in a linked list
  Node InsertSpecific(Node head, int data, int position) {
    // Will Need to Return Head Node
    Node trackedHeadNode = head;

    Node nodeToInsert = new Node();
    nodeToInsert.data = data;

    // Empty List - Returned newly created node or null
    if (head == null) {
      return nodeToInsert;
    }

    // Inserting a Node ahead of the List
    if (position == 0) {
      nodeToInsert.next = head;
      return nodeToInsert;
    }

    // Traverse the Singly Linked List to 1 Position Prior
    // Stop traversing if you reached the end of the List
    int currPosition = 0;

    while (currPosition < position - 1 && head.next != null) {
      head = head.next;
      currPosition++;
    }

    // Inserting a Node in-between a List or at the end of of a List
    Node nodeAtPosition = head.next;
    head.next = nodeToInsert;
    head = head.next;
    head.next = nodeAtPosition;

    return trackedHeadNode;
  }
Example #17
0
 public void deleteNode(Node node) {
   if (node.next != null) {
     node.data = node.next.data;
     node.next = node.next.next;
   } else {
     throw new NoSuchElementException();
   }
 }
  ReverseALinkedList() {
    Node node1 = new Node();
    node1.data = 1;

    Node node2 = new Node();
    node2.data = 2;

    Node node3 = new Node();
    node3.data = 3;

    node1.next = node2;
    node2.next = node3;
    node3.next = null;

    Node head = Reverse(node1);
    System.out.println(head.data + " " + head.next.data + " " + head.next.next.data);
  }
Example #19
0
 public void add(T value) {
   if (root == null) {
     root = new Node();
     root.data = value;
   } else {
     root.add(value);
   }
 }
  /**
   * Replaces the current element at <code>index/code> with
   * <code>element</code>.
   * @return The current element at <code>index</code>.
   */
  public Object set(int index, Object element) {

    Node setMe = getInternal(index);
    Object oldData = setMe.data;

    setMe.data = element;

    return oldData;
  }
 // Insert a node at the head of a linked list
 Node InsertHead(Node head, int x) {
   Node someNode = new Node();
   someNode.data = x;
   if (head == null) {
     return someNode;
   }
   someNode.next = head;
   return someNode;
 }
Example #22
0
  public void push(int data) {

    Node newNode = new Node();

    newNode.data = data;

    newNode.next = head;

    head = newNode;
  }
Example #23
0
  public void add(Comparable data) {
    Node newNode = new Node();

    newNode.data = data;
    if (root == null) {
      root = newNode;
    } else {
      root.addNode(newNode);
    }
  }
Example #24
0
 public void addElementLast(int data) {
   Node newNode = new Node();
   newNode.data = data;
   newNode.next = null;
   Node temp = head;
   while (temp.next != null) {
     temp = temp.next;
   }
   temp.next = newNode;
 }
Example #25
0
  public void addLast(Item item) // добавление эл-та в конец списка
      {
    if (head == null) {
      head = new Node();
      head.data = item;
    } else {
      Node helpNode = head; // создаём указатель на голову, чтобы не
      // нарушать порядок списка

      while (helpNode.next != null)
        // в цикле доходим до последнего эл-та
        helpNode = helpNode.next;

      Node newNode = new Node();
      newNode.data = item;

      helpNode.next = newNode; // вставляем после последнего
    }
    this.N++;
  }
Example #26
0
  public void setLeft(Node<T> left) {
    if (!((left == null) || (data.compareTo(left.data()) == 1))) {
      throw new RuntimeException("Cannot set " + right.data + " to be left of " + data);
    }

    this.left = left;

    if (this.left != null) {
      this.left.setParent(this);
    }
  }
Example #27
0
 @Override
 public void set(int index, T v) {
   cur = first;
   for (int i = 0; i < index; i++) {
     if (cur == null) {
       throw new IndexOutOfBoundsException();
     }
     cur = cur.next;
   }
   cur.data = v;
 }
 private Node addWithCarry(Node head1, Node head2) {
   if (head1 == null) {
     return null;
   }
   Node result = Node.newNode(0);
   result.next = addWithCarry(head1.next, head2.next);
   int r = head1.data + head2.data + carry;
   result.data = r % 10;
   carry = r / 10;
   return result;
 }
 private static Node add(Node node, ArrayList<Integer> list) {
   Node current = node;
   Node head = node;
   ListIterator<Integer> it = list.listIterator();
   while (it.hasNext()) {
     if (head == null) {
       head = new Node();
       head.data = it.next();
       head.next = null;
       node = head;
     } else {
       current = new Node();
       current.data = it.next();
       current.next = null;
       node.next = current;
       node = node.next;
     }
   }
   return head;
 }
 private Node addRemaining(Node start, Node stop) {
   if (start != stop) {
     Node result = Node.newNode(0);
     result.next = addRemaining(start.next, stop);
     result.data = (start.data + carry) % 10;
     carry = (start.data + carry) / 10;
     return result;
   } else {
     return null;
   }
 }