2-3树的java实现

最新推荐文章于 2024-05-26 11:16:37 发布
最新推荐文章于 2024-05-26 11:16:37 发布
阅读量2.1k 收藏 1
点赞数
分类专栏： 数据结构 文章标签： 数据结构

点的定义

package TwoThreeTree;


	class Node
    
    
     
      {
	    private Node
     
     
      
       parent;
	    private Node
      
      
       
        leftChild;
	    private Node
       
       
        
         rightChild;
	    private Node
        
        
          middleChild; // When node is 2-node, leftVal is the values, and rightVal is null. private T leftVal; private T rightVal; private boolean twoNode; protected Node() { } public static 
         
           Node 
          
            newTwoNode(T value) { Node 
           
             node = new Node 
            
              (); node.leftVal = value; node.twoNode = true; return node; } public static 
             
               Node 
              
                newThreeNode(T leftVal, T rightVal) { Node 
               
                 node = new Node 
                
                  (); if (leftVal.compareTo(rightVal) > 0) { node.rightVal = leftVal; node.leftVal = rightVal; } else { node.leftVal = leftVal; node.rightVal = rightVal; } node.twoNode = false; return node; } public static HoleNode newHole() { return new HoleNode(); } public void setLeftChild(Node 
                 
                   leftChild) { this.leftChild = leftChild; if (leftChild != null) leftChild.setParent(this); } public void removeChildren() { this.leftChild = null; this.rightChild = null; } public void setRightChild(Node 
                  
                    rightChild) { this.rightChild = rightChild; if (rightChild != null) rightChild.setParent(this); } public void setMiddleChild(Node 
                   
                     middleChild) { assert isThreeNode(); this.middleChild = middleChild; if (middleChild != null) { middleChild.setParent(this); } } public final Node 
                    
                      parent() { return parent; } public final void setParent(Node 
                     
                       parent) { this.parent = parent; } public boolean isTerminal() { return leftChild == null && rightChild == null; } public T val() { assert isTwoNode(); return leftVal; } public T leftVal() { assert isThreeNode(); return leftVal; } public void setVal(T val) { assert isTwoNode(); leftVal = val; } public T rightVal() { assert isThreeNode(); return rightVal; } public void setLeftVal(T leftVal) { assert isThreeNode(); this.leftVal = leftVal; } public void setRightVal(T rightVal) { assert isThreeNode(); this.rightVal = rightVal; } public boolean isTwoNode() { // return rightVal == null; return twoNode; } public boolean isThreeNode() { return !isTwoNode(); } public Node 
                      
                        leftChild() { return leftChild; } public Node 
                       
                         rightChild() { return rightChild; } public Node 
                        
                          middleChild() { assert isThreeNode(); return middleChild; } @SuppressWarnings("unchecked") public void replaceChild(Node currentChild, Node newChild) { if (currentChild == leftChild) { leftChild = newChild; } else if (currentChild == rightChild) { rightChild = newChild; } else { assert middleChild == currentChild; middleChild = newChild; } newChild.setParent(this); currentChild.setParent(null); } }

空点的定义

package TwoThreeTree;

/**
 * A hole node does not have any values, and have only one child.
 */
final class HoleNode
    
    
     
      extends Node {
    private Node
     
     
      
       child;

    HoleNode() {
        super();
    }

    public boolean isTwoNode() {
        return false;
    }

    public Node sibling() {
        if (parent() != null) {
            return parent().leftChild() == this ? parent().rightChild(): parent().leftChild();
        }
        return null;
    }

    @Override
    public void setLeftChild(Node leftChild) {
    }

    @Override
    public void removeChildren() {
        child = null;
    }


    @Override
    public void setRightChild(Node rightChild) {
    }

    public Node
      
      
       
        child() {
        return child;
    }

    public void setChild(Node
       
       
        
         child) {
        this.child = child;
    }
}

2-3树实现


/**
 *  A 2-3 tree is a balanced search tree where each node can have either two children and one value (2-node),
 * or three children and two values (3-node).
 *
 * References:
 * http://scienceblogs.com/goodmath/2009/03/two-three_trees_a_different_ap.php
 * http://cs.wellesley.edu/~cs230/spring07/2-3-trees.pdf
 *
 *
 * Author: Sergejs Melderis (sergey.melderis@gmail.com)
 */


package TwoThreeTree;


import java.util.*;






@SuppressWarnings("unchecked")
public class TwoTreeTree
    
    
     
      extends AbstractSet
     
     
      
       implements SortedSet
      
      
       
        {

    Node
       
       
        
         root;
    int size = 0;

    public boolean add(T value) {
        if (root == null)
            root = Node.newTwoNode(value);
        else {
            try {
                Node
        
        
          result = insert(value, root); if (result != null) { root = result; } } catch (DuplicateException e) { return false; } } size ++; return true; } public boolean contains(T value) { return findNode(root, value) != null; } private Node 
         
           findNode(Node 
          
            node, T value) { if (node == null) return null; if (node.isThreeNode()) { int leftComp = value.compareTo(node.leftVal()); int rightComp = value.compareTo(node.rightVal()); if (leftComp == 0 || rightComp == 0) { return node; } if (leftComp < 0) { return findNode(node.leftChild(), value); } else if (rightComp < 0) { return findNode(node.middleChild(), value); } else { return findNode(node.rightChild(), value); } } else { int comp = value.compareTo(node.val()); if (comp == 0) return node; if (comp < 0) return findNode(node.leftChild(), value); else return findNode(node.rightChild(), value); } } private static final class DuplicateException extends RuntimeException {}; private static final DuplicateException DUPLICATE = new DuplicateException(); private Node 
           
             insert(T value, Node 
            
              node) throws DuplicateException { Node 
             
               returnValue = null; if (node.isTwoNode()) { int comp = value.compareTo(node.val()); if (node.isTerminal()) { if (comp == 0) throw DUPLICATE; Node 
              
                thnode = Node.newThreeNode(value, node.val()); Node 
               
                 parent = node.parent(); if (parent != null) parent.replaceChild(node, thnode); else root = thnode; } else { if (comp < 0) { Node 
                
                  result = insert(value, node.leftChild()); if (result != null) { Node 
                 
                   threeNode = Node.newThreeNode(result.val(), node.val()); threeNode.setRightChild(node.rightChild()); threeNode.setMiddleChild(result.rightChild()); threeNode.setLeftChild(result.leftChild()); if (node.parent() != null) { node.parent().replaceChild(node, threeNode); } else { root = threeNode; } unlinkNode(node); } } else if (comp > 0) { Node 
                  
                    result = insert(value, node.rightChild()); if (result != null) { Node 
                   
                     threeNode = Node.newThreeNode(result.val(), node.val()); threeNode.setLeftChild(node.leftChild()); threeNode.setMiddleChild(result.leftChild()); threeNode.setRightChild(result.rightChild()); if (node.parent() != null) { node.parent().replaceChild(node, threeNode); } else { root = threeNode; } unlinkNode(node); } } else { throw DUPLICATE; } } } else { // three node Node 
                    
                      threeNode = node; int leftComp = value.compareTo(threeNode.leftVal()); int rightComp = value.compareTo(threeNode.rightVal()); if (leftComp == 0 || rightComp == 0) { throw DUPLICATE; } if (threeNode.isTerminal()) { returnValue = splitNode(threeNode, value); } else { if (leftComp < 0) { Node 
                     
                       result = insert(value, threeNode.leftChild()); if (result != null) { returnValue = splitNode(threeNode, result.val()); returnValue.leftChild().setLeftChild(result.leftChild()); returnValue.leftChild().setRightChild(result.rightChild()); returnValue.rightChild().setLeftChild(threeNode.middleChild()); returnValue.rightChild().setRightChild((threeNode.rightChild())); unlinkNode(threeNode); } } else if (rightComp < 0) { Node 
                      
                        result = insert(value, threeNode.middleChild()); if (result != null) { returnValue = splitNode(threeNode, result.val()); returnValue.leftChild().setLeftChild(threeNode.leftChild()); returnValue.leftChild().setRightChild(result.leftChild()); returnValue.rightChild().setLeftChild(result.rightChild()); returnValue.rightChild().setRightChild(threeNode.rightChild()); unlinkNode(threeNode); } } else { Node 
                       
                         result = insert(value, threeNode.rightChild()); if (result != null) { returnValue = splitNode(threeNode, result.val()); returnValue.leftChild().setLeftChild(threeNode.leftChild()); returnValue.leftChild().setRightChild(threeNode.middleChild()); returnValue.rightChild().setLeftChild(result.leftChild()); returnValue.rightChild().setRightChild(result.rightChild()); unlinkNode(threeNode); } } } } return returnValue; } public boolean remove(T value) { if (value == null) return false; // System.out.println("removing " + value); Node 
                        
                          node = findNode(root, value); if (node == null) return false; HoleNode hole = null; Node 
                         
                           terminalNode; T holeValue; if (node.isTerminal()) { terminalNode = node; holeValue = value; } else { // Replace by successor. if (node.isThreeNode()) { if (node.leftVal().equals(value)) { Node 
                          
                            pred = predecessor(node, value); holeValue = pred.isThreeNode() ? pred.rightVal() : pred.val(); node.setLeftVal(holeValue); terminalNode = pred; } else { Node 
                           
                             succ = successor(node, value); holeValue = succ.isThreeNode() ? succ.leftVal() : succ.val(); node.setRightVal(holeValue); terminalNode = succ; } } else { Node 
                            
                              succ = successor(node, value); holeValue = succ.isThreeNode() ? succ.leftVal() : succ.val(); node.setVal(holeValue); terminalNode = succ; } } assert terminalNode.isTerminal(); if (terminalNode.isThreeNode()) { // Easy case. Replace 3-node by 2-node T val = terminalNode.leftVal().equals(holeValue) ? terminalNode.rightVal() : terminalNode.leftVal(); Node 
                             
                               twoNode = Node.newTwoNode(val); if (terminalNode.parent() != null) { terminalNode.parent().replaceChild(terminalNode, twoNode); } else { root = twoNode; } } else { if (terminalNode.parent() != null) { hole = Node.newHole(); terminalNode.parent().replaceChild(terminalNode, hole); } else { root = null; } } // For description of each case see // "2-3 Tree Deletion: Upward Phase" in http://cs.wellesley.edu/~cs230/spring07/2-3-trees.pdf while (hole != null) { // Case 1. The hole has a 2-node as parent and 2-node as sibling. if (hole.parent().isTwoNode() && hole.sibling().isTwoNode()) { //System.out.println("Case 1"); Node 
                              
                                parent = hole.parent(); Node 
                               
                                 sibling = hole.sibling(); Node 
                                
                                  threeNode = Node.newThreeNode(parent.val(), sibling.val()); if (parent.leftChild() == hole) { threeNode.setLeftChild(hole.child()); threeNode.setMiddleChild(sibling.leftChild()); threeNode.setRightChild(sibling.rightChild()); } else { threeNode.setLeftChild(sibling.leftChild()); threeNode.setMiddleChild(sibling.rightChild()); threeNode.setRightChild(hole.child()); } if (parent.parent() == null) { unlinkNode(hole); root = threeNode; hole = null; } else { hole.setChild(threeNode); parent.parent().replaceChild(parent, hole); } unlinkNode(parent); unlinkNode(sibling); } // Case 2. The hole has a 2-node as parent and 3-node as sibling. else if (hole.parent().isTwoNode() && hole.sibling().isThreeNode()) { //System.out.println("Case 2 "); Node 
                                 
                                   parent = hole.parent(); Node 
                                  
                                    sibling = hole.sibling(); if (parent.leftChild() == hole) { Node 
                                   
                                     leftChild = Node.newTwoNode(parent.val()); Node 
                                    
                                      rightChild = Node.newTwoNode(sibling.rightVal()); parent.setVal(sibling.leftVal()); parent.replaceChild(hole, leftChild); parent.replaceChild(sibling, rightChild); leftChild.setLeftChild(hole.child()); leftChild.setRightChild(sibling.leftChild()); rightChild.setLeftChild(sibling.middleChild()); rightChild.setRightChild(sibling.rightChild()); } else { Node 
                                     
                                       leftChild = Node.newTwoNode(sibling.leftVal()); Node 
                                      
                                        rightChild = Node.newTwoNode(parent.val()); parent.setVal(sibling.rightVal()); parent.replaceChild(sibling, leftChild); parent.replaceChild(hole, rightChild); leftChild.setLeftChild(sibling.leftChild()); leftChild.setRightChild(sibling.middleChild()); rightChild.setLeftChild(sibling.rightChild()); rightChild.setRightChild(hole.child()); } unlinkNode(hole); unlinkNode(sibling); hole = null; } // Case 3. The hole has a 3-node as parent and 2-node as sibling. else if (hole.parent().isThreeNode()) { Node 
                                       
                                         parent = hole.parent(); // subcase (a), hole is in the middle if (parent.middleChild() == hole && parent.leftChild().isTwoNode()) { //System.out.println("Case 3 (a) hole in the middle"); Node 
                                        
                                          leftChild = parent.leftChild(); Node 
                                         
                                           newParent = Node.newTwoNode(parent.rightVal()); Node 
                                          
                                            newLeftChild = Node.newThreeNode(leftChild.val(), parent.leftVal()); newParent.setLeftChild(newLeftChild); newParent.setRightChild(parent.rightChild()); if (parent != root) { parent.parent().replaceChild(parent, newParent); } else { root = newParent; } newLeftChild.setLeftChild(leftChild.leftChild()); newLeftChild.setMiddleChild(leftChild.rightChild()); newLeftChild.setRightChild(hole.child()); unlinkNode(parent); unlinkNode(leftChild); unlinkNode(hole); hole = null; } // subcase (b), hole is in the middle else if (parent.middleChild() == hole && parent.rightChild().isTwoNode()) { //System.out.println("Case 3(b) hole in the middle"); Node 
                                           
                                             rightChild = parent.rightChild(); Node 
                                            
                                              newParent = Node.newTwoNode(parent.leftVal()); Node 
                                             
                                               newRightChild = Node.newThreeNode(parent.rightVal(), rightChild.val()); newParent.setLeftChild(parent.leftChild()); newParent.setRightChild(newRightChild); if (parent != root) { parent.parent().replaceChild(parent, newParent); } else { root = newParent; } newRightChild.setLeftChild(hole.child()); newRightChild.setMiddleChild(rightChild.leftChild()); newRightChild.setRightChild(rightChild.rightChild()); unlinkNode(parent); unlinkNode(rightChild); unlinkNode(hole); hole = null; } else if (parent.middleChild().isTwoNode()) { Node 
                                              
                                                middleChild = parent.middleChild(); // subcase (a). hole is the left child. if (parent.leftChild() == hole) { //System.out.println("Case 3 (a) hole is left child"); Node 
                                               
                                                 newParent = Node.newTwoNode(parent.rightVal()); Node 
                                                
                                                  leftChild = Node.newThreeNode(parent.leftVal(), middleChild.val()); newParent.setLeftChild(leftChild); newParent.setRightChild(parent.rightChild()); if (parent != root) { parent.parent().replaceChild(parent, newParent); } else { root = newParent; } leftChild.setLeftChild(hole.child()); leftChild.setMiddleChild(middleChild.leftChild()); leftChild.setRightChild(middleChild.rightChild()); unlinkNode(parent); unlinkNode(hole); unlinkNode(middleChild); hole = null; } // subcase (a). hole is the right child. else if (parent.rightChild() == hole) { //System.out.println("Case 3 (a) hole is right child"); Node 
                                                 
                                                   newParent = Node.newTwoNode(parent.leftVal()); Node 
                                                  
                                                    rightChild = Node.newThreeNode(middleChild.val(), parent.rightVal()); newParent.setRightChild(rightChild); newParent.setLeftChild(parent.leftChild()); if (parent != root) { parent.parent().replaceChild(parent, newParent); } else { root = newParent; } rightChild.setLeftChild(middleChild.leftChild()); rightChild.setMiddleChild(middleChild.rightChild()); rightChild.setRightChild(hole.child()); unlinkNode(parent); unlinkNode(hole); unlinkNode(middleChild); hole = null; } } // Case 4. The hole has a 3-node as parent and 3-node as sibling. else if (parent.middleChild().isThreeNode()) { Node 
                                                   
                                                     middleChild = parent.middleChild(); // subcase (a) hole is the left child if (hole == parent.leftChild()) { //System.out.println("Case 4 (a) hole is left child"); Node 
                                                    
                                                      newLeftChild = Node.newTwoNode(parent.leftVal()); Node 
                                                     
                                                       newMiddleChild = Node.newTwoNode(middleChild.rightVal()); parent.setLeftVal(middleChild.leftVal()); parent.setLeftChild(newLeftChild); parent.setMiddleChild(newMiddleChild); newLeftChild.setLeftChild(hole.child()); newLeftChild.setRightChild(middleChild.leftChild()); newMiddleChild.setLeftChild(middleChild.middleChild()); newMiddleChild.setRightChild(middleChild.rightChild()); unlinkNode(hole); unlinkNode(middleChild); hole = null; } // subcase (b) hole is the right child else if (hole == parent.rightChild()) { // System.out.println("Case 4 (b) hole is right child"); Node 
                                                      
                                                        newMiddleChild = Node.newTwoNode(middleChild.leftVal()); Node 
                                                       
                                                         newRightChild = Node.newTwoNode(parent.rightVal()); parent.setRightVal(middleChild.rightVal()); parent.setMiddleChild(newMiddleChild); parent.setRightChild(newRightChild); newMiddleChild.setLeftChild(middleChild.leftChild()); newMiddleChild.setRightChild(middleChild.middleChild()); // newMiddleChild.setParent(middleChild.middleChild()); newRightChild.setLeftChild(middleChild.rightChild()); newRightChild.setRightChild(hole.child()); unlinkNode(hole); unlinkNode(middleChild); hole = null; } else if (hole == parent.middleChild() && parent.leftChild().isThreeNode()) { // System.out.println("Case 4 (a) hole is middle child, left is 3-node"); Node 
                                                        
                                                          leftChild = parent.leftChild(); Node 
                                                         
                                                           newLeftChild = Node.newTwoNode(leftChild.leftVal()); Node 
                                                          
                                                            newMiddleChild = Node.newTwoNode(parent.leftVal()); parent.setLeftVal(leftChild.rightVal()); parent.setLeftChild(newLeftChild); parent.setMiddleChild(newMiddleChild); newLeftChild.setLeftChild(leftChild.leftChild()); newLeftChild.setRightChild(leftChild.middleChild()); newMiddleChild.setLeftChild(leftChild.rightChild()); newMiddleChild.setRightChild(hole.child()); unlinkNode(hole); unlinkNode(leftChild); hole = null; } else { assert (hole == parent.middleChild() && parent.rightChild().isThreeNode()); // System.out.println("Case 4 (b) hole is middle child, right is 3-node"); Node 
                                                           
                                                             rightChild = parent.rightChild(); Node 
                                                            
                                                              newRightChild = Node.newTwoNode(rightChild.rightVal()); Node 
                                                             
                                                               newMiddleChild = Node.newTwoNode(parent.rightVal()); parent.setRightVal(rightChild.leftVal()); parent.setMiddleChild(newMiddleChild); parent.setRightChild(newRightChild); newRightChild.setRightChild(rightChild.rightChild()); newRightChild.setLeftChild(rightChild.middleChild()); newMiddleChild.setRightChild(rightChild.leftChild()); newMiddleChild.setLeftChild(hole.child()); unlinkNode(hole); unlinkNode(rightChild); hole = null; } } } } size--; return true; } private void unlinkNode(Node node) { node.removeChildren(); node.setParent(null); } private Node 
                                                              
                                                                successor(Node 
                                                               
                                                                 node, T value) { if (node == null) return null; if (!node.isTerminal()) { Node 
                                                                
                                                                  p; if (node.isThreeNode() && node.leftVal().equals(value)) { p = node.middleChild(); } else { p = node.rightChild(); } while (p.leftChild() != null) { p = p.leftChild(); } return p; } else { Node 
                                                                 
                                                                   p = node.parent(); if (p == null) return null; Node 
                                                                  
                                                                    ch = node; while (p != null && ch == p.rightChild()) { ch = p; p = p.parent(); } return p != null ? p : null; } } private Node 
                                                                   
                                                                     predecessor(Node 
                                                                    
                                                                      node, T value) { if (node == null) return null; Node 
                                                                     
                                                                       p; if (!node.isTerminal()) { if (node.isThreeNode() && node.rightVal().equals(value)) { p = node.middleChild(); } else { p = node.leftChild(); } while (p.rightChild() != null) { p = p.rightChild(); } return p; } else { throw new UnsupportedOperationException("Implement predecessor parent is not terminal node"); } } private Node 
                                                                      
                                                                        splitNode(Node 
                                                                       
                                                                         threeNode, T value) { T min; T max; T middle; if (value.compareTo(threeNode.leftVal()) < 0) { min = value; middle = threeNode.leftVal(); max = threeNode.rightVal(); } else if (value.compareTo(threeNode.rightVal()) < 0) { min = threeNode.leftVal(); middle = value; max = threeNode.rightVal(); } else { min = threeNode.leftVal(); max = value; middle = threeNode.rightVal(); } Node 
                                                                        
                                                                          parent = Node.newTwoNode(middle); parent.setLeftChild(Node.newTwoNode(min)); parent.setRightChild(Node.newTwoNode(max)); return parent; } public interface Function 
                                                                         
                                                                           { public void apply(T t); } /** * Preorder search. * Visit the node. * Visit the left subtree * Visit the middle subtree */ public void preOrder(Node 
                                                                          
                                                                            node, Function 
                                                                           
                                                                             f) { if (node.isThreeNode()) { f.apply(node.leftVal()); f.apply(node.rightVal()); } if (node.isTerminal()) return; preOrder(node.leftChild(), f); if (node.isThreeNode()) { assert node.middleChild() != null; preOrder(node.middleChild(), f); } preOrder(node.rightChild(), f); } public void inorderSearch(Node 
                                                                            
                                                                              node, Function 
                                                                             
                                                                               func) { if (node == null) return; inorderSearch(node.leftChild(), func); if (node.isThreeNode()) { Node 
                                                                              
                                                                                threeNode = node; func.apply(threeNode.leftVal()); inorderSearch(threeNode.middleChild(), func); func.apply(threeNode.rightVal()); } else { func.apply(node.val()); } inorderSearch(node.rightChild(), func); } // Set operations. /** * The returning iterator does not support remove. */ public Iterator 
                                                                               
                                                                                 iterator() { return new Iterator 
                                                                                
                                                                                  () { Node 
                                                                                 
                                                                                   nextNode; // Stack to keep three nodes Deque 
                                                                                   
                                                                                   
                                                                                     > threeNodes = new ArrayDeque 
                                                                                     
                                                                                     
                                                                                       >(); T next; { Node 
                                                                                      
                                                                                        node = root; while(node != null && node.leftChild() != null) { node = node.leftChild(); } nextNode = node; } public boolean hasNext() { return next != null || nextNode != null; } public T next() { T prev; if (next != null) { prev = next; next = null; nextNode = successor(nextNode, prev); return prev; } if (nextNode.isThreeNode()) { if (nextNode.isTerminal()) { next = nextNode.rightVal(); prev = nextNode.leftVal(); } else { if (threeNodes.peekFirst() == nextNode) { threeNodes.pollFirst(); prev = nextNode.rightVal(); nextNode = successor(nextNode, prev); } else { prev = nextNode.leftVal(); threeNodes.addFirst(nextNode); nextNode = successor(nextNode, prev); } } } else { prev = nextNode.val(); nextNode = successor(nextNode, prev); } return prev; } public void remove() { throw new UnsupportedOperationException(); } }; } public Comparator 
                                                                                        comparator() { return null; } public SortedSet 
                                                                                       
                                                                                         subSet(T fromElement, T toElement) { throw new UnsupportedOperationException(); } public SortedSet 
                                                                                        
                                                                                          headSet(T toElement) { throw new UnsupportedOperationException(); } public SortedSet 
                                                                                         
                                                                                           tailSet(T fromElement) { throw new UnsupportedOperationException(); } public T first() { Node 
                                                                                          
                                                                                            node = root; while (node.leftChild() != null) { node = node.leftChild(); } return node.isThreeNode() ? node.leftVal() : node.val(); } public T last() { Node 
                                                                                           
                                                                                             node = root; while (node.rightChild() != null) { node = node.rightChild(); } return node.isThreeNode() ? node.rightVal() : node.val(); } public int size() { return size; } @Override public boolean contains(Object o) { try { return contains ((T) o); } catch (ClassCastException e) { return false; } } @Override public boolean remove(Object o) { try { return remove((T) o); } catch (ClassCastException e) { return false; } } @Override public void clear() { root = null; } @Override public Object[] toArray() { final Object arr[] = new Object[size]; inorderSearch(root, new Function() { int index = 0; public void apply(Object t) { arr[index++] = (T) t; } }); return arr; } @Override public 
                                                                                            
                                                                                              T[] toArray(T[] a) { T[] r = a.length >= size ? a : (T[]) java.lang.reflect.Array .newInstance(a.getClass().getComponentType(), size); return _toArray(r); } public 
                                                                                             
                                                                                               T[] _toArray(final T[] a) { inorderSearch(root, new Function() { int index = 0; public void apply(Object t) { a[index++] = (T) t; } }); return a; } @Override public boolean removeAll(Collection 
                                                                                               c) { boolean removed = false; for (Object o : c) { removed |= remove(o); } return removed; } @Override public String toString() { if (size == 0) return "[]"; final StringBuilder sb = new StringBuilder("["); inorderSearch(root, new Function 
                                                                                              
                                                                                                () { public void apply(T t) { sb.append(t); sb.append(", "); } }); sb.deleteCharAt(sb.length() - 1); sb.deleteCharAt(sb.length() - 1); sb.append("]"); return sb.toString(); } }

