Do you want to learn python from me with a lot of interactive quizzes, and exercises? Here is my project-based python learning course: codebasics.io/courses/python-for-beginner-and-intermediate-learners
Sir i usually watch videos in hindi because i grab the things more quicker than english tutorials but your explanation is very impressive the way you explain the things are excellent god bless you sir and i am praying that you stay healthy.
Thanks a ton Sir, Data structure series is much-appreciated series as it is the foundation of programming. Also, lots of University exams are pending due to COVID-19, series on data structure will really help. Amazing teaching skills :)
Thankyou very much sir for these amazing videos.. After 15 years I am learning these concepts again and now I am getting these concepts more clear because of your crystal clear and simple way of explanation. I have a query in the way your have defined elements in inorder,preorder and posrorder traversal. sometimes you have added as elements += self.left.in_order_traversal(). Sometimes it is elements.append(self.data) , sometimes elements = [self.data]. Looks like the list is appended in 3 different ways: += , appened, []. Please explain when do use each of these.
1) Append is to insert a single element into an existing list 2) += is two join two lists into a single list 3) [] is used to initialize a new list They all serve a different purpose
There is an error at around 21:30. You must return 'self.left.search(val)', otherwise your result will be 'None" since nothing is being returned to main.
Thanks a lot! Although, I have some difficulties understanding the the in_order_traversal method. I will appreciate if you could explain the elements+=self.left.in_order_traversal()
If the list is: [1, 2, 3, 4, 5] it's recursively calling the function on self.left, until it gets to the farthest left node. Eventually that final function returns a list of just: [1] The final function returns that list to the second last recursively called function, which adds it to it's own list to give us: [1, 2] And it keeps going, each recursively called function returns a list to the function called just before it. += in Python, when used with lists, adds two lists to eachother
@codebasics this is going to be a very specific request but can you please add a video explaining how to balance a binary tree to get the optimum performance and some of the special trees like AVL... Would be really helpful. I genuinely appreciate your work and have shared your playlists with my friends too. Thank you so much.
What if the number_list was [1, 4, 17 .... ]. In that case through your code, the root node would be 1 and the entire tree would be created to the right side of the root node. That means the root node is not really in the center of the two sub-trees. Then how exactly is this In-order traversal if there is no left sub-tree at all?
I have a question. If we start the input element [ ] from the minimum number, for example, 1. Does it still work? Cause it seems like the whole number tree is on the right side. Do we need to add some conditions or limitations to the input element? Or the right-side tree is okay?
Hello Dhaval, Much appreciated and many thanks for educating us. For the in order traversal , i some how feel that we can use list as class variable and then append the node data when we hit the exit condition of recursion to reduce the confusion which i felt. def in_order_traversal(self): if self.left: self.left.in_order_traversal() BinarySearchTreeNode.in_elements.append(self.data) if self.right: self.right.in_order_traversal() return BinarySearchTreeNode.in_elements
Really very happy about finding such an obvious and understood funny video series about data structures and algorithms. Everything is 100% clear with deeply explained theories and well-understood practicals. Also, the exercise series with the videos are highly appreciated. Dear sir thank you so much for the fantastic video series. ❤💖
hi , I tink the slid where you explaining the pre_order is having in correct array : [15, 7, 12, 14, 20, 23, 27, 88] -> I am using the same exact method and its not making an output like the one on slides , thanks
very honestly sir, This is my first tutorial i clear the problem within one hour, Dhaval sir u r a great teacher,please upload some more videos about improve programming skills,how improve logical thinking please sir, I really love u sir,May god bless for long live for u sir
Solution for post and pre traversal seems to be incorrect, maybe I'm wrong but it's only working when the list is already arranged in pre_order mode...........
Thanks a lot for posting these videos. I have been procrastinating algorithms and data structures for a while coz I wasn't able to understand data structures apart from arrays as well as recursion and after watching this video I am implementing linked list and BST in Python in just one day :D
If you are new, please watch the Recursion topic on the last chapter in this series, because this topic will use Recursion concepts extensively as should become the pre-requisite before you started.
00:01 Binary search tree is a special type of binary tree with ordering criteria 02:45 Binary Search Tree properties and search efficiency explained. 05:27 Binary search tree offers efficient search and insertion operations 08:11 Understanding inorder traversal in Binary Search Trees 10:47 Adding nodes to a binary search tree involves checking for existing values and determining the correct subtree to place the new node 14:03 Explanation of in-order traversal method in binary search tree 17:20 Building Binary Search Tree and its utilities 20:15 Recursion in binary search tree search operation 23:00 Enhance Binary Search Tree Node Class with Additional Methods
I really get surprised when some people actually work in white background. I think it is better if you use black background, it is easy on the eyes of people who are watching the video.
I am the fresher here and do i need these coding skills to crack any interviews bcoz i am pretty good at those topics but not on coding. Please reply anyone please!..
this is giving output None, why? def search(self,val): if self.data==val: return True if val < self.data: if self.left : self.left.search(val) else: return False if val > self.data : if self.right: self.right.search(val) else: return False
can someone explain how elements = [] can store values even after it is being re-initialized every time recursively at 18:07 and also the traversal function is wrong it gives wrong results please correct it, it fails to switch between the right of the left subtree and left of the right subtree. it just prints all the left together and all the rights together
Please, think before you write. Every time the function is called, a new elements variable is temporarily created. So there is an element list for every function call (This isn't a waste of memory since the variable are deleted after the function returns).
'elements' is not a global variable, it's local to the traversal function. So you call a traversal function and it allocates memory for a variable 'elements'. Then the function is called again recursively, and that newly called function also has it's own allocated memory which we've defined as elements. Two (or more) functions can have the same local variable name and still refer to different memory allocations
Sir, thank you for the session. However, We have to find all 3 traversals (in order , preorder, post order) by given graph. But the code is taking list as an input so how can I convert that graph into list
Data Structures Made easy. You are amazing sir, I understand the complete concept with USE CASE(Very important) in one shot. Moreover, how the complexity is calculated.Sir, may I know your name?
Hi, I have a question about the binary search tree. Is it possible if the right child node under node 7 at 5:56 is a number that is greater than 15 (for example 16). I think we can because you just mentioned that the right child node is larger than the value of the parent node and the left child node is lesser than the parent node. If 16 is able to be added under node 7, will the binary search algorithm for number 16 have some problem at the beginning, we choose to find the number from the right branch because 16 is larger than 15. I'm sorry for this long comment but I will appreciate any help! Thank you so much and have a great day!
def calculate_sum(self): left_sum = self.left.calculate_sum() if self.left else 0 right_sum = self.right.calculate_sum() if self.right else 0 return self.data + left_sum + right_sum This part i couldn't understand...how this left sum is adding all the item on the left and how right sum is adding all the of right... Can someone explain it ?
class binary(): def __init__(self,data): self.data=data self.left=None self.right=None def insert(self,val): if val==self.data: return if val self.data : if self.right: self.right.search(val) else: return False def build_tree(arr): root=binary(arr[0]) for i in range(1,len(arr)): root.insert(arr[i]) return root b=[2,4,3,5,3,6,7,0,11,8,4,7] tree=build_tree(b) print(tree.print()) print(tree.search(5))
Great tutorial, but could you please explain the line 14 self.left.add_child(data) part and the other ones that does the recursive function? Like what does the self.left have to do with the function? It doesn't change the value of the data right? So it just calls the function again with the same data.
@@magnacarta7045 I think the way it works is that it keeps calling itself until the self.left == None, or there are no other elements on the left. Then it assigns the node to be that new left element, so ig that's how it changes? I could be wrong so feel free to correct me
@@magnacarta7045 If you have a tree with 3 elements in the left node, then you call the function on the base node's self.left. Then the function calls itself on THAT node's self.left, which is like calling it on self.left.left on the original function. Eventually you get to the final node, which has self.left == None which is how the function knows when to stop
The sorting time complexity is O(H). H=height of the BST its important difference since if every child have only 1 child on 1 side, then time complexity can reach up to O(n) time. n=number of nodes.
Sir, Thank you for the tutorial, it helped me to understand BST better. However, I have a small doubt. For the above methods, when we are checking the search for the strings, we received none for sweden and uk. we modified the code using 'return'. However, when we used the same method for list of numbers , we got the boolean results correct. Could you please explain me why?
Is there any reason on line 45: self.left.search(val) and 51 we have the same thing but rigth... but now we add return? any reason we why need to return this part, figure those lines are just to jump from nodes to nodes, why do we need to return one and not the other?
Hi everyone! One question: with numbers =[17, 4, 1, 20, 9, 23, 18, 34], if I do numbers_tree.add_child(13), and check print(numbers_tree.right.data), 13 does not appear. However, the function in_order_transversal() is OK (output = [1, 4, 9, 13, 17, 18, 20, 23]). Any clue about it? Thank you!
If you built the tree with 17 as the root node (which is what this code does root = BinarySearchTreeNode(elements[0])) then the right node must be bigger, so I am guessing it will be 18. When you do add_child it runs through each node and checks to see if it is less or more then keeps going down that path. For example with 13, it will check against 17 and say its less, so it goes to left subtree and compare against that node and recursively ask less or more. 13 will end up SOMEWHERE in the LEFT subtree of 17.
Hi Dhaval, While going through the video again, I thought in the traversal for In Order and Pre Order, 23 comes before 20, as while visiting a node in DFS, the tread is till the leaf and then the previous nodes. This is my understanding. Please let me know if I am missing something. Want to get that cleared. Regards, Krish
try to debug on stack model, whereever the function is recalled, it will return to the same point after execution and remaining leftout portion of that function will execute
I have a small question to ask, Why are we defining the methods inside the class ? such as add_node, since root node is required everytime we add a node, It will unnecessarily increase the space complexity.
Ty very much for the explanation, i found it very easy to implement and understand but i have a question. Is it possible to do an AVL tree using this algorithm? I find it very hard to do
Hi Dhaval, You have presented the coding magic behind BST in a incisive way. Very precise in the coding structure. Excellent , once again. I have been recommending your videos many and it is sure to have multiplier effect. Regards, Krish
Sir, you are a lifesaver, the best tutorials on data structures and algorithms; thank you greatly. I am forever grateful, and I will recommend your tutorials to all my colleagues, thank you so much!
Lets say there's a list [1, 2, 3, 4, 5] Function will start at a root node (3) and initialize an empty list. First it checks self.left of 3, which exists as the node (2). It recursively runs the same function on that node(2). Because node (2) also has a self.left, it gets recursively run again on node (2) which gets us to node (1). Finally node (1) doesn't have self.left so it returns us a list of it's data, which is just: [1] So the function running on node (2) has the list [1] returned to it, and it adds [1] to it's own data via += so your new list is [1, 2]. Eventually it adds the node and then moves onto self.right, and eventually you have a list of elements in numerical order
I do not think that is the case in you example with his code. In his code he set the root as element[0]. In other words, your Node 1 will be the root based on the build_tree function. Then since all the numbers in the array is greater than the root. It would have a all be connected to the right of the node. It should look something like this. 1 --2 ---3 ----4 -----5
