কিভাবে একটি বাইনারি গাছ বাস্তবায়ন?
উত্তর:
বাইনারি অনুসন্ধান বৃক্ষের এখানে আমার সাধারণ পুনরাবৃত্তির বাস্তবায়ন।
#!/usr/bin/python
class Node:
def __init__(self, val):
self.l = None
self.r = None
self.v = val
class Tree:
def __init__(self):
self.root = None
def getRoot(self):
return self.root
def add(self, val):
if self.root is None:
self.root = Node(val)
else:
self._add(val, self.root)
def _add(self, val, node):
if val < node.v:
if node.l is not None:
self._add(val, node.l)
else:
node.l = Node(val)
else:
if node.r is not None:
self._add(val, node.r)
else:
node.r = Node(val)
def find(self, val):
if self.root is not None:
return self._find(val, self.root)
else:
return None
def _find(self, val, node):
if val == node.v:
return node
elif (val < node.v and node.l is not None):
self._find(val, node.l)
elif (val > node.v and node.r is not None):
self._find(val, node.r)
def deleteTree(self):
# garbage collector will do this for us.
self.root = None
def printTree(self):
if self.root is not None:
self._printTree(self.root)
def _printTree(self, node):
if node is not None:
self._printTree(node.l)
print(str(node.v) + ' ')
self._printTree(node.r)
# 3
# 0 4
# 2 8
tree = Tree()
tree.add(3)
tree.add(4)
tree.add(0)
tree.add(8)
tree.add(2)
tree.printTree()
print(tree.find(3).v)
print(tree.find(10))
tree.deleteTree()
tree.printTree()
চমৎকার বাস্তবায়ন। আমি এখানে কিছু স্টাইলের জিনিস দেখানোর জন্য আছি । অজগর সাধারণত
—
জেফ ম্যান্ডেল
node is not Noneআপনার পরিবর্তে করে (node!=None)। এছাড়াও, আপনি __str__মুদ্রণযন্ত্র পদ্ধতির পরিবর্তে ফাংশনটি ব্যবহার করতে পারেন ।
এছাড়াও, আপনার
—
_ফ্যান্ডটি
def _find(self, val, node): if(val == node.v): return node elif(val < node.v and node.l != None): return self._find(val, node.l) elif(val > node.v and node.r != None): return self._find(val, node.r)
এটি একটি বাইনারি অনুসন্ধান গাছ কোথায়
—
সাগর শাহ 13
left<=root<=right?
ট্রি.ফাইন্ড (0), ট্রি.ফাইন্ড (2), ট্রি.ফাইন্ড (4), ট্রি.ফাইন্ড (8) সমস্ত কিছুই প্রত্যাবর্তন করে না।
—
টনি ওয়াং
একটি ছোট ত্রুটি রয়েছে, আপনি যখন একটি বিদ্যমান কী sertোকানোর চেষ্টা করবেন তখন এটি ডুপ্লিকেট কী দিয়ে একটি নতুন নোড তৈরি করতে গাছের নীচে নেমে যাবে।
—
দিয়েগো
# simple binary tree
# in this implementation, a node is inserted between an existing node and the root
class BinaryTree():
def __init__(self,rootid):
self.left = None
self.right = None
self.rootid = rootid
def getLeftChild(self):
return self.left
def getRightChild(self):
return self.right
def setNodeValue(self,value):
self.rootid = value
def getNodeValue(self):
return self.rootid
def insertRight(self,newNode):
if self.right == None:
self.right = BinaryTree(newNode)
else:
tree = BinaryTree(newNode)
tree.right = self.right
self.right = tree
def insertLeft(self,newNode):
if self.left == None:
self.left = BinaryTree(newNode)
else:
tree = BinaryTree(newNode)
tree.left = self.left
self.left = tree
def printTree(tree):
if tree != None:
printTree(tree.getLeftChild())
print(tree.getNodeValue())
printTree(tree.getRightChild())
# test tree
def testTree():
myTree = BinaryTree("Maud")
myTree.insertLeft("Bob")
myTree.insertRight("Tony")
myTree.insertRight("Steven")
printTree(myTree)এটি সম্পর্কে আরও পড়ুন এখানে: -এটি বাইনারি গাছের একটি খুব সাধারণ বাস্তবায়ন ।
এটি মধ্যে প্রশ্ন সহ একটি দুর্দান্ত টিউটোরিয়াল
কোডটি নষ্ট
—
বাম
insertLeftহয়ে গেছে এবং বাইনারি গাছের
নিম্নলিখিত লাইনগুলি অদলবদল করে এটি সহজেই ঠিক করা যেতে পারে: ট্রি.লেফ্ট = সেলফ.লফ্ট সেলফেল্ট = ট্রি
—
আইরেলেজাব
শেষ লিঙ্কটি নষ্ট হয়ে গেছে। আপনি এটা ঠিক করতে পারবো.
—
আরজি
[আপনাকে সাক্ষাত্কারের জন্য যা প্রয়োজন] একটি নোড ক্লাস হ'ল বাইনারি গাছ উপস্থাপনের জন্য পর্যাপ্ত ডেটা স্ট্রাকচার।
(অন্য উত্তরগুলি বেশিরভাগ ক্ষেত্রে সঠিক হলেও, বাইনারি গাছের জন্য এগুলি প্রয়োজন হয় না: বস্তুর শ্রেণি প্রসারিত করার দরকার নেই, বিএসটি হওয়ার দরকার নেই, ডিউক আমদানি করার দরকার নেই)।
class Node:
def __init__(self, value = None):
self.left = None
self.right = None
self.value = valueএখানে একটি গাছের উদাহরণ রয়েছে:
n1 = Node(1)
n2 = Node(2)
n3 = Node(3)
n1.left = n2
n1.right = n3এই উদাহরণে এন 1 হ'ল গাছের মূল হ'ল n2, n3 এর শিশু হিসাবে।
এটি ইতিমধ্যে অন্যান্য অনেক উত্তর বর্ণিত আছে এর বাইরে কিছু যুক্ত করে?
—
স্নেফটেল
@ স্নেফটেল অন্যান্য উত্তরগুলি বাইনারি গাছের জন্য পরিশীলিত। বাইনারি ট্রি প্রয়োগের জন্য এটি প্রয়োজনীয় টুকরা। অন্যান্য উত্তরগুলি নতুন ব্যক্তির পক্ষে বুঝতে অসুবিধা বোধ করছে তাই আমি ভেবেছিলাম নতুন ব্যক্তিকে সাহায্য করার জন্য কেবল সর্বনিম্ন পোস্ট করুন। অন্যান্য উত্তরগুলির কয়েকটি নিবন্ধ এবং জার্নাল কাগজপত্রের জন্য ভাল;) এটি সফ্টওয়্যার সাক্ষাত্কারের জন্য কারওর প্রয়োজন।
—
অপাদানা
এটি সরলতা যোগ করে, যা মূল্যবান।
—
পাইংং
সহজ এবং খুব যৌক্তিক। গ্রেট। আমি এটা পছন্দ করি!
—
অ্যাপোস্টোলোস
পাইথনে বিএসটি-র সহজ বাস্তবায়ন
class TreeNode:
def __init__(self, value):
self.left = None
self.right = None
self.data = value
class Tree:
def __init__(self):
self.root = None
def addNode(self, node, value):
if(node==None):
self.root = TreeNode(value)
else:
if(value<node.data):
if(node.left==None):
node.left = TreeNode(value)
else:
self.addNode(node.left, value)
else:
if(node.right==None):
node.right = TreeNode(value)
else:
self.addNode(node.right, value)
def printInorder(self, node):
if(node!=None):
self.printInorder(node.left)
print(node.data)
self.printInorder(node.right)
def main():
testTree = Tree()
testTree.addNode(testTree.root, 200)
testTree.addNode(testTree.root, 300)
testTree.addNode(testTree.root, 100)
testTree.addNode(testTree.root, 30)
testTree.printInorder(testTree.root)
আপনি কিছু বাক্যটি সেমিকোলন দিয়ে এবং কিছুটি সেমিকোলন ছাড়াই শেষ করেছেন। আপনি দয়া করে এর কারণ ব্যাখ্যা করতে পারেন? পিএস - আমি পাইথন শিক্ষানবিস, সে কারণেই এ জাতীয় প্রাথমিক প্রশ্ন জিজ্ঞাসা করছি।
—
আউটলেয়ার 229
@ আউটিলার 229 উপরের কোডের সমস্ত সেমিকোলনগুলি alচ্ছিক, এগুলি সরিয়ে কোনও কিছুই পরিবর্তন করে না। আমার অনুমান যে ফক্স কেবলমাত্র সি ++ বা জাভা জাতীয় ভাষার কোডিংয়ের জন্য ব্যবহৃত হয়, যার জন্য লাইনের শেষে সেমিকোলন প্রয়োজন। Thatচ্ছিক ব্যবহার বাদে সেমিকোলনগুলি একক লাইনে স্টেটমেন্ট চেইনে ব্যবহার করা যেতে পারে। উদাহরণস্বরূপ a = 1; খ = 2; সি = 3 পাইথনে একটি বৈধ একক লাইন হবে।
—
পদার্থবিজ্ঞান
তালিকাগুলি ব্যবহার করে বাইনারি গাছ প্রয়োগের খুব দ্রুত 'নোংরা উপায়। সর্বাধিক দক্ষ নয়, এটি শূন্য মানগুলিও খুব ভালভাবে পরিচালনা করে না। তবে এটি খুব স্বচ্ছ (অন্তত আমার কাছে):
def _add(node, v):
new = [v, [], []]
if node:
left, right = node[1:]
if not left:
left.extend(new)
elif not right:
right.extend(new)
else:
_add(left, v)
else:
node.extend(new)
def binary_tree(s):
root = []
for e in s:
_add(root, e)
return root
def traverse(n, order):
if n:
v = n[0]
if order == 'pre':
yield v
for left in traverse(n[1], order):
yield left
if order == 'in':
yield v
for right in traverse(n[2], order):
yield right
if order == 'post':
yield vএকটি পুনরাবৃত্তিযোগ্য থেকে একটি গাছ নির্মাণ:
>>> tree = binary_tree('A B C D E'.split())
>>> print tree
['A', ['B', ['D', [], []], ['E', [], []]], ['C', [], []]]একটি গাছ পাড়ি:
>>> list(traverse(tree, 'pre')), list(traverse(tree, 'in')), list(traverse(tree, 'post'))
(['A', 'B', 'D', 'E', 'C'],
['D', 'B', 'E', 'A', 'C'],
['D', 'E', 'B', 'C', 'A'])
খুব সুন্দর! আমি সাহায্য করতে পারিনি তবে মন্তব্য করতে পারলাম যে ফলস্বরূপ গাছ আক্রমণকারীকে ধরে না যে বাম সাবট্রির সমস্ত উপাদান ভি। এর চেয়ে কম - বাইনারি অনুসন্ধানের গাছগুলির জন্য গুরুত্বপূর্ণ এমন একটি সম্পত্তি। (হ্যাঁ আমি বুঝতে পারি যে ওপি একটি "অনুসন্ধান ট্রি" চাইবে না) তবে এফডাব্লুআইডাব্লু _এডডিতে চেকটিতে একটি সাধারণ পরিবর্তন করে এটি করা যেতে পারে) তারপরে আপনার ইনঅর্ডার ট্র্যাভারসাল একটি বাছাই তালিকা দেয়।
—
থায়নে
আমি সাহায্য করতে পারি না তবে লক্ষ্য করতে পারি যে এখানে বেশিরভাগ উত্তরগুলি বাইনারি অনুসন্ধান ট্রি বাস্তবায়ন করছে। বাইনারি অনুসন্ধান ট্রি! = বাইনারি ট্রি
একটি বাইনারি অনুসন্ধান গাছের একটি খুব নির্দিষ্ট সম্পত্তি রয়েছে: যে কোনও নোড এক্সের জন্য, এক্স এর কী তার বাম সন্তানের যে কোনও বংশধরের চাবি থেকে বড় এবং তার ডান সন্তানের বংশধরের চাবি থেকেও ছোট।
বাইনারি ট্রি এ জাতীয় কোনও বিধিনিষেধ আরোপ করে না। একটি বাইনারি ট্রি কেবল একটি 'কী' উপাদান সহ একটি ডেটা স্ট্রাকচার এবং দুটি বাচ্চা 'বাম' এবং 'ডান' বলে say
একটি গাছ একটি বাইনারি গাছের আরও সাধারণ কেস যেখানে প্রতিটি নোডে একটি নির্বিচার সংখ্যক শিশু থাকতে পারে। সাধারণত, প্রতিটি নোডে একটি 'শিশু' উপাদান থাকে যা টাইপ তালিকা / অ্যারের হয়।
এখন, ওপি-র প্রশ্নের উত্তর দেওয়ার জন্য, আমি পাইথনে বাইনারি ট্রি পুরোপুরি বাস্তবায়ন সহ অন্তর্ভুক্ত করছি। প্রতিটি বাইনারিট্রনোড সংরক্ষণ করে রাখার অন্তর্নিহিত ডেটা স্ট্রাকচারটি একটি অভিধান, এটি সর্বোত্তম ও (1) লুপ اپ সরবরাহ করে। আমি গভীরতার সাথে প্রথম এবং প্রস্থের প্রথম ট্র্যাভারসালও প্রয়োগ করেছি। এগুলি গাছগুলিতে সঞ্চালিত খুব সাধারণ অপারেশন।
from collections import deque
class BinaryTreeNode:
def __init__(self, key, left=None, right=None):
self.key = key
self.left = left
self.right = right
def __repr__(self):
return "%s l: (%s) r: (%s)" % (self.key, self.left, self.right)
def __eq__(self, other):
if self.key == other.key and \
self.right == other.right and \
self.left == other.left:
return True
else:
return False
class BinaryTree:
def __init__(self, root_key=None):
# maps from BinaryTreeNode key to BinaryTreeNode instance.
# Thus, BinaryTreeNode keys must be unique.
self.nodes = {}
if root_key is not None:
# create a root BinaryTreeNode
self.root = BinaryTreeNode(root_key)
self.nodes[root_key] = self.root
def add(self, key, left_key=None, right_key=None):
if key not in self.nodes:
# BinaryTreeNode with given key does not exist, create it
self.nodes[key] = BinaryTreeNode(key)
# invariant: self.nodes[key] exists
# handle left child
if left_key is None:
self.nodes[key].left = None
else:
if left_key not in self.nodes:
self.nodes[left_key] = BinaryTreeNode(left_key)
# invariant: self.nodes[left_key] exists
self.nodes[key].left = self.nodes[left_key]
# handle right child
if right_key == None:
self.nodes[key].right = None
else:
if right_key not in self.nodes:
self.nodes[right_key] = BinaryTreeNode(right_key)
# invariant: self.nodes[right_key] exists
self.nodes[key].right = self.nodes[right_key]
def remove(self, key):
if key not in self.nodes:
raise ValueError('%s not in tree' % key)
# remove key from the list of nodes
del self.nodes[key]
# if node removed is left/right child, update parent node
for k in self.nodes:
if self.nodes[k].left and self.nodes[k].left.key == key:
self.nodes[k].left = None
if self.nodes[k].right and self.nodes[k].right.key == key:
self.nodes[k].right = None
return True
def _height(self, node):
if node is None:
return 0
else:
return 1 + max(self._height(node.left), self._height(node.right))
def height(self):
return self._height(self.root)
def size(self):
return len(self.nodes)
def __repr__(self):
return str(self.traverse_inorder(self.root))
def bfs(self, node):
if not node or node not in self.nodes:
return
reachable = []
q = deque()
# add starting node to queue
q.append(node)
while len(q):
visit = q.popleft()
# add currently visited BinaryTreeNode to list
reachable.append(visit)
# add left/right children as needed
if visit.left:
q.append(visit.left)
if visit.right:
q.append(visit.right)
return reachable
# visit left child, root, then right child
def traverse_inorder(self, node, reachable=None):
if not node or node.key not in self.nodes:
return
if reachable is None:
reachable = []
self.traverse_inorder(node.left, reachable)
reachable.append(node.key)
self.traverse_inorder(node.right, reachable)
return reachable
# visit left and right children, then root
# root of tree is always last to be visited
def traverse_postorder(self, node, reachable=None):
if not node or node.key not in self.nodes:
return
if reachable is None:
reachable = []
self.traverse_postorder(node.left, reachable)
self.traverse_postorder(node.right, reachable)
reachable.append(node.key)
return reachable
# visit root, left, then right children
# root is always visited first
def traverse_preorder(self, node, reachable=None):
if not node or node.key not in self.nodes:
return
if reachable is None:
reachable = []
reachable.append(node.key)
self.traverse_preorder(node.left, reachable)
self.traverse_preorder(node.right, reachable)
return reachableআপনার দুটি ক্লাস করার দরকার নেই
class Tree:
val = None
left = None
right = None
def __init__(self, val):
self.val = val
def insert(self, val):
if self.val is not None:
if val < self.val:
if self.left is not None:
self.left.insert(val)
else:
self.left = Tree(val)
elif val > self.val:
if self.right is not None:
self.right.insert(val)
else:
self.right = Tree(val)
else:
return
else:
self.val = val
print("new node added")
def showTree(self):
if self.left is not None:
self.left.showTree()
print(self.val, end = ' ')
if self.right is not None:
self.right.showTree()
@ user3022012 আপনার মন্তব্যটি কেবল ভুল। সংজ্ঞা অনুসারে, একটি গাছ তথ্য এবং উপ গাছ দ্বারা গঠিত হয় (বাইনারি গাছের জন্য এটি দুটি উপ-গাছ), যা গাছও। কোনও কারণ নেই, রুট নোডকে গাছ থেকে আলাদাভাবে যা করা উচিত।
—
গিয়ারাড
মূল পোস্টারটিতে কেবল বাইনারি ট্রি প্রয়োগের জন্য বলা হয়েছিল বাইনারি অনুসন্ধানের গাছের জন্য নয় ...
—
লোকারাড
আরও কিছুটা "পাইথোনিক"?
class Node:
def __init__(self, value):
self.value = value
self.left = None
self.right = None
def __repr__(self):
return str(self.value)
class BST:
def __init__(self):
self.root = None
def __repr__(self):
self.sorted = []
self.get_inorder(self.root)
return str(self.sorted)
def get_inorder(self, node):
if node:
self.get_inorder(node.left)
self.sorted.append(str(node.value))
self.get_inorder(node.right)
def add(self, value):
if not self.root:
self.root = Node(value)
else:
self._add(self.root, value)
def _add(self, node, value):
if value <= node.value:
if node.left:
self._add(node.left, value)
else:
node.left = Node(value)
else:
if node.right:
self._add(node.right, value)
else:
node.right = Node(value)
from random import randint
bst = BST()
for i in range(100):
bst.add(randint(1, 1000))
print (bst)#!/usr/bin/python
class BinaryTree:
def __init__(self, left, right, data):
self.left = left
self.right = right
self.data = data
def pre_order_traversal(root):
print(root.data, end=' ')
if root.left != None:
pre_order_traversal(root.left)
if root.right != None:
pre_order_traversal(root.right)
def in_order_traversal(root):
if root.left != None:
in_order_traversal(root.left)
print(root.data, end=' ')
if root.right != None:
in_order_traversal(root.right)
def post_order_traversal(root):
if root.left != None:
post_order_traversal(root.left)
if root.right != None:
post_order_traversal(root.right)
print(root.data, end=' ')
প্রাক-অর্ডার ট্র্যাভারসালটি ভুল: আপনার প্রতিটি শাখা পৃথকভাবে পরীক্ষা করা দরকার।
—
সোভান্তে
আমি মনে করি, কেবল প্রতিটি ক্রম এবং পোস্ট অর্ডারের ক্ষেত্রে আপনাকে প্রতিটি শাখা পৃথকভাবে পরীক্ষা করতে হবে। প্রাক-অর্ডার পদ্ধতি আমি লিখেছি, সঠিক ফলাফল দেয়। আপনি কি আমাকে বলতে পারবেন কোন ক্ষেত্রে এই পদ্ধতিটি ভেঙে যাবে? যাইহোক, আমাকে উভয় শাখা আলাদাভাবে পরীক্ষা করা যাক যেমন আমি পোস্ট-অর্ডার করার জন্য এবং ইন-অর্ডার করেছেন
—
Shanks
এটি যেভাবে ছিল, বাম শিশুটি যদি না হয় তবে এটি ডান সন্তানের দিকে তাকাবে না।
—
সোভান্তে
আমি বোঝাতে চাইছি, যদি বাইনারি গাছের বাম বাচ্চা কেউ না হয় তবে আমরা ধরে নিতে পারি যে ডান সন্তানও তেমন নেই। যদি কোনও নোড 2 এবং কেবল 2 নোডে শাখা করে এবং বামটি কোনও হয় না, ডানটিও কোনও হবে না।
—
eshanrh
Nodeসংযুক্ত নোডগুলির একটি ভিত্তিক শ্রেণি একটি মানক পদ্ধতির। এগুলি কল্পনা করা শক্ত হতে পারে to
একটি থেকে প্রেরণা প্রবন্ধ উপর পাইথন প্যাটার্নস - বাস্তবায়নকারী গ্রাফ , একটি সহজ অভিধান বিবেচনা করুন:
প্রদত্ত
একটি বাইনারি গাছ
a
/ \
b c
/ \ \
d e fকোড
অনন্য নোডের একটি অভিধান তৈরি করুন :
tree = {
"a": ["b", "c"],
"b": ["d", "e"],
"c": [None, "f"],
"d": [None, None],
"e": [None, None],
"f": [None, None],
}বিস্তারিত
- প্রতিটি কী-মান জোড় একটি অনন্য নোড তার বাচ্চাদের দেখানোর ।
- একটি তালিকা (বা টিপল) বাম / ডান বাচ্চাদের একটি অর্ডারযুক্ত জোড় ধারণ করে।
- একটি ডিক দিয়ে সন্নিবেশের আদেশ দেওয়া হয়েছে , ধরে নিন প্রথম প্রবেশটি মূল is
- সাধারণ পদ্ধতিগুলি এমন ফাংশন হতে পারে যা ডিককে পরিবর্তন করে বা অতিক্রম করে (দেখুন
find_all_paths())।
গাছ-ভিত্তিক ফাংশনগুলির মধ্যে প্রায়শই নিম্নলিখিত সাধারণ ক্রিয়াকলাপগুলি অন্তর্ভুক্ত থাকে:
- ট্র্যাভার্স : প্রদত্ত ক্রমে প্রতিটি নোড উত্পাদন করুন (সাধারণত বাম থেকে ডানদিকে)
- প্রস্থের প্রথম অনুসন্ধান (বিএফএস): ট্র্যাভার্স স্তর
- গভীরতা-প্রথম অনুসন্ধান (ডিএফএস): প্রথমে ট্র্যাভার্স শাখা (প্রাক-ইন-ইন / / পোস্ট-অর্ডার)
- সন্নিবেশ করুন : বাচ্চাদের সংখ্যার উপর নির্ভর করে গাছে একটি নোড যুক্ত করুন
- সরান : বাচ্চার সংখ্যার উপর নির্ভর করে একটি নোড সরান
- আপডেট : এক গাছ থেকে অন্য গাছে গায়েবি নোডগুলি মার্জ করুন
- দর্শন করুন : একটি ট্র্যাভার্সড নোডের মান অর্জন করুন
এই সমস্ত অপারেশন বাস্তবায়নের চেষ্টা করুন। এখানে আমরা প্রকট এক এই ফাংশন - একটি এই বি ট্র্যাভেরসাল:
উদাহরণ
import collections as ct
def traverse(tree):
"""Yield nodes from a tree via BFS."""
q = ct.deque() # 1
root = next(iter(tree)) # 2
q.append(root)
while q:
node = q.popleft()
children = filter(None, tree.get(node))
for n in children: # 3
q.append(n)
yield nodelist(traverse(tree))
# ['a', 'b', 'c', 'd', 'e', 'f']এটি নোড এবং শিশুদের একটি ডিকের জন্য প্রয়োগ করা প্রস্থের প্রথম অনুসন্ধান (স্তর-ক্রম) অ্যালগরিদম ।
- একটি ফিফোর সারি শুরু করুন । আমরা একটি ব্যবহার করি
deque, তবে একটিqueueবা একটিlistকাজ (পরেরটি অক্ষম)। - রুট নোডটি পান এবং সজ্জিত করুন (ধরে নিন যে মূলটি ডাইকের প্রথম অধ্যায়, পাইথন ৩.+++)।
- স্বতঃস্ফূর্তভাবে একটি নোডের সন্ধান করুন, এর শিশুদের সজ্জিত করুন এবং নোডের মান দিন yield
গাছের উপর এই গভীরতার টিউটোরিয়ালটিও দেখুন ।
সূক্ষ্মদৃষ্টি
ট্র্যাভারসালগুলি সম্পর্কে সাধারণভাবে দুর্দান্ত কিছু, আমরা সহজেই গভীরতার প্রথম অনুসন্ধান (ডিএফএস) এর পরবর্তী পুনরাবৃত্তির পদ্ধতির পরিবর্তনটি কেবল স্ট্যাক (ওরফে LIFO সারি) দিয়ে সারিটি প্রতিস্থাপনের মাধ্যমে সহজেই পরিবর্তন করতে পারি । এর সহজ অর্থ হল আমরা যে দিকটি উত্থাপন করি সেদিক থেকে আমরা প্রসূত হই। ডিএফএস আমাদের প্রতিটি শাখা অনুসন্ধান করতে দেয়।
কিভাবে? যেহেতু আমরা একটি ব্যবহার করছেন deque, আমরা পরিবর্তন করে একটি স্ট্যাক অনুকরণ করতে node = q.popleft()করতে node = q.pop()(ডান)। এর ফলে ডান-বিশেষ সুবিধাপ্রাপ্ত হয়, অগ্রিম-বরাত দেওয়া DFS : ['a', 'c', 'f', 'b', 'e', 'd']।
import random
class TreeNode:
def __init__(self, key):
self.key = key
self.left = None
self.right = None
self.p = None
class BinaryTree:
def __init__(self):
self.root = None
def length(self):
return self.size
def inorder(self, node):
if node == None:
return None
else:
self.inorder(node.left)
print node.key,
self.inorder(node.right)
def search(self, k):
node = self.root
while node != None:
if node.key == k:
return node
if node.key > k:
node = node.left
else:
node = node.right
return None
def minimum(self, node):
x = None
while node.left != None:
x = node.left
node = node.left
return x
def maximum(self, node):
x = None
while node.right != None:
x = node.right
node = node.right
return x
def successor(self, node):
parent = None
if node.right != None:
return self.minimum(node.right)
parent = node.p
while parent != None and node == parent.right:
node = parent
parent = parent.p
return parent
def predecessor(self, node):
parent = None
if node.left != None:
return self.maximum(node.left)
parent = node.p
while parent != None and node == parent.left:
node = parent
parent = parent.p
return parent
def insert(self, k):
t = TreeNode(k)
parent = None
node = self.root
while node != None:
parent = node
if node.key > t.key:
node = node.left
else:
node = node.right
t.p = parent
if parent == None:
self.root = t
elif t.key < parent.key:
parent.left = t
else:
parent.right = t
return t
def delete(self, node):
if node.left == None:
self.transplant(node, node.right)
elif node.right == None:
self.transplant(node, node.left)
else:
succ = self.minimum(node.right)
if succ.p != node:
self.transplant(succ, succ.right)
succ.right = node.right
succ.right.p = succ
self.transplant(node, succ)
succ.left = node.left
succ.left.p = succ
def transplant(self, node, newnode):
if node.p == None:
self.root = newnode
elif node == node.p.left:
node.p.left = newnode
else:
node.p.right = newnode
if newnode != None:
newnode.p = node.p
এটি চালানোর পরে, নতুন নোডগুলি z, y, x, w, u, v কখনও কখনও বরাদ্দ করা যেতে পারে, কখনও কখনও বাগগুলি থাকতে পারে: u.key অ্যাট্রিবিউটর: মুদ্রণ 'ন্যানটাইপ' অবজেক্টটির কোনও বৈশিষ্ট্য নেই 'কী' আমি ভাবছি কীভাবে এটি ঠিক করার জন্য, ধন্যবাদ
—
1'5 এ জল 0
এই বাস্তবায়ন গাছের গঠন বিনষ্ট না করে সন্নিবেশ, অনুসন্ধান এবং মোছা সমর্থন করে। এটি কোনও সজ্জিত গাছ নয়।
# Class for construct the nodes of the tree. (Subtrees)
class Node:
def __init__(self, key, parent_node = None):
self.left = None
self.right = None
self.key = key
if parent_node == None:
self.parent = self
else:
self.parent = parent_node
# Class with the structure of the tree.
# This Tree is not balanced.
class Tree:
def __init__(self):
self.root = None
# Insert a single element
def insert(self, x):
if(self.root == None):
self.root = Node(x)
else:
self._insert(x, self.root)
def _insert(self, x, node):
if(x < node.key):
if(node.left == None):
node.left = Node(x, node)
else:
self._insert(x, node.left)
else:
if(node.right == None):
node.right = Node(x, node)
else:
self._insert(x, node.right)
# Given a element, return a node in the tree with key x.
def find(self, x):
if(self.root == None):
return None
else:
return self._find(x, self.root)
def _find(self, x, node):
if(x == node.key):
return node
elif(x < node.key):
if(node.left == None):
return None
else:
return self._find(x, node.left)
elif(x > node.key):
if(node.right == None):
return None
else:
return self._find(x, node.right)
# Given a node, return the node in the tree with the next largest element.
def next(self, node):
if node.right != None:
return self._left_descendant(node.right)
else:
return self._right_ancestor(node)
def _left_descendant(self, node):
if node.left == None:
return node
else:
return self._left_descendant(node.left)
def _right_ancestor(self, node):
if node.key <= node.parent.key:
return node.parent
else:
return self._right_ancestor(node.parent)
# Delete an element of the tree
def delete(self, x):
node = self.find(x)
if node == None:
print(x, "isn't in the tree")
else:
if node.right == None:
if node.left == None:
if node.key < node.parent.key:
node.parent.left = None
del node # Clean garbage
else:
node.parent.right = None
del Node # Clean garbage
else:
node.key = node.left.key
node.left = None
else:
x = self.next(node)
node.key = x.key
x = None
# tests
t = Tree()
t.insert(5)
t.insert(8)
t.insert(3)
t.insert(4)
t.insert(6)
t.insert(2)
t.delete(8)
t.delete(5)
t.insert(9)
t.insert(1)
t.delete(2)
t.delete(100)
# Remember: Find method return the node object.
# To return a number use t.find(nº).key
# But it will cause an error if the number is not in the tree.
print(t.find(5))
print(t.find(8))
print(t.find(4))
print(t.find(6))
print(t.find(9))আমি জানি অনেক ভাল সমাধান ইতিমধ্যে পোস্ট করা হয়েছে তবে বাইনারি গাছগুলির জন্য আমার সাধারণত আলাদা পদ্ধতির থাকে: কিছু নোড শ্রেণীর সাথে যাওয়া এবং সরাসরি এটি প্রয়োগ করা আরও পঠনযোগ্য তবে যখন আপনার কাছে প্রচুর নোড থাকে এটি স্মৃতি সম্পর্কে খুব লোভী হয়ে উঠতে পারে, তাই আমি জটিলতার একটি স্তর যুক্ত করার এবং পাইথন তালিকায় নোডগুলি সংরক্ষণ করার পরামর্শ দিন এবং তারপরে কেবল তালিকাটি ব্যবহার করে গাছের আচরণ অনুকরণ করুন।
আপনি প্রয়োজনে গাছের নোডগুলি অবশেষে উপস্থাপন করতে একটি নোড শ্রেণিকে এখনও সংজ্ঞায়িত করতে পারেন, তবে তালিকায় একটি সাধারণ আকারে [মান, বাম, ডান] রেখে অর্ধেক স্মৃতি বা তার চেয়ে কম ব্যবহার করবেন!
এখানে অ্যারে নোডগুলি সংরক্ষণ করে বাইনারি অনুসন্ধান বৃক্ষ শ্রেণীর একটি দ্রুত উদাহরণ। এটি অ্যাড, রিমুভ, স ...
"""
Basic Binary Search Tree class without recursion...
"""
__author__ = "@fbparis"
class Node(object):
__slots__ = "value", "parent", "left", "right"
def __init__(self, value, parent=None, left=None, right=None):
self.value = value
self.parent = parent
self.left = left
self.right = right
def __repr__(self):
return "<%s object at %s: parent=%s, left=%s, right=%s, value=%s>" % (self.__class__.__name__, hex(id(self)), self.parent, self.left, self.right, self.value)
class BinarySearchTree(object):
__slots__ = "_tree"
def __init__(self, *args):
self._tree = []
if args:
for x in args[0]:
self.add(x)
def __len__(self):
return len(self._tree)
def __repr__(self):
return "<%s object at %s with %d nodes>" % (self.__class__.__name__, hex(id(self)), len(self))
def __str__(self, nodes=None, level=0):
ret = ""
if nodes is None:
if len(self):
nodes = [0]
else:
nodes = []
for node in nodes:
if node is None:
continue
ret += "-" * level + " %s\n" % self._tree[node][0]
ret += self.__str__(self._tree[node][2:4], level + 1)
if level == 0:
ret = ret.strip()
return ret
def __contains__(self, value):
if len(self):
node_index = 0
while self._tree[node_index][0] != value:
if value < self._tree[node_index][0]:
node_index = self._tree[node_index][2]
else:
node_index = self._tree[node_index][3]
if node_index is None:
return False
return True
return False
def __eq__(self, other):
return self._tree == other._tree
def add(self, value):
if len(self):
node_index = 0
while self._tree[node_index][0] != value:
if value < self._tree[node_index][0]:
b = self._tree[node_index][2]
k = 2
else:
b = self._tree[node_index][3]
k = 3
if b is None:
self._tree[node_index][k] = len(self)
self._tree.append([value, node_index, None, None])
break
node_index = b
else:
self._tree.append([value, None, None, None])
def remove(self, value):
if len(self):
node_index = 0
while self._tree[node_index][0] != value:
if value < self._tree[node_index][0]:
node_index = self._tree[node_index][2]
else:
node_index = self._tree[node_index][3]
if node_index is None:
raise KeyError
if self._tree[node_index][2] is not None:
b, d = 2, 3
elif self._tree[node_index][3] is not None:
b, d = 3, 2
else:
i = node_index
b = None
if b is not None:
i = self._tree[node_index][b]
while self._tree[i][d] is not None:
i = self._tree[i][d]
p = self._tree[i][1]
b = self._tree[i][b]
if p == node_index:
self._tree[p][5-d] = b
else:
self._tree[p][d] = b
if b is not None:
self._tree[b][1] = p
self._tree[node_index][0] = self._tree[i][0]
else:
p = self._tree[i][1]
if p is not None:
if self._tree[p][2] == i:
self._tree[p][2] = None
else:
self._tree[p][3] = None
last = self._tree.pop()
n = len(self)
if i < n:
self._tree[i] = last[:]
if last[2] is not None:
self._tree[last[2]][1] = i
if last[3] is not None:
self._tree[last[3]][1] = i
if self._tree[last[1]][2] == n:
self._tree[last[1]][2] = i
else:
self._tree[last[1]][3] = i
else:
raise KeyError
def find(self, value):
if len(self):
node_index = 0
while self._tree[node_index][0] != value:
if value < self._tree[node_index][0]:
node_index = self._tree[node_index][2]
else:
node_index = self._tree[node_index][3]
if node_index is None:
return None
return Node(*self._tree[node_index])
return Noneআমি একটি প্যারেন্ট বৈশিষ্ট্য যুক্ত করেছি যাতে আপনি যে কোনও নোড অপসারণ করতে পারেন এবং বিএসটি কাঠামো বজায় রাখতে পারেন।
পাঠযোগ্যতার জন্য দুঃখিত, বিশেষত "অপসারণ" ফাংশনের জন্য। মূলত, যখন কোনও নোড অপসারণ করা হয়, আমরা গাছের অ্যারেটি পপ করে শেষ উপাদান দিয়ে প্রতিস্থাপন করি (যদি আমরা শেষ নোডটি সরাতে চাইতাম তবে) if বিএসটি কাঠামো বজায় রাখতে, অপসারণ নোডটি তার বাম বাচ্চাদের সর্বাধিক বা তার ডান বাচ্চাদের ন্যূনতমের সাথে প্রতিস্থাপন করা হয় এবং সূচিগুলি বৈধ রাখতে কিছু অপারেশন করতে হবে তবে এটি যথেষ্ট দ্রুত।
আমি অভ্যন্তরীণ র্যাডিক্স ট্রাই সহ কয়েকটি বড় শব্দের অভিধান তৈরি করতে আরও প্রযুক্তিগত জিনিসগুলির জন্য এই কৌশলটি ব্যবহার করেছি এবং আমি মেমরির খরচ 7-8 দ্বারা বিভক্ত করতে সক্ষম হয়েছি (আপনি এখানে একটি উদাহরণ দেখতে পারেন: https://gist.github.com/fbparis / b3ddd5673b603b42c880974b23db7cda )
বাইনারি অনুসন্ধান গাছের একটি ভাল বাস্তবায়ন , এখান থেকে নেওয়া :
'''
A binary search Tree
'''
from __future__ import print_function
class Node:
def __init__(self, label, parent):
self.label = label
self.left = None
self.right = None
#Added in order to delete a node easier
self.parent = parent
def getLabel(self):
return self.label
def setLabel(self, label):
self.label = label
def getLeft(self):
return self.left
def setLeft(self, left):
self.left = left
def getRight(self):
return self.right
def setRight(self, right):
self.right = right
def getParent(self):
return self.parent
def setParent(self, parent):
self.parent = parent
class BinarySearchTree:
def __init__(self):
self.root = None
def insert(self, label):
# Create a new Node
new_node = Node(label, None)
# If Tree is empty
if self.empty():
self.root = new_node
else:
#If Tree is not empty
curr_node = self.root
#While we don't get to a leaf
while curr_node is not None:
#We keep reference of the parent node
parent_node = curr_node
#If node label is less than current node
if new_node.getLabel() < curr_node.getLabel():
#We go left
curr_node = curr_node.getLeft()
else:
#Else we go right
curr_node = curr_node.getRight()
#We insert the new node in a leaf
if new_node.getLabel() < parent_node.getLabel():
parent_node.setLeft(new_node)
else:
parent_node.setRight(new_node)
#Set parent to the new node
new_node.setParent(parent_node)
def delete(self, label):
if (not self.empty()):
#Look for the node with that label
node = self.getNode(label)
#If the node exists
if(node is not None):
#If it has no children
if(node.getLeft() is None and node.getRight() is None):
self.__reassignNodes(node, None)
node = None
#Has only right children
elif(node.getLeft() is None and node.getRight() is not None):
self.__reassignNodes(node, node.getRight())
#Has only left children
elif(node.getLeft() is not None and node.getRight() is None):
self.__reassignNodes(node, node.getLeft())
#Has two children
else:
#Gets the max value of the left branch
tmpNode = self.getMax(node.getLeft())
#Deletes the tmpNode
self.delete(tmpNode.getLabel())
#Assigns the value to the node to delete and keesp tree structure
node.setLabel(tmpNode.getLabel())
def getNode(self, label):
curr_node = None
#If the tree is not empty
if(not self.empty()):
#Get tree root
curr_node = self.getRoot()
#While we don't find the node we look for
#I am using lazy evaluation here to avoid NoneType Attribute error
while curr_node is not None and curr_node.getLabel() is not label:
#If node label is less than current node
if label < curr_node.getLabel():
#We go left
curr_node = curr_node.getLeft()
else:
#Else we go right
curr_node = curr_node.getRight()
return curr_node
def getMax(self, root = None):
if(root is not None):
curr_node = root
else:
#We go deep on the right branch
curr_node = self.getRoot()
if(not self.empty()):
while(curr_node.getRight() is not None):
curr_node = curr_node.getRight()
return curr_node
def getMin(self, root = None):
if(root is not None):
curr_node = root
else:
#We go deep on the left branch
curr_node = self.getRoot()
if(not self.empty()):
curr_node = self.getRoot()
while(curr_node.getLeft() is not None):
curr_node = curr_node.getLeft()
return curr_node
def empty(self):
if self.root is None:
return True
return False
def __InOrderTraversal(self, curr_node):
nodeList = []
if curr_node is not None:
nodeList.insert(0, curr_node)
nodeList = nodeList + self.__InOrderTraversal(curr_node.getLeft())
nodeList = nodeList + self.__InOrderTraversal(curr_node.getRight())
return nodeList
def getRoot(self):
return self.root
def __isRightChildren(self, node):
if(node == node.getParent().getRight()):
return True
return False
def __reassignNodes(self, node, newChildren):
if(newChildren is not None):
newChildren.setParent(node.getParent())
if(node.getParent() is not None):
#If it is the Right Children
if(self.__isRightChildren(node)):
node.getParent().setRight(newChildren)
else:
#Else it is the left children
node.getParent().setLeft(newChildren)
#This function traversal the tree. By default it returns an
#In order traversal list. You can pass a function to traversal
#The tree as needed by client code
def traversalTree(self, traversalFunction = None, root = None):
if(traversalFunction is None):
#Returns a list of nodes in preOrder by default
return self.__InOrderTraversal(self.root)
else:
#Returns a list of nodes in the order that the users wants to
return traversalFunction(self.root)
#Returns an string of all the nodes labels in the list
#In Order Traversal
def __str__(self):
list = self.__InOrderTraversal(self.root)
str = ""
for x in list:
str = str + " " + x.getLabel().__str__()
return str
def InPreOrder(curr_node):
nodeList = []
if curr_node is not None:
nodeList = nodeList + InPreOrder(curr_node.getLeft())
nodeList.insert(0, curr_node.getLabel())
nodeList = nodeList + InPreOrder(curr_node.getRight())
return nodeList
def testBinarySearchTree():
r'''
Example
8
/ \
3 10
/ \ \
1 6 14
/ \ /
4 7 13
'''
r'''
Example After Deletion
7
/ \
1 4
'''
t = BinarySearchTree()
t.insert(8)
t.insert(3)
t.insert(6)
t.insert(1)
t.insert(10)
t.insert(14)
t.insert(13)
t.insert(4)
t.insert(7)
#Prints all the elements of the list in order traversal
print(t.__str__())
if(t.getNode(6) is not None):
print("The label 6 exists")
else:
print("The label 6 doesn't exist")
if(t.getNode(-1) is not None):
print("The label -1 exists")
else:
print("The label -1 doesn't exist")
if(not t.empty()):
print(("Max Value: ", t.getMax().getLabel()))
print(("Min Value: ", t.getMin().getLabel()))
t.delete(13)
t.delete(10)
t.delete(8)
t.delete(3)
t.delete(6)
t.delete(14)
#Gets all the elements of the tree In pre order
#And it prints them
list = t.traversalTree(InPreOrder, t.root)
for x in list:
print(x)
if __name__ == "__main__":
testBinarySearchTree()আমি @ অপদানের পদ্ধতির একটি প্রকরণটি দেখাতে চাই, যখন যথেষ্ট সংখ্যক নোড থাকে তখন এটি আরও কার্যকর হয়:
'''
Suppose we have the following tree
10
/ \
11 9
/ \ / \
7 12 15 8
'''
# Step 1 - Create nodes - Use a list instead of defining each node separately
nlist = [10,11,7,9,15,8,12]; n = []
for i in range(len(nlist)): n.append(Node(nlist[i]))
# Step 2 - Set each node position
n[0].left = n[1]
n[1].left = n[2]
n[0].right = n[3]
n[3].left = n[4]
n[3].right = n[5]
n[1].right = n[6]class Node:
"""
single Node for tree
"""
def __init__(self, data):
self.data = data
self.right = None
self.left = None
class binaryTree:
"""
binary tree implementation
"""
def __init__(self):
self.root = None
def push(self, element, node=None):
if node is None:
node = self.root
if self.root is None:
self.root = Node(element)
else:
if element < node.data:
if node.left is not None:
self.push(element, node.left)
else:
node.left = Node(element)
else:
if node.right is not None:
self.push(element, node.right)
else:
node.right = Node(element)
def __str__(self):
self.printInorder(self.root)
return "\n"
def printInorder(self, node):
"""
print tree in inorder
"""
if node is not None:
self.printInorder(node.left)
print(node.data)
self.printInorder(node.right)
def main():
"""
Main code and logic comes here
"""
tree = binaryTree()
tree.push(5)
tree.push(3)
tree.push(1)
tree.push(3)
tree.push(0)
tree.push(2)
tree.push(9)
tree.push(10)
print(tree)
if __name__ == "__main__":
main()পাইথনে বাইনারি ট্রি
class Tree(object):
def __init__(self):
self.data=None
self.left=None
self.right=None
def insert(self, x, root):
if root==None:
t=node(x)
t.data=x
t.right=None
t.left=None
root=t
return root
elif x<root.data:
root.left=self.insert(x, root.left)
else:
root.right=self.insert(x, root.right)
return root
def printTree(self, t):
if t==None:
return
self.printTree(t.left)
print t.data
self.printTree(t.right)
class node(object):
def __init__(self, x):
self.x=x
bt=Tree()
root=None
n=int(raw_input())
a=[]
for i in range(n):
a.append(int(raw_input()))
for i in range(n):
root=bt.insert(a[i], root)
bt.printTree(root)এখানে একটি সহজ সমাধান যা বাইনারি ট্রি তৈরি করতে ব্যবহার করা যেতে পারে যাতে গাছগুলি প্রদর্শন করতে পুনরাবৃত্ত পদ্ধতির সাহায্যে ট্রভারসালকে নীচের কোডটিতে ব্যবহার করা হয়।
class Node(object):
def __init__(self):
self.left = None
self.right = None
self.value = None
@property
def get_value(self):
return self.value
@property
def get_left(self):
return self.left
@property
def get_right(self):
return self.right
@get_left.setter
def set_left(self, left_node):
self.left = left_node
@get_value.setter
def set_value(self, value):
self.value = value
@get_right.setter
def set_right(self, right_node):
self.right = right_node
def create_tree(self):
_node = Node() #creating new node.
_x = input("Enter the node data(-1 for null)")
if(_x == str(-1)): #for defining no child.
return None
_node.set_value = _x #setting the value of the node.
print("Enter the left child of {}".format(_x))
_node.set_left = self.create_tree() #setting the left subtree
print("Enter the right child of {}".format(_x))
_node.set_right = self.create_tree() #setting the right subtree.
return _node
def pre_order(self, root):
if root is not None:
print(root.get_value)
self.pre_order(root.get_left)
self.pre_order(root.get_right)
if __name__ == '__main__':
node = Node()
root_node = node.create_tree()
node.pre_order(root_node)থেকে নেওয়া কোড: পাইথনে বাইনারি ট্রি