public void printing()
{
Queue <btree_node> qu = new Queue <btree_node>();
qu.Enqueue(root);
while (qu.Count > 0)
{
btree_node temp = qu.Dequeue();
if (temp != null)
{
foreach (btree_node q in temp.children)
{
qu.Enqueue(q);
}
string r = string.Empty;
foreach (int q in temp.keys)
{
r += q.ToString();
r += " ";
}
print(r);
}
//else { print("=="); }
}
}
private void insert(int data, btree_node current)
{
if (current.isleaf && current.keys.Count < max_keys)
{
current.keys.Add(data);
current.keys.Sort();
return;
}
else if (!current.isleaf)
{
for (int i = 0; i < current.keys.Count; i++)
{
if (data < current.keys[i])
{
current = current.children[i];
break;
}
if (i == current.keys.Count - 1)
{
current = current.children[i + 1]; break;
}
}
insert(data, current);
}
else
{
current.isleaf = false;
full_node_insertion(data, current);
}
}
List <btree_node> path(int data)
{
btree_node current = root;
List <btree_node> path_node = new List <btree_node>();
while (current != null)
{
path_node.Add(current);
for (int i = 0; i < current.keys.Count; i++)
{
if (data == current.keys[i])
{
path_node.Reverse();
return(path_node);
}
if (data < current.keys[i])
{
current = current.children[i];
break;
}
if (i == current.keys.Count - 1)
{
current = current.children[i + 1]; break;
}
}
}
path_node.Reverse();
return(path_node);
}
void full_node_insertion(int data, btree_node btree_node)
{
List <btree_node> nodes = path(data);
btree_node.keys.Add(data);
btree_node.keys.Sort();
for (int i = 0; i < nodes.Count - 1; i++)
{
correct_insertion(nodes[i], nodes[i + 1]);
}
if (nodes[nodes.Count - 1].keys.Count == max_keys + 1)
{
root = new btree_node(max_keys);
root.isleaf = false;
correct_insertion(nodes[nodes.Count - 1], root);
}
}
int max_value_of_left(btree_node current)
{
int temp = 0;
while (current != null)
{
temp = current.keys[current.keys.Count - 1];
List <btree_node> current_list = real_children(current.children);
if (current_list.Count < 1)
{
break;
}
current_list.Reverse();
current = current_list[0];
}
return(temp);
}
void delete_element(int data)
{
List <btree_node> nodes = path(data);
btree_node main = nodes[0];
if (!main.keys.Contains(data))
{
print("not present"); return;
}
else if ((main.isleaf && main.keys.Count > min_keys) || (main == root && main.keys.Count > 1) || (main == root && main.children.Length == 0))
{
main.keys.Remove(data); main.keys.Sort();
}
else if ((main.isleaf && main != root))
{
bool temp = leaf_delete(nodes[1], main);
if (!temp)
{
leaf_mix(data, nodes[1], main);
}
else
{
main.keys.Remove(data); main.keys.Sort();
}
}
else
{
int temp_index = Array.IndexOf(main.keys.ToArray(), data);
int temp = 0;
temp = max_value_of_left(main.children[temp_index]);
delete_element(temp);
List <btree_node> temp_nodes = path(data);
temp_nodes[0].keys.Remove(data);
temp_nodes[0].keys.Add(temp);
temp_nodes[0].keys.Sort();
}
}
void correct_insertion(btree_node node, btree_node parent)
{
if (node.keys.Count <= max_keys)
{
return;
}
int temp = node.keys[median_index()];
parent.keys.Add(temp);
parent.keys.Sort();
int temp_index = parent.keys.IndexOf(temp);
List <btree_node> left_c = new List <btree_node>(max_keys);
List <btree_node> right_c = new List <btree_node>(max_keys);
btree_node left = new btree_node(max_keys);
btree_node right = new btree_node(max_keys);
int i = -1;
foreach (btree_node trial in node.children)
{
i++;
if (i < node.children.Length / 2)
{
left_c.Add(trial);
if (trial != null)
{
left.isleaf = false;
}
}
else
{
right_c.Add(trial);
if (trial != null)
{
right.isleaf = false;
}
}
}
i = -1;
foreach (int trial in node.keys)
{
i++;
if (i == median_index())
{
continue;
}
if (i < node.keys.Count / 2)
{
left.keys.Add(trial);
}
else
{
right.keys.Add(trial);
}
}
i = 0;
foreach (btree_node child in left_c)
{
left.children[i] = child; i++;
}
i = 0;
foreach (btree_node child in right_c)
{
right.children[i] = child; i++;
}
node.keys.Remove(temp);
btree_node[] children_arr = new btree_node[max_keys + 2];
for (int p = 0, q = 0; p < max_keys + 2; q++, p++)
{
if (p == temp_index)
{
children_arr[temp_index] = left;
children_arr[temp_index + 1] = right;
p++;
}
else
{
children_arr[p] = parent.children[q];
}
}
parent.children = children_arr;
}
private bool leaf_delete(btree_node upper_node, btree_node main)
{
btree_node temp = root;
int index = Array.IndexOf(upper_node.children, main);
string type = "";
if (upper_node.children[0] != main)
{
temp = upper_node.children[index - 1];
if (temp.keys.Count > min_keys)
{
type = "max";
}
}
if (type == "")
{
temp = upper_node.children[index + 1];
if (temp != null && temp.keys.Count > min_keys)
{
type = "min";
}
}
if (type == "min" || type == "max")
{
List <btree_node> left_c = new List <btree_node>();
List <btree_node> right_c = new List <btree_node>();
if (type == "max")
{
foreach (btree_node child in main.children)
{
right_c.Add(child);
}
List <btree_node> going_element = real_children(temp.children);
going_element.Reverse();
if (going_element.Count > 0)
{
right_c.Insert(0, going_element[0]);
}
int temp_index = Array.IndexOf(temp.children, going_element);
for (int i = 0; i < temp_index; i++)
{
left_c.Add(temp.children[i]);
}
for (int i = temp_index; i < max_keys + 2; i++)
{
left_c.Add(null);
}
}
else
{
foreach (btree_node child in main.children)
{
left_c.Add(child);
}
left_c.Insert(real_children(main.children).Count, temp.children[0]);
for (int i = 1; i < max_keys + 2; i++)
{
right_c.Add(temp.children[i]);
}
right_c.Add(null);
}
int removable_data = 0;
if (type == "max")
{
removable_data = temp.keys[temp.keys.Count - 1];
}
else
{
removable_data = temp.keys[0];
}
temp.keys.Remove(removable_data);
upper_node.keys.Add(removable_data);
upper_node.keys.Sort();
index = upper_node.keys.IndexOf(removable_data);
main.children = new btree_node [max_keys + 2];
temp.children = new btree_node [max_keys + 2];
if (type == "max")
{
removable_data = upper_node.keys[++index];
for (int i = 0; i < max_keys; i++)
{
main.children[i] = right_c[i];
}
for (int i = 0; i < max_keys; i++)
{
temp.children[i] = left_c[i];
}
}
else
{
removable_data = upper_node.keys[--index];
for (int i = 0; i < max_keys; i++)
{
main.children[i] = left_c[i];
}
for (int i = 0; i < max_keys; i++)
{
temp.children[i] = right_c[i];
}
}
upper_node.keys.Remove(removable_data);
main.keys.Add(removable_data);
main.keys.Sort();
return(true);
}
else
{
return(false);
}
}
public btree(int max_keys)
{
this.max_keys = max_keys;
this.min_keys = Mathf.FloorToInt(Mathf.Ceil(max_keys / 2));
root = new btree_node(max_keys);
}
private void leaf_mix(int data, btree_node upper_node, btree_node main)
{
bool con = upper_node == root && upper_node.keys.Count == 1;
btree_node upper_upper_node = null;
if (upper_node.keys.Count == 1 && main != null)
{
upper_upper_node = path(data)[2];
}
bool leaf_condition = true;
int index = Array.IndexOf(upper_node.children, main);
List <int> new_key = new List <int>();
List <btree_node> my_children = new List <btree_node>();
if (index != 0)
{
foreach (int insert in upper_node.children[index - 1].keys)
{
new_key.Add(insert);
}
if (real_children(upper_node.children[index - 1].children).Count > 0)
{
leaf_condition = false;
foreach (btree_node child in real_children(upper_node.children[index - 1].children))
{
my_children.Add(child);
}
}
}
foreach (int insert in main.keys)
{
new_key.Add(insert);
}
foreach (btree_node child in real_children(main.children))
{
my_children.Add(child); leaf_condition = false;
}
if (index == 0)
{
if (real_children(upper_node.children[index + 1].children).Count > 0)
{
leaf_condition = false;
foreach (btree_node child in real_children(upper_node.children[index + 1].children))
{
my_children.Add(child);
}
}
foreach (int insert in upper_node.children[index + 1].keys)
{
new_key.Add(insert);
}
}
if (index != 0)
{
new_key.Add(upper_node.keys[index - 1]); upper_node.keys.RemoveAt(index - 1);
}
else
{
new_key.Add(upper_node.keys[index]); upper_node.keys.RemoveAt(index);
}
new_key.Remove(data);
upper_node.keys.Sort();
new_key.Sort();
btree_node new_child = new btree_node(max_keys);
new_child.keys = new_key;
if (!leaf_condition)
{
new_child.isleaf = false;
}
btree_node[] children = new btree_node[max_keys + 2];
for (int i = 0, q = 0; q < max_keys + 2; i++, q++)
{
if ((index == 0 && i == 0) || (i == index - 1))
{
children[i] = new_child;
q++;
}
else
{
children[i] = upper_node.children[q];
}
}
upper_node.children = children;
new_child.children = new btree_node[max_keys + 2];
for (int q = 0; q < my_children.Count; q++)
{
new_child.children[q] = my_children[q];
}
if (con)
{
root = new_child; return;
}
if (upper_node.keys.Count < min_keys && upper_node != root)
{
if (upper_upper_node != null)
{
bool temp = leaf_delete(upper_upper_node, upper_node);
if (!temp)
{
leaf_mix(data, upper_upper_node, upper_node);
}
}
else
{
int temp_index = Array.IndexOf(path(data).ToArray(), upper_node);
bool temp = leaf_delete(path(data)[temp_index + 1], upper_node);
if (!temp)
{
leaf_mix(data, path(data)[temp_index + 1], upper_node);
}
}
}
}
