Save Successor Validated with airSlate SignNow

Save successor validated

hey what's up guys nobody right technically stuff on Twitter in YouTube check description for all my information we're gonna be doing valid binary search tree my my grandma's house but I did not want to miss a day of uploading so a medium problem given a binary search given a binary tree determine if it's a valid binary search tree okay so we're giving a route to a binary tree and it's gonna be called is valid BST it's a boolean method we're gonna return true or false whether it is a valid binary search tree so each node we can see has a value a left child and a right child leaf nodes you know like 1 and 3 here right the nodes at the very bottom you could say you can see they don't have children so their left and right values would just be null okay so we're gonna start at the root and you know we're just gonna traverse the tree and make sure it's a valid binary search tree it says assume BST is defined as false left subtree of a node contains only nodes keys less than weight left subtree of a node contains only nodes with keys less than the nodes key okay right subtree only contains only nodes with keys greater than the nodes key so they're not allowing duplicates by this definition so we're gonna have to check against duplicates as well so both the left and right subtrees must also be binary search trees okay so what they're just saying is if you guys don't know this yeah this a BST binary search tree is just where the left children are less than the root in the right children are greater so 1 is less than 2 and 3 is greater than 2 so that is correct that is a valid binary search tree see would return true on this input here but if you look at an input like this where we have you know 5 1 4 3 6 right 1 is less than 5 so the left is less than the root which is good but 4 is also less than 5 and 4 should be on the left in that case so this is not valid and it gives you that exact answer right there so how do we do this how do you traverse a tree right there's a few traversal methods there's very popular ones right so there are you know in order pre order post or those are popular traversal methods and these are just referring to the order you traverse than root note right so out of three nodes right there's a root node and then there's the left and right child right so the root node in pre-order pre means first so it would be root then left right post order root is last so left right root in order root is in the middle so you got left root right so we want to do in order because if you actually look at it in order is a sorted version so binary search is done on sorted arrays binary search trees you've gotta see this traversal pattern as being sorted you know 1 2 3 right that's actually pretty much sorted so from left to right is sorted in a left root right is gonna be sorted in order traversal so we want to make sure that it is sorted right so that's why in order is kind of the one we're gonna go with you we can do this iteratively now there are some weird test cases in this problem so we're gonna have to actually use a double at some point in this problem to handle they do like very high double integer values so we're gonna be using a double and the main idea here is we're gonna use a stack here's the here's the main idea of this problem how we're gonna solve it we're gonna look at this root we're going to traverse all the way down the left side so we're gonna go to the least you know hi the smallest value node sorry my dogs barking the smallest value node in the entire tree and we're as we traverse all the way down the left side of the tree we're gonna be pushing values onto a stack parent node values and then what we're gonna do once we fill up the stack is we're gonna start popping stack values off so the stacks gonna get filled with parent nodes we're gonna traverse all the way down the left side and we're gonna pop stack values off and as we do this we're gonna you just keep referencing you know more and more parent nodes and making sure that the order is in place so hopefully that kind of makes sense so here we go we're just gonna set up our stack of tree nodes here we're gonna set up this double this is gonna be left child val is equal to negative doubled Val you gotta use this because it's weird our main condition is while stack is not empty or sorry root is not equal to null so we use this condition because we're gonna be filling up a stack so while it's not empty we're gonna want to keep traversing but also we want to have or route is not equal to null first because we need to enter the loop there's gonna be nothing on the stack originally so the route isn't null hopefully if it is if it is null we're just gonna return true anyway that will discount that as a valid binary search tree that's how the problem wants it but other than that it won't be null right because then there is some kind of tree so it will enter this loop now within here we're gonna say while root is not equal to null and we're gonna make root no we're gonna traverse until root is null but this won't break out of this loop because we're gonna fill up the stack within this loop right so we're gonna traverse until root is null all the way down the left side like I said and fill the stack up with values push values onto the stack push them onto the stack and these will be parent values right you could think of it as parent values because 5 is gonna go on the stack then one's gonna go on the stack or two is gonna go on the stack then one's gonna go in a second in this tree example it would be one on the stack then two on the stack then four on the stack right so we're pushing these parent values onto the stack root equals root dot left and we're traversing all the way down the left side now once we actually fill up the stack with all of these values when we traverse all the way the left we can start popping values off the stack and this is just gonna be a parent value right here now we want to make sure that the parent value is definitely not less than the left child value the left child value should always be less than the parent value and we're gonna return false that's why we can return true outside of this loop because we're returning false we're doing all of our checks to make sure that it's good within we're trying to disprove within this loop that is a valid binary search tree so if we find any discrepancies here or we find an error in the binary in the structure of the binary search tree we'll return false and then if we make it through this entire loop we can return true right so the only check we really have to do is okay is the left child less than the parent if that's true we're gonna be good right and each level right we're traversing we traversed all of the left notes right we're always traversing the left notes because within each iteration of this loop we're checking are we at the left most node we could possibly be at this current level and if not we're gonna keep going putting on the stack and we're always doing the parents because the parents are essentially left nodes anyway of you know the parent like every left node is pretty much gonna be some kind of parent in a bigger tree right so you know the parents get popped off so we got the parents covered we got the left notes covered the only thing we don't have covered is we do have to traverse the right side at each level if there is a right side so we just have to do this root is equal to root table right in each level and we do have to assign this left child Val whenever we do at right after we do this check it's like the left we we go down the left we put all the nodes on the stack these are parent nodes and we compare against left child Val it's a minute first because it's gonna be the very left most node anyway so after it's a very MUC mo so we come around again right so if we put one in five on the stack or two and one on the stack we look at one and it's gonna be null versus one it doesn't even matter we have this negative double so we're gonna say is one less is a one less than the minimum value possible no obviously not okay but then we go to two is two less than one because it's just gonna be the previous value because we signed left child value to the previous root so the root is the parent right it's gonna be one and then is one less than this minimum value no and then we say okay left is equal left child value is equal to one and then we go around and then two gets popped off the stack okay is one less is two less than one no and then you assign the next one but you always have to check to the right no to so when you get to two then you say okay root is equal to three okay so now you know what I mean it keeps going so basically you put all these parent nodes onto the stack you pop up you you know each iteration of the loop you're making sure you're at the leftmost no within this loop filling up the stack making sure you're filling up the stack you're popping those parent values off making sure the left is less than the parent this is is parent less than the left and whenever there's write notes to traverse you make sure you go down those bright paths too with this line right here that's it you just prove within the loop and you return true on the outside so I'm one of my grandmas sorry if it was a little bit different than my videos I don't even have my mic I didn't you know maybe there was a interruptions or anything but I don't think it was that bad so I just want to make sure I post every day because I want to grow the channel and yeah that's it so please like and subscribe to help me do that and you know I'll be back in my house later today and I'll be maybe screaming working on some more videos for you guys thank you guys for watching comment below videos you want me to do ask me any questions you got and yeah that's pretty much it see you in the next video alright