public virtual int height(TreeBANode <T> node) { if (node == null) { return(0); } if (node.child == null) { return(1); } int[] heights = new int[node.child.Length]; for (int x = 0; x < node.child.Length; x++) { heights[x] = height(node.child[x]); } int maxHeight = -1; for (int x = 0; x < node.child.Length; x++) { if (heights[x] > maxHeight) { maxHeight = heights[x]; } } return(1 + maxHeight); }
public virtual bool ElmentI(T element) { if (root == null) { root = new TreeBANode <T>(element, rootSize); root.initializeChild(); return(true); } else { TreeBANode <T> nodeToInsertInto = FTInsert(element); if (SpacesLNode(nodeToInsertInto) == 0) { if (FTInsert(element) == root) { return(SRInsert(element)); } else { if (SHSpace(nodeToInsertInto)) { return(ReOElementI(element, nodeToInsertInto)); } else { return(SNInsert(FTInsert(element), element)); } } } else { return(Insert(FTInsert(element), element)); } } }
public virtual int CountSpacesFill(TreeBANode <T> node) { if (node == null) { return(0); } int spacesFilled = 0; int childSpacesFilled = 0; if (node == root) { spacesFilled = rootSize - SpacesLNode(node); } else { spacesFilled = maxNodeSize - SpacesLNode(node); } if (node.child != null && node.child.Length > 0) { for (int i = 0; i < maxNodeSize; i++) { if (node.child[i] != null) { childSpacesFilled += maxNodeSize - SpacesLNode(node.child[i]); } } } return(spacesFilled + childSpacesFilled); }
public virtual TreeBANode <T> FTInsert(T element, TreeBANode <T> node) { if (node != null) { int i = 1; for (; i <= ConvertNodeToInt(node).Length&& ConvertNodeToInt(node)[i - 1].CompareTo(element) < 0; i++) { if ((i > ConvertNodeToInt(node).Length || ConvertNodeToInt(node)[i - 1].CompareTo(element) > 0) && node.child != null && node.child.Length >= i) { if (node.child != null && node.child[i - 1] != null) { return(FTInsert(element, node.child[i - 1])); } else { return(node); } } else { return(node); } } } else { return(null); } return(node); //ver }
public virtual int SpacesLNode(TreeBANode <T> node) { if (node != null) { int contador = 0; for (int i = 0; i < node.keys.Length; i++) { if (node.keys[i] != null) { contador++; } } if (contador == node.keys.Length) { return(0); } else { return(node.keys.Length - 1); } } else { return(0); } }
//public virtual bool DFNode(TreeBANode<T> node, T elementt) //{ // return (DFNode(node, (elementt))); //} public virtual bool DFNode(TreeBANode <T> node, T element) { T[] elementList = ConvertNodeToInt(node); int numElements; T[] minimalList; if (node == root) { minimalList = new T[rootSize - SpacesLNode(node) - 1]; numElements = rootSize; } else { minimalList = new T[maxNodeSize - SpacesLNode(node) - 1]; numElements = maxNodeSize; } int i = 0; int j = 0; while (j < elementList.Length && i < minimalList.Length) { if (!elementList[j].Equals(element)) { minimalList[i] = elementList[j]; i++; } j++; } Array.Sort(minimalList); return(true); }
//public virtual string search(T element) //{ // return search(element, root); //} public virtual T[] search(T element, TreeBANode <T> node) { if (node != null) { int i = 1; for (; i <= ConvertNodeToInt(node).Length&& element.CompareTo(ConvertNodeToInt(node)[i - 1]) > 0; i++) { ; } if (i > ConvertNodeToInt(node).Length || ConvertNodeToInt(node)[i - 1].CompareTo(element) > 0) { if (node.child != null && node.child.Length > 0 && i < node.child.Length - 1) { return(search(element, node.child[i - 1])); } else { return(node.keys); } } else { return(node.keys); } } else { return(node.keys); } }
//Method for Find parent in the tree public virtual TreeBANode <T> FParent(TreeBANode <T> searchNode, TreeBANode <T> @base) { if (searchNode == null || @base == null || searchNode == @base) { return(null); } bool isChild = false; for (int x = 0; x < @base.child.Length; x++) { if (@base.child[x] == searchNode) { isChild = true; } } if (!isChild) { for (int x = 0; x < @base.child.Length; x++) { TreeBANode <T> possibleParent = FParent(searchNode, @base.child[x]); if (possibleParent != null) { return(possibleParent); } } return(null); } else { return(@base); } }
public virtual bool SNInsert(TreeBANode <T> node, T element) { TreeBANode <T> parent = FParent(node); int numChild = -1; for (int x = 0; x < parent.child.Length; x++) { if (parent.child[x] == node) { numChild = x; } } if (numChild == -1) { return(false); } //System.out.println("Parent is " + ConvertNodeToInt(parent)[numChild-1]); T[] elementList = new T[maxNodeSize + 1]; T[] nodeContents = ConvertNodeToInt(node); for (int x = 0; x < maxNodeSize; x++) { elementList[x] = nodeContents[x]; } elementList[elementList.Length - 1] = element; Array.Sort(elementList); TreeBANode <T> newNodeLeft = new TreeBANode <T>(maxNodeSize); TreeBANode <T> newNodeRight = new TreeBANode <T>(maxNodeSize); int splitter = (int)(Math.Floor((2 * (maxNodeSize + 1) - 1) / (double)(3))); Insert(parent, elementList[splitter]); for (int x = 0; x < splitter; x++) { Insert(newNodeLeft, elementList[x]); } for (int x = splitter + 1; x < elementList.Length; x++) { Insert(newNodeRight, elementList[x]); } //System.out.println("Num child " + numChild); parent.child[numChild] = newNodeLeft; if (numChild + 1 < parent.child.Length) { parent.child[numChild + 1] = newNodeRight; } //RDistribute(parent); return(true); }
//Method for Insert into the node public virtual bool Insert(TreeBANode <T> node, T element) { //T[] elementList = node.keys; List <T> elementList = new List <T>(); int r = 0; while (node.keys[r] != null) { elementList.Add(node.keys[r]); r++; } int numElements; T[] minimalList; if (node == root) { minimalList = new T[elementList.Count() + 1]; numElements = rootSize; } else { minimalList = new T[elementList.Count() + 1]; numElements = maxNodeSize; } for (int i = 0; i < elementList.Count(); i++) { minimalList[i] = elementList[i]; } minimalList[minimalList.Length - 1] = element; Array.Sort(minimalList); node.keys = new T[numElements]; for (int x = 0; x < numElements; x++) { if (x < minimalList.Length) { node.keys[x] = minimalList[x]; } else { node.keys[x] = default(T); } } return(true); }
public virtual void enqueue(TreeBANode <T> node) { if (root == null) { root = new Node <T>(node); return; } Node <T> nodePointer = root; while (nodePointer.next != null) { nodePointer = nodePointer.next; } nodePointer.next = new Node <T>(node); }
public virtual string getTreeString(TreeBANode <T> node) { if (node == null) { return(""); } string nodeString = ""; for (int x = 0; x < ConvertNodeToInt(node).Length; x++) { nodeString += getTreeString(node.child[x]); nodeString += ConvertNodeToInt(node)[x]; } nodeString += TreeString; return(nodeString); }
public virtual bool SRInsert(T element) { if (root == null) { return(false); } T[] rootArray = new T[ConvertNodeToInt(root).Length + 1]; T[] currentElements = ConvertNodeToInt(root); for (int x = 0; x < currentElements.Length; x++) { rootArray[x] = currentElements[x]; } rootArray[rootArray.Length - 1] = element; Array.Sort(rootArray); int numLeft = (int)(Math.Ceiling((double)(currentElements.Length) / 2)); TreeBANode <T> leftNode = new TreeBANode <T>(maxNodeSize); TreeBANode <T> rightNode = new TreeBANode <T>(maxNodeSize); for (int x = 0; x < numLeft; x++) { Insert(leftNode, rootArray[x]); } //string nullString = ""; for (int x = 0; x < rootSize; x++) { //nullString += "[]"; root.keys[x] = default(T); } //root.keys = null; Insert(root, rootArray[numLeft]); for (int x = numLeft + 1; x < rootArray.Length; x++) { Insert(rightNode, rootArray[x]); } root.child[0] = leftNode; root.child[1] = rightNode; return(true); }
public virtual int CountSpaceTree(TreeBANode <T> node) { int currentNodeSpaces = node.keys.Length - 1; int childNodeSpaces = 0; if (node.child != null && node.child.Length > 0) { for (int i = 0; i < maxNodeSize; i++) { if (node.child[i] != null) { childNodeSpaces += (int)(node.child[i].keys.Length - 1) / 2; } } } return(currentNodeSpaces + childNodeSpaces); }
//public virtual bool DElement(T element) //{ // return DElement(new int?(element)); //} public virtual bool DElement(T element) { TreeBANode <T> node = BASerch(element); if (node == null) { return(false); } int minimumSize = (int)(Math.Floor((double)(maxNodeSize * 2 - 1) / 3)); bool haschild = false; if (node.child != null) { for (int x = 0; x < node.child.Length; x++) { if (node.child[x] != null) { haschild = true; } } } if (node != null && node != root) { if (haschild == false && ConvertNodeToInt(node).Length > minimumSize) { DFNode(node, element); } else { if (SHSpare(node)) { return(ReODelete(element, node)); } else { return(MDelete(element, node)); } } } return(false); }
public virtual bool SHSpare(TreeBANode <T> node) { int x = 0; int minSize = (int)(Math.Floor((double)(maxNodeSize * 2 - 1) / 3)); TreeBANode <T> parent = FParent(node); for (; x < parent.child.Length && parent.child[x] != node; x++) { ; } if (x == parent.child.Length) { return(false); } if (x == 0) { if (parent.child[1] != null) { return(CountSpacesFill(parent.child[1]) > minSize); } } else if (x == parent.child.Length - 1 || parent.child[x + 1] == null) { if (parent.child[x - 1] != null) { return(CountSpacesFill(parent.child[x - 1]) > minSize); } } else { if (parent.child[x - 1] != null && parent.child[x + 1] != null) { return(CountSpacesFill(parent.child[x - 1]) > minSize || CountSpacesFill(parent.child[x + 1]) > minSize); } } return(false); }
//editar public virtual T[] ConvertNodeToInt(TreeBANode <T> node) { int i = 0; if (node == null) { return(null); } T[] splitNum = node.keys; return(splitNum); //splitNum = splitNum.Replace("[", ""); //splitNum = splitNum.Replace("]", " "); //var st = new StreamTokenizer(splitNum); //T[] numbers = new T[st.Count()]; //while (st.Count > 1) //{ // numbers[i] = splitNum[i]; // i++; //} //T[] valueArray = null; //int notNullCounter = 0; //for (int x = 0; x < numbers.Length; x++) //{ // if (!string.ReferenceEquals(numbers[x], " ")) // { // notNullCounter++; // } //} //valueArray = new T[notNullCounter]; //for (int x = 0; x < valueArray.Length; x++) //{ //// valueArray[x] = numbers[x]; //} }
public virtual bool SHSpace(TreeBANode <T> node) { int x = 0; TreeBANode <T> parent = FParent(node); for (; x < parent.child.Length && parent.child[x] != node; x++) { ; } if (x == parent.child.Length) { return(false); } if (x == 0) { if (parent.child[1] != null) { return(SpacesLNode(parent.child[1]) > 0); } } else if (x == parent.child.Length - 1 || parent.child[x + 1] == null) { if (parent.child[x - 1] != null) { return(SpacesLNode(parent.child[x - 1]) > 0); } } else { if (parent.child[x - 1] != null && parent.child[x + 1] != null) { return(SpacesLNode(parent.child[x - 1]) > 0 || SpacesLNode(parent.child[x + 1]) > 0); } } return(false); }
public virtual bool ReODelete(T element, TreeBANode <T> node) { int minimumSize = (int)(Math.Floor((double)(maxNodeSize * 2 - 1) / 3)); TreeBANode <T> parent = FParent(node); int x = 0; for (; x < parent.child.Length && parent.child[x] != node; x++) { ; } if (x > 0 && CountSpacesFill(parent.child[x - 1]) > minimumSize) { T shiftKey = ConvertNodeToInt(node)[0]; T temp = ConvertNodeToInt(parent)[x - 1]; DFNode(parent, temp); DFNode(node, ConvertNodeToInt(node)[0]); Insert(parent, shiftKey); Insert(node, element); Insert(parent.child[x - 1], temp); } else if (x < maxNodeSize - 1 && CountSpacesFill(parent.child[x + 1]) > 0) { T shiftKey = ConvertNodeToInt(parent.child[x + 1])[0]; T temp = ConvertNodeToInt(parent)[x]; DFNode(parent, temp); DFNode(parent.child[x + 1], shiftKey); DFNode(node, ConvertNodeToInt(node)[x]); Insert(parent, shiftKey); Insert(node, temp); } return(true); }
public virtual TreeBANode <T> BASerch(T key, TreeBANode <T> node) { if (node != null) { int i = 1; for (; i <= ConvertNodeToInt(node).Length&& ConvertNodeToInt(node)[i - 1].CompareTo(key) < 0; i++) { ; } if (i > ConvertNodeToInt(node).Length || ConvertNodeToInt(node)[i - 1].CompareTo(key) > 0) { return(BASerch(key, node.child[i - 1])); } else { return(node); } } else { return(null); } }
public virtual void RDistribute(TreeBANode <T> node) { int numNodes = 0; //ConvertNodeToInt(node).length; int minimumSize = (int)(Math.Floor((double)(maxNodeSize * 2 - 1) / 3)); bool hasMoved; do { //System.out.println("Iteration"); hasMoved = false; for (int x = 0; x < node.child.Length; x++) { if (maxNodeSize - SpacesLNode(node.child[x]) < minimumSize) { T newRoot = ConvertNodeToInt(node.child[x - 1])[ConvertNodeToInt(node.child[x]).Length - 1]; T oldRoot = ConvertNodeToInt(node)[x - 1]; DFNode(node.child[x - 1], ConvertNodeToInt(node.child[x - 1])[ConvertNodeToInt(node.child[x - 1]).Length - 1]); DFNode(node, oldRoot); Insert(node, newRoot); Insert(node.child[x], oldRoot); } } } while (hasMoved == true); }
public virtual bool ReOElementI(T element, TreeBANode <T> node) { TreeBANode <T> parent = FParent(node); int x = 0; for (; x < parent.child.Length && parent.child[x] != node; x++) { ; } if (x > 0 && SpacesLNode(parent.child[x - 1]) > 0) { T shiftKey = ConvertNodeToInt(node)[0]; T temp = ConvertNodeToInt(parent)[x - 1]; DFNode(parent, temp); DFNode(node, ConvertNodeToInt(node)[0]); Insert(parent, shiftKey); Insert(node, element); Insert(parent.child[x - 1], temp); } else if (x < maxNodeSize - 1 && SpacesLNode(parent.child[x + 1]) > 0) { } return(true); }
//Builder public TreeBA(int m) { this.root = null; this.maxNodeSize = m - 1; this.rootSize = (int)(2 * (Math.Floor((double)(2 * m - 1) / 3)) + 1); }
//Method for find Parent in the tree public virtual TreeBANode <T> FParent(TreeBANode <T> searchNode) { return(FParent(searchNode, root)); }
public Node(TreeBANode <T> node) { elem = node; }
public virtual bool MDelete(T element, TreeBANode <T> node) { TreeBANode <T> parent = FParent(node); int numChild = -1; for (int x = 0; x < parent.child.Length; x++) { if (parent.child[x] == node) { numChild = x; } } if (numChild == -1) { return(false); } DFNode(node, element); T[] elementList = new T[maxNodeSize]; T[] nodeContents = ConvertNodeToInt(node); for (int x = 0; x < nodeContents.Length; x++) { elementList[x] = nodeContents[x]; } int counter = 0; TreeBANode <T> sibling = null; TreeBANode <T> newNode = new TreeBANode <T>(maxNodeSize); int? newParent; if (numChild == 0) { sibling = parent.child[numChild + 1]; } else if (numChild == maxNodeSize - 1) { sibling = parent.child[numChild - 1]; } else if (numChild > 0 && SpacesLNode(parent.child[numChild - 1]) >= ConvertNodeToInt(node).Length) { sibling = parent.child[numChild - 1]; } else if (numChild < maxNodeSize - 1 && SpacesLNode(parent.child[numChild + 1]) >= ConvertNodeToInt(node).Length) { sibling = parent.child[numChild - 1]; } for (int x = nodeContents.Length; x < maxNodeSize; x++) { elementList[x] = ConvertNodeToInt(sibling)[counter]; counter++; } Array.Sort(elementList); for (int x = 0; x < elementList.Length; x++) { Insert(newNode, elementList[x]); } if (sibling == parent.child[numChild + 1]) { parent.child[numChild] = newNode; T temp = ConvertNodeToInt(parent)[numChild]; DFNode(parent, ConvertNodeToInt(parent)[numChild]); Insert(newNode, temp); } else { parent.child[numChild - 1] = newNode; T temp = ConvertNodeToInt(parent)[numChild]; DFNode(parent, ConvertNodeToInt(parent)[numChild - 1]); Insert(newNode, temp); } return(true); }
public bool Equals(TreeBANode <T> other) { return(this.keys.Equals(other.keys)); }