disappearedgod
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2-3-4树的java实现
想作会飞的鱼的博客
01-12 4131
一、什么是2-3-4树 2-3-4树和红黑树一样，也是平衡树。只不过不是二叉树，它的子节点数目可以达到4个。 每个节点存储的数据项可以达到3个。名字中的2,3,4是指节点可能包含的子节点数目。具体而言： 1、若父节点中存有1个数据项，则必有2个子节点。 2、若父节点中存有2个数据项，则必有3个子节点。 3、若父节点中存有3个数据项，则必有4个子节点。 也就是说子节点的数目是父节点中数据
二叉树的Java实现
OrangeXXL的博客
09-27 172
前段时间看数据结构的过程中自己实现了一个二叉树及其常用操作。参考书籍是《数据结构与算法：java语言版》Mark Allen Weiss写的那本。我再创建的过程中默认就是创建为二叉查找树的形式。创建类BinaryTree，之后对其中的内容进行一一介绍。 Node节点 首先介绍节点node //创建节点类 class Node{ int value; Node LChild; Nod...
2—3树 Java实现
qq_45672914的博客
08-25 428
最适合新手的暴力实现2—3树方法。
2-3查找树-树-数据结构和算法(Java)
gaogzhen的博客
12-13 486
2-3查找树-树-数据结构和算法(Java)
B树与B+树区别
最新发布
Hubery_sky的博客
05-26 1512
总之,B+树相比B树有更好的空间利用率和查询性能,更适合用作大型数据库的索引结构。近日总结：做了一个梦，去实习了，实习场景忒吓人了，吓得我在梦里连夜跑了。
java实现2-3树_Java数据结构和算法(八)--红黑树与2-3树
weixin_39767124的博客
02-27 307
红黑树规则：1、每个节点要么是红色，要么是黑色2、根节点都是黑色节点3、每个叶节点是黑色节点3、每个红色节点的两个子节点都是黑色节点，反之，不做要求，换句话说就是不能有连续两个红色节点4、从任意节点到所有叶子节点上的黑色节点数量是相同的一般对红黑树的讲述都是先给出这样的定义，这样想对不太容易理解的，而在算法4一书中，直接跳过这些规则，而讲述了红黑树与2-3树的等价性。如果我们先了解2-3树，理解了...
java 树 查找_2-3 查找树及其Java实现
weixin_39606361的博客
02-12 285
2-3 查找树定义(来源：wiki)2–3树是一种树型数据结构，内部节点(存在子节点的节点)要么有2个孩子和1个数据元素，要么有3个孩子和2个数据元素，叶子节点没有孩子，并且有1个或2个数据元素。2个结点 定义如果一个内部节点拥有一个数据元素、两个子节点，则此节点为2节点。如果一个内部节点拥有两个数据元素、三个子节点，则此节点为3节点。当且仅当以下叙述中有一条成立时，T为2–3树：T为空。即T不包...
2-3树原理+代码实现！超简单java入门版！
title_martin的博客
01-21 456
2-3查找树 为了保证树的平衡性，我们需要一些灵活性，因此在这里我们允许树中的一个结点保存多个键，确切的说，我们将一颗标准的二叉查找树的结点称为2-结点(含有一个键和两条链)。而现在我们引入3-结点，它含有两个键和3条链。2-和3-结点中的每条链对应着其中保存的键所产生的一个区间。 定义： 一颗2-3树要么为空，要么满足下面两个要求： 2-结点： 含有一个键，及其对应值得两条链，左链接指向2-3树中的键都小于该结点，右链接指向2-3树中的键都大于该结点 3-结点： 含有两个键(及其对应的值)和3条链
tree-sitter-java:树保姆的Java语法
04-17
2. **代码高亮**：通过解析代码结构，tree-sitter-java可以帮助编辑器实现智能的代码高亮，提升阅读体验。 3. **代码补全**：根据已解析的AST，可以提供精准的代码补全建议，增强IDE的功能。 4. **格式化和重构**：...
从2-3树理解红黑树
02-25
2-3树是一种特殊的树形数据结构，而红黑树则是一种对2-3树进行颜色编码以实现更简洁表示的抽象概念。通过理解2-3树，我们可以更好地理解红黑树的运作机制。 首先，让我们详细讨论2-3树。2-3树是一种每个节点最多...
红黑树-基于Java实现的红黑树数据结构.zip
03-21
5. **Java实现**： - Java标准库中的`java.util.TreeMap`和`java.util.TreeSet`类底层就是用红黑树实现的。 - 实现红黑树需要定义节点类，包含节点值、颜色、左子节点、右子节点以及父节点等属性，并实现插入、...
2-3树的实现
11-22
陈建二老师总结的2-3树讲课资料,主要适用于中南大学计算机系研究生的高级算法课程
java树三级结构代码
12-04
java树结构，分3级节点逐级显示，还可以响应点击事件，亲测可以使用，代码有注释，若有疑问可以给我留言
2-3树的插于及删除操作源代码
03-28
NULL 博文链接：https://shinepw.iteye.com/blog/1271090
k-means算法Java实现
05-06
在这个Java实现中，我们将深入探讨算法的原理、步骤以及如何用Java编程语言进行实现。 首先，k-means算法的核心思想是迭代过程。算法开始时，我们需要随机选择k个数据点作为初始的聚类中心（或称质心）。接下来，...
Java-Red-Black-Tree:Java中通用红黑树的实现
06-11
在Java中，红黑树的实现位于`java.util.TreeMap`和`java.util.TreeSet`的源码中，具体可以查看`java.util.TreeMap$Node`类，这个类代表了红黑树的节点，包含了颜色属性、键、值和子节点等信息。通过分析源码，我们...
数据结构与算法（java）：树-平衡树（2-3树原理，红黑树，B树，B+树）
lalala_dxf的博客
03-12 1926
平衡树 当我们依次往二叉查找树中插入9，8，7，6，5，4，3，2，1这个九个数据时，最终构出来的树是个非平衡树，如下： 当要查找1这个元素时，查找效率会很低，原因在于这个树它不平衡，全部都是向左边的分支。如果让生成的树像完全二叉树那样，查找效率更高。常见的平衡树有如下几个2-3查找树，红黑树，B-树和B+树等。。。 2-3查找树 定义 2-3查找树要么为空要么满足下面两个要求： 2-结点：含有一个键（及其对应的值）和两条链，左链接指向2-3树中的键都小于该结点，右链接指向的2-3树中的键都大于该结点。
Java实现数据结构---234树
coding is an art
07-18 2745
一个节点最多只有两个子节点的树称为二叉树，一个节点最多拥有N（大于等于3）个子节点的树称为N叉树，N叉树相对于二叉树而言，存储相等数量的数据，N叉树因为同一层存放的数据变多，相应树的高度就变小，查询也就更快。 234树是N叉树的一种，它主要具有以下特点： 1. 一个节点最多可以存储3个数据项。 2. 一个节点（非叶节点）最多拥有4个子节点。 3. 数据项个数与子节点数量关系为：子节点数量 = 数据项个数 + 1。
C++ 2-3树实现（红黑树）学习笔记
qq_36203083的博客
04-06 1161
C++ 2-3树实现（红黑树）学习笔记 在使用二叉查找树时，二叉查找树的运行时间取决于树的形状，树的形状取决于插入数据的顺序，最好的情况是叶子节点到根节点到距离为LogN。 2-3树可以允许“每个节点保存2个数据”的情况发生，从而提高了二叉查找树的灵活性，最终实现了无论以什么顺序插入，都可以保持树的平衡性和有序性。 一. 2-3树的节点类型 本次通过红黑树实现2-3树，在树进行操作的过程中，2-...
查询树形结构 --java
07-28
根据提供的代码，这是一个查询树形结构的Java代码示例。代码中使用了递归的方式来查询树形结构中包含指定关键字的节点。首先，通过调用`init()`方法初始化了一个树形结构的列表`treeList`。然后，通过使用Java 8的流式操作，筛选出根节点（`pid`为0的节点），并使用`map`操作将每个根节点的子节点列表设置为通过`getChildren`方法递归获取的子节点列表。最后，使用`collect`操作将结果收集到一个列表中，并使用Gson库将结果转换为JSON格式输出。 在代码中，`TreeEntity`是树形结构的实体类，包含了节点的id、名称、父级id和子级集合。`getChildren`方法用于递归获取指定节点的子节点列表。 请注意，这只是一个示例代码，具体的树形结构查询实现可能会根据实际需求有所不同。 #### 引用[.reference_title] - *1* *2* [Java树形结构查询（Steam）](https://blog.csdn.net/xiaoxiaohan130/article/details/120910211)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insertT0,239^v3^insert_chatgpt"}} ] [.reference_item] - *3* [java树形结构---通过关键词查询返回路径](https://blog.csdn.net/bianfu2008zhi/article/details/114880044)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insertT0,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值