اڳڀرائي
هي مضمون بائنري ڳولا جي وڻن بابت آهي. مون تازو هڪ مضمون ڪيو اتي مون بائنري وڻن تي گهڻو ڌيان نه ڏنو، ڇاڪاڻ ته ڳولا، داخل ڪرڻ، ۽ حذف ڪرڻ جا طريقا لاڳاپيل نه هئا. هاڻي مون وڻن جي باري ۾ هڪ مضمون لکڻ جو فيصلو ڪيو. اچو ته شروع ڪريون.
وڻ هڪ ڊيٽا جي جوڙجڪ آهي جنهن ۾ ڪنارن سان ڳنڍيل نوڊس شامل آهن. اسان اهو چئي سگهون ٿا ته هڪ وڻ هڪ گراف جي هڪ خاص صورت آهي. هتي هڪ مثال وڻ آهي:
هي هڪ بائنري ڳولا جو وڻ ناهي! سڀ ڪجهه کٽيو آهي!
اصطلاحات
رستو
وڻ جي پاڙ - اھو آھي ان جو مٿاھين نوڊ. مثال ۾، هي نوڊ A آهي. هڪ وڻ ۾، صرف هڪ رستو روٽ کان ڪنهن ٻئي نوڊ ڏانهن وٺي سگهي ٿو! حقيقت ۾، ڪنهن به نوڊ کي هن نوڊ سان لاڳاپيل ذيلي وڻ جي روٽ طور سمجهي سگهجي ٿو.
والدين / اولاد
روٽ کان سواءِ سڀني نوڊس کي بلڪل ھڪڙي ڪنڊ آھي ٻئي نوڊ ڏانھن. موجوده هڪ مٿان واقع نوڊ سڏيو ويندو آهي والدين هن نوڊ. ھڪڙو نوڊ جيڪو موجوده ھڪڙي جي ھيٺان واقع آھي ۽ ان سان ڳنڍيل آھي سڏيو ويندو آھي اولاد هن نوڊ. اچو ته هڪ مثال استعمال ڪريون. اچو ته نوڊ B وٺو، پوء ان جو والدين نوڊ A ٿيندو، ۽ ان جا ٻار نوڊ D، E ۽ F هوندا.
اليزي
جنهن جو ڪو به اولاد نه هجي ان کي وڻ جو پن چئبو. مثال ۾، پنن جا نوڊس D، E، F، G، I، J، K هوندا.
هي بنيادي اصطلاح آهي. ٻين تصورن تي وڌيڪ بحث ڪيو ويندو. تنهن ڪري، هڪ بائنري وڻ هڪ وڻ آهي جنهن ۾ هر نوڊ کي ٻن ٻارن کان وڌيڪ نه هوندو. جيئن توهان اندازو لڳايو، مثال مان وڻ بائنري نه هوندو، ڇاڪاڻ ته نوڊس B ۽ H کي ٻن کان وڌيڪ ٻار آهن. هتي هڪ بائنري وڻ جو هڪ مثال آهي:
وڻ جي نوڊس ڪنهن به معلومات تي مشتمل ٿي سگھي ٿو. هڪ بائنري سرچ وڻ هڪ بائنري وڻ آهي جنهن ۾ هيٺيون خاصيتون آهن:
- ٻئي کاٻي ۽ ساڄي ذيلي وڻ آهن بائنري ڳولا جا وڻ.
- هڪ صوابديدي نوڊ X جي کاٻي ذيلي وڻ جي سڀني نوڊس وٽ ڊيٽا ڪي ويل ويلز آهن جيڪي پاڻ نوڊ ايڪس جي ڊيٽا ڪيئي جي قيمت کان گهٽ آهن.
- سڀني نوڊس جي ساڄي ذيلي تري ۾ هڪ صوابديدي نوڊ X وٽ ڊيٽا ڪي ويل ويلز آهن جيڪي نوڊ X جي ڊيٽا ڪي جي قيمت کان وڌيڪ يا برابر آهن.
ڪيٻي - نوڊ جي ڪا به خاصيت (مثال طور، هڪ نمبر). چاٻي جي ضرورت آهي ته جيئن توهان وڻ جي عنصر کي ڳولي سگهو ٿا جنهن سان هن ڪيئي سان لاڳاپيل آهي. بائنري ڳولا واري وڻ جو مثال:
وڻ جو نظارو
جيئن اسان اڳتي وڌنداسين، مان توهان جي سمجھ کي بهتر ڪرڻ لاءِ ڪوڊ جا ڪجهه (ممڪن طور نامڪمل) ٽڪرا مهيا ڪندس. مڪمل ڪوڊ مضمون جي آخر ۾ هوندو.
هڪ وڻ نوڊس تي مشتمل هوندو آهي. نوڊ جي جوڙجڪ:
public class Node<T> {
private T data;
private int key;
private Node<T> leftChild;
private Node<T> rightChild;
public Node(T data, int key) {
this.data = data;
this.key = key;
}
public Node<T> getLeftChild() {
return leftChild;
}
public Node<T> getRightChild() {
return rightChild;
}
//...остальные методы узла
}
هر نوڊ ۾ ٻه ٻار هوندا آهن (اهو بلڪل ممڪن آهي ته کاٻي ٻار ۽/يا ساڄي ٻار ٻار هڪ ناڪاري قدر تي مشتمل هوندا). توهان شايد اهو محسوس ڪيو آهي ته هن معاملي ۾ نمبر ڊيٽا نوڊ ۾ محفوظ ڪيل ڊيٽا آهي؛ key - node key.
اسان ڳٽ کي ترتيب ڏئي ڇڏيو آهي، هاڻي اچو ته وڻن بابت مسئلن تي دٻاء جي باري ۾ ڳالهايون. ان کان پوءِ، لفظ ”وڻ“ مان مطلب ھوندس بائنري سرچ وڻ جو تصور. بائنري وڻ جي جوڙجڪ:
public class BinaryTree<T> {
private Node<T> root;
//методы дерева
}
اسان کي صرف وڻ جي روٽ جي ضرورت آهي ڪلاس فيلڊ جي طور تي، ڇاڪاڻ ته روٽ مان، getLeftChild() ۽ getRightChild() طريقن کي استعمال ڪندي، توهان وڻ جي ڪنهن به نوڊ تائين پهچي سگهو ٿا.
هڪ وڻ ۾ Algorithms
Поиск
اچو ته توهان وٽ هڪ تعمير ٿيل وڻ آهي. هڪ عنصر کي ڪيئن ڳولهي چاٻي سان؟ توهان کي ضرورت آهي ته ترتيب وار روٽ کان وڻ جي هيٺان منتقل ڪريو ۽ ڪنجي جي قيمت کي ايندڙ نوڊ جي ڪنجي سان ڀيٽڻ جي ضرورت آهي: جيڪڏهن ڪيئي ايندڙ نوڊ جي ڪنجي کان گهٽ آهي، ته پوءِ نوڊ جي کاٻي ٻار ڏانهن وڃو، جيڪڏهن اهو آهي. وڌيڪ، ساڄي پاسي، جيڪڏهن ڪنجيون برابر آهن، گهربل نوڊ مليو آهي! لاڳاپيل ڪوڊ:
public Node<T> find(int key) {
Node<T> current = root;
while (current.getKey() != key) {
if (key < current.getKey())
current = current.getLeftChild();
else
current = current.getRightChild();
if (current == null)
return null;
}
return current;
}
جيڪڏهن موجوده null ٿي وڃي ٿي، پوء ڳولا وڻ جي آخر تائين پهچي چڪو آهي (هڪ تصوراتي سطح تي، توهان وڻ ۾ هڪ غير موجود جڳهه تي آهيو - هڪ پنن جو ٻار).
اچو ته هڪ متوازن وڻ تي ڳولا الورورٿم جي اثرائتي تي غور ڪريو (هڪ وڻ جنهن ۾ نوڊس وڌيڪ يا گهٽ برابر طور تي ورهايل آهن). پوءِ ڳولا جي ڪارڪردگي O(log(n)) هوندي، ۽ logarithm بيس 2 آهي. ڏسو: جيڪڏهن هڪ متوازن وڻ ۾ n عنصر آهن، ته پوءِ ان جو مطلب آهي ته log(n) هوندو بيس 2 ليولن تائين. وڻ ۽ ڳولا ۾، چڪر جي هڪ قدم ۾، توهان هڪ سطح هيٺ وڃو.
داخل
جيڪڏهن توهان ڳولا جي جوهر کي سمجهندا آهيو، ته پوءِ داخل ٿيڻ کي سمجهڻ توهان لاءِ مشڪل نه ٿيندو. توهان کي صرف وڻ جي هڪ پني ڏانهن وڃڻو پوندو (ڳولا ۾ بيان ڪيل نزول جي ضابطن جي مطابق) ۽ ان جو اولاد بڻيو - کاٻي يا ساڄي، ڪنجي تي منحصر ڪري ٿو. عمل درآمد:
public void insert(T insertData, int key) {
Node<T> current = root;
Node<T> parent;
Node<T> newNode = new Node<>(insertData, key);
if (root == null)
root = newNode;
else {
while (true) {
parent = current;
if (key < current.getKey()) {
current = current.getLeftChild();
if (current == null) {
parent.setLeftChild(newNode);
return;
}
}
else {
current = current.getRightChild();
if (current == null) {
parent.setRightChild(newNode);
return;
}
}
}
}
}
انهي حالت ۾، موجوده نوڊ جي اضافي ۾، اهو ضروري آهي ته موجوده نوڊ جي والدين بابت معلومات ذخيرو ڪرڻ لاء. جڏهن موجوده null جي برابر ٿي وڃي ٿي، والدين متغير ۾ اسان کي گهربل شيٽ شامل هوندي.
داخل ڪرڻ جي ڪارڪردگي واضح طور تي ساڳي ئي هوندي جيئن ڳولا جي - O(log(n)).
ختم ٿيل
هٽائڻ سڀ کان ڏکيو آپريشن آهي جيڪو وڻ تي ڪرڻو پوندو. اهو واضح آهي ته پهرين اسان کي اهو عنصر ڳولڻ جي ضرورت پوندي جنهن کي اسين حذف ڪرڻ وارا آهيون. پر پوءِ ڇا؟ جيڪڏهن اسان صرف ان جو حوالو null ڏانهن مقرر ڪريون ٿا، اسان ان ذيلي وڻ جي باري ۾ معلومات وڃائي ڇڏينداسين جنهن جو هي نوڊ روٽ آهي. وڻن کي ختم ڪرڻ جا طريقا ٽن ڪيسن ۾ ورهايل آهن.
پهريون ڪيس. ختم ٿيل نوڊ جو ڪو به اولاد ناهي
جيڪڏهن ختم ٿيڻ واري نوڊ کي ڪو به اولاد نه آهي، ته ان جو مطلب آهي ته اهو هڪ پتي آهي. تنهن ڪري، توهان صرف ان جي والدين جي leftChild يا rightChild فيلڊ کي null سيٽ ڪري سگهو ٿا.
ٻيو ڪيس. ختم ٿيڻ واري نوڊ کي ھڪڙو ٻار آھي
اهو معاملو پڻ تمام پيچيده ناهي. اچو ته اسان جي مثال ڏانهن موٽون. اچو ته چئون ته اسان کي ڪيئي 14 سان هڪ عنصر کي ختم ڪرڻ جي ضرورت آهي. اتفاق ڪيو ته جيئن ته اهو ڪي 10 سان هڪ نوڊ جو صحيح اولاد آهي، پوء ان جي اولاد مان ڪنهن به (هن صورت ۾ صحيح هڪ) کي 10 کان وڏي ڪيئي هوندي، تنهنڪري توهان ان کي وڻ مان آسانيءَ سان ”ڪٽ“ ڪري سگھجي ٿو، ۽ والدين کي سڌو سنئون ان نوڊ جي چائلڊ سان ڳنڍي سگھي ٿو، يعني ڊليٽ ڪيو پيو وڃي. نوڊ کي ڪيئي 10 سان نوڊ 13 سان ڳنڍيو. صورتحال ساڳي هوندي جيڪڏهن ڪنهن نوڊ کي ختم ڪرڻ ضروري هجي جيڪو ان جي والدين جي کاٻي ٻار آهي. ان جي باري ۾ پاڻ سوچيو - هڪ صحيح قياس.
ٽيون ڪيس. هڪ نوڊ کي ٻه ٻار آهن
سڀ کان ڏکيو ڪيس. اچو ته هڪ نئون مثال ڏسو.
جانشين جي ڳولا ڪريو
اچو ته چئون ته اسان کي ڪي 25 سان هڪ نوڊ ختم ڪرڻ جي ضرورت آهي. ان جي جاءِ تي اسان کي ڪير رکڻ گهرجي؟ سندس پوئلڳن مان هڪ (اولاد يا اولاد جو اولاد) ٿيڻ گهرجي جانشين(جيڪو نوڊ کي هٽائڻ جي جاء وٺندو).
ڪيئن سمجهڻ گهرجي ته ڪير جانشين ٿيڻ گهرجي؟ وجداني طور تي، هي وڻ ۾ هڪ نوڊ آهي جنهن جي ڪنجي کي ختم ٿيڻ واري نوڊ کان ايندڙ سڀ کان وڏو آهي. الورورٿم هن ريت آهي. توھان کي ان جي ساڄي اولاد ڏانھن وڃڻ جي ضرورت آھي (هميشه ساڄي طرف، ڇاڪاڻ ته اھو اڳ ۾ ئي چيو ويو آھي ته جانشين ڪيئي ختم ٿيڻ واري نوڊ جي ڪنجي کان وڏي آھي)، ۽ پوءِ ھن ساڄي اولاد جي کاٻي اولاد جي زنجير مان وڃو. . مثال ۾، اسان ڪيئي 35 سان نوڊ ڏانھن وڃون ٿا، ۽ پوء ان جي کاٻي ٻارن جي زنجير جي ذريعي پتي ڏانھن ھيٺ وڃو - ھن حالت ۾، ھي زنجير صرف نوڊ تي مشتمل آھي 30 سان. سختي سان ڳالهائڻ، اسان ڏسي رهيا آهيون نوڊس جي سيٽ ۾ سڀ کان ننڍي نوڊ لاءِ ان کان وڌيڪ وڏي نوڊ جنهن کي اسين ڳولي رهيا آهيون.
جانشين ڳولڻ جو طريقو ڪوڊ:
public Node<T> getSuccessor(Node<T> deleteNode) {
Node<T> parentSuccessor = deleteNode;//родитель преемника
Node<T> successor = deleteNode;//преемник
Node<T> current = successor.getRightChild();//просто "пробегающий" узел
while (current != null) {
parentSuccessor = successor;
successor = current;
current = current.getLeftChild();
}
//на выходе из цикла имеем преемника и родителя преемника
if (successor != deleteNode.getRightChild()) {//если преемник не совпадает с правым потомком удаляемого узла
parentSuccessor.setLeftChild(successor.getRightChild());//то его родитель забирает себе потомка преемника, чтобы не потерять его
successor.setRightChild(deleteNode.getRightChild());//связываем преемника с правым потомком удаляемого узла
}
return successor;
}
ختم ڪرڻ جو طريقو لاء مڪمل ڪوڊ:
public boolean delete(int deleteKey) {
Node<T> current = root;
Node<T> parent = current;
boolean isLeftChild = false;//В зависимости от того, является ли удаляемый узел левым или правым потомком своего родителя, булевская переменная isLeftChild будет принимать значение true или false соответственно.
while (current.getKey() != deleteKey) {
parent = current;
if (deleteKey < current.getKey()) {
current = current.getLeftChild();
isLeftChild = true;
} else {
isLeftChild = false;
current = current.getRightChild();
}
if (current == null)
return false;
}
if (current.getLeftChild() == null && current.getRightChild() == null) {//первый случай
if (current == root)
current = null;
else if (isLeftChild)
parent.setLeftChild(null);
else
parent.setRightChild(null);
}
else if (current.getRightChild() == null) {//второй случай
if (current == root)
root = current.getLeftChild();
else if (isLeftChild)
parent.setLeftChild(current.getLeftChild());
else
current.setRightChild(current.getLeftChild());
} else if (current.getLeftChild() == null) {
if (current == root)
root = current.getRightChild();
else if (isLeftChild)
parent.setLeftChild(current.getRightChild());
else
parent.setRightChild(current.getRightChild());
}
else {//третий случай
Node<T> successor = getSuccessor(current);
if (current == root)
root = successor;
else if (isLeftChild)
parent.setLeftChild(successor);
else
parent.setRightChild(successor);
}
return true;
}
پيچيدگي O(log(n)) جي لڳ ڀڳ ٿي سگھي ٿي.
وڻ ۾ وڌ ۾ وڌ / گھٽ ۾ گھٽ ڳولڻ
اهو واضح آهي ته هڪ وڻ ۾ گهٽ ۾ گهٽ / وڌ ۾ وڌ قدر ڪيئن ڳولهجي - توهان کي ترتيب سان وڻ جي کاٻي / ساڄي عناصر جي زنجير سان گڏ هلڻ جي ضرورت آهي. جڏھن توھان چادر ڏانھن وڃو، اھو ھوندو گھٽ ۾ گھٽ / وڌ ۾ وڌ عنصر.
public Node<T> getMinimum(Node<T> startPoint) {
Node<T> current = startPoint;
Node<T> parent = current;
while (current != null) {
parent = current;
current = current.getLeftChild();
}
return parent;
}
public Node<T> getMaximum(Node<T> startPoint) {
Node<T> current = startPoint;
Node<T> parent = current;
while (current != null) {
parent = current;
current = current.getRightChild();
}
return parent;
}
پيچيدگي - O(log(n))
سميٽيڪل بائي پاس
ٽرورسل وڻ جي هر نوڊ جو دورو ڪري رهيو آهي انهي سان گڏ ڪجهه عمل ڪرڻ لاءِ.
ورجائي سميٽرڪ ٽرورسل الگورٿم:
- کاٻي ٻار تي عمل ڪريو
- پنهنجو پاڻ سان عمل ڪريو
- صحيح ٻار تي عمل ڪريو
ڪوڊ
public void inOrder(Node<T> current) {
if (current != null) {
inOrder(current.getLeftChild());
System.out.println(current.getData() + " ");//Здесь может быть все, что угодно
inOrder(current.getRightChild());
}
}
ٿڪل
آخرڪار! جيڪڏهن مون ڪجهه وضاحت نه ڪئي آهي يا ڪا راءِ آهي، مهرباني ڪري انهن کي تبصرن ۾ ڇڏي ڏيو. جيئن واعدو ڪيو ويو، مان مڪمل ڪوڊ مهيا ڪريان ٿو.
Node.java:
public class Node<T> {
private T data;
private int key;
private Node<T> leftChild;
private Node<T> rightChild;
public Node(T data, int key) {
this.data = data;
this.key = key;
}
public void setLeftChild(Node<T> newNode) {
leftChild = newNode;
}
public void setRightChild(Node<T> newNode) {
rightChild = newNode;
}
public Node<T> getLeftChild() {
return leftChild;
}
public Node<T> getRightChild() {
return rightChild;
}
public T getData() {
return data;
}
public int getKey() {
return key;
}
}
BinaryTree.java:
public class BinaryTree<T> {
private Node<T> root;
public Node<T> find(int key) {
Node<T> current = root;
while (current.getKey() != key) {
if (key < current.getKey())
current = current.getLeftChild();
else
current = current.getRightChild();
if (current == null)
return null;
}
return current;
}
public void insert(T insertData, int key) {
Node<T> current = root;
Node<T> parent;
Node<T> newNode = new Node<>(insertData, key);
if (root == null)
root = newNode;
else {
while (true) {
parent = current;
if (key < current.getKey()) {
current = current.getLeftChild();
if (current == null) {
parent.setLeftChild(newNode);
return;
}
}
else {
current = current.getRightChild();
if (current == null) {
parent.setRightChild(newNode);
return;
}
}
}
}
}
public Node<T> getMinimum(Node<T> startPoint) {
Node<T> current = startPoint;
Node<T> parent = current;
while (current != null) {
parent = current;
current = current.getLeftChild();
}
return parent;
}
public Node<T> getMaximum(Node<T> startPoint) {
Node<T> current = startPoint;
Node<T> parent = current;
while (current != null) {
parent = current;
current = current.getRightChild();
}
return parent;
}
public Node<T> getSuccessor(Node<T> deleteNode) {
Node<T> parentSuccessor = deleteNode;
Node<T> successor = deleteNode;
Node<T> current = successor.getRightChild();
while (current != null) {
parentSuccessor = successor;
successor = current;
current = current.getLeftChild();
}
if (successor != deleteNode.getRightChild()) {
parentSuccessor.setLeftChild(successor.getRightChild());
successor.setRightChild(deleteNode.getRightChild());
}
return successor;
}
public boolean delete(int deleteKey) {
Node<T> current = root;
Node<T> parent = current;
boolean isLeftChild = false;
while (current.getKey() != deleteKey) {
parent = current;
if (deleteKey < current.getKey()) {
current = current.getLeftChild();
isLeftChild = true;
} else {
isLeftChild = false;
current = current.getRightChild();
}
if (current == null)
return false;
}
if (current.getLeftChild() == null && current.getRightChild() == null) {
if (current == root)
current = null;
else if (isLeftChild)
parent.setLeftChild(null);
else
parent.setRightChild(null);
}
else if (current.getRightChild() == null) {
if (current == root)
root = current.getLeftChild();
else if (isLeftChild)
parent.setLeftChild(current.getLeftChild());
else
current.setRightChild(current.getLeftChild());
} else if (current.getLeftChild() == null) {
if (current == root)
root = current.getRightChild();
else if (isLeftChild)
parent.setLeftChild(current.getRightChild());
else
parent.setRightChild(current.getRightChild());
}
else {
Node<T> successor = getSuccessor(current);
if (current == root)
root = successor;
else if (isLeftChild)
parent.setLeftChild(successor);
else
parent.setRightChild(successor);
}
return true;
}
public void inOrder(Node<T> current) {
if (current != null) {
inOrder(current.getLeftChild());
System.out.println(current.getData() + " ");
inOrder(current.getRightChild());
}
}
}
پي ايس
O(n) ڏانهن تنزل
توھان مان گھڻن کي محسوس ڪيو ويو آھي: جيڪڏھن توھان وڻ کي غير متوازن بڻايون؟ مثال طور، ڪنهن وڻ ۾ وڌايل ڪنجين سان نوڊس وجھو: 1,2,3,4,5,6... پوءِ وڻ ڪجهه حد تائين ڳنڍيل فهرست وانگر هوندو. ۽ ها، وڻ پنهنجي وڻ جي جوڙجڪ کي وڃائي ڇڏيندو، ۽ تنهن ڪري ڊيٽا جي رسائي جي ڪارڪردگي. ڳولها، داخل ڪرڻ، ۽ حذف ڪرڻ جي عملن جي پيچيدگي هڪ ڳنڍيل فهرست جي برابر ٿي ويندي: O(n). اهو سڀ کان اهم آهي، منهنجي خيال ۾، بائنري وڻن جي نقصانات.
صرف رجسٽرڊ استعمال ڪندڙ سروي ۾ حصو وٺي سگهن ٿا. ، توهان جي مهرباني.
مان گهڻو وقت تائين حب تي نه رهيو آهيان، ۽ مان ڄاڻڻ چاهيان ٿو ته توهان ڪهڙن عنوانن تي ڪهڙا مضمون وڌيڪ ڏسڻ چاهيندا؟
-
ڊيٽا جي جوڙجڪ
-
الگورتھم (DP، recursion، data compression، etc.)
-
حقيقي زندگي ۾ ڊيٽا جي جوڙجڪ ۽ الگورتھم جي درخواست
-
جاوا ۾ پروگرامنگ Android ايپليڪيشنون
-
جاوا ۾ ويب ايپليڪيشن پروگرامنگ
2 صارفين ووٽ ڏنو. 1 استعمال ڪندڙ روڪيو.
ذريعو: www.habr.com