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; }
/** * 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; }
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; }
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 }
/** * 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; } }
/** 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; }
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; }
// Задание 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; } } }
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; }
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> < 0 or is > <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; } } }
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; }
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); }
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; }
public void push(int data) { Node newNode = new Node(); newNode.data = data; newNode.next = head; head = newNode; }
public void add(Comparable data) { Node newNode = new Node(); newNode.data = data; if (root == null) { root = newNode; } else { root.addNode(newNode); } }
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; }
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++; }
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); } }
@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; } }