@@sharcodesthe guy speaking in the video is alive but the other cofounder passed away. Because of that he stopped making these videos but he works at google now
If anyone thinking that what if head pointer is not global then here's the code struct node* reverse(struct node* ptr){ struct node* head; if(ptr->next==NULL){ head=ptr; return head; } head=reverse(ptr->next); struct node* temp=ptr->next; temp->next=ptr; ptr->next=NULL; return head; }
i checked one further on each call, that way you can get rid of temp node Node* reverse_r(Node * root, Node * out=NULL){ if(root->next->next==NULL){ out=root->next; root->next->next=root; } else{ out = reverse_r(root->next); root->next->next=root; root->next=NULL; } return out; }
Best videos on Data Structure. I am a masters student and all these videos seriously helped me for interview preparation. Please do post some more videos on Trees and Graphs and bit manipulation. Really appreciate your way of explanation
Hi, the way u are presenting the things really awesome...! I think this is the most easiest way to reverse a list. explanation: In the last recursive call previous will be last element in the list and that will be turned out to first (header). otherwise just change the next pointer to previous element. void List::reverse(Node* current,Node* previous) { if (current == NULL) { m_header = previous; return; } reverse(current->next,current); current->next=previous; }
Amazing series of videos so far. I'm very thankful for its quality, and I hope that its author rests in peace. I had already done linked lists, but I had never used recursion on them. Brilliant. In order to better dive into the topics, I usually try to figure out a solution before watching videos or reading solutions in books. In this case, the solution I came up with did not presuppose a global pointer to the first node, so the function I created is fully self-contained: list * list_reverse(list *lst, list *prev) { list *head = NULL; if(lst != NULL) { head = list_reverse(lst->next, lst); lst->next = prev; } else { head = prev; } return head; } It takes two parameters: the first node (lst), and the previous node's pointer (prev), which would be NULL since the first node would not have any node prior to it. It returns a pointer to the new head of the list, the new first node. It creates a pointer named head that will be used to keep track of the first node. It verifies whether the node it received as a parameter is NULL. If it is not NULL, it calls itself recursively using its next element as the first node, and itself as the previous node, and changes the current node's next to the previous one provided as the prev parameter. (That means that the first node's next will become NULL.) If the lst parameter (current node) is null, the head pointer is changed to the previous node's address, or to NULL if it was the only node. After the if statement, the function returns the head pointer. That return of the head pointer is important, as it will be set when the end of the list is reached, and will be preserved as-is across the recursion. Example of usage: mylist = list_append(mylist, data1); mylist = list_append(mylist, data2); mylist = list_reverse(mylist, NULL); When using the function, the *prev parameter should always be NULL. If it is not, the list's last node's next pointer will point to whatever you chose, and the list will not end properly. Example of mistake: mylist = list_reverse(mylist, mylist); //
I tried solving this on my own before watching the video and this is what I came up with. The solution in the video is correct and mine works too. Some of you may find it useful. From the main(), I called reverse(head, NULL); void reverse(struct node* p, struct node * prev) { if(head==NULL) { return; } if(p->ptr==NULL) { head=p; return; } rev(p->next,p); p->next=prev; }
Before watching the video, I tried to do it on my own and I did it. Guys first try it yourself by using your own logic and implementation. Then you will learn better. Here is my approach - // called reverseListUsingRecursion(NULL,head) in main() void reverseListUsingRecursion(Node* prev,Node* current){
if(current==NULL) return; Node *Current = current; Node *Next = current->next; current->next = prev; head = Current; reverseListUsingRecursion(Current,Next); } BTW this guy is the best teacher :).
Another approcah:: it will return new head pointer from main call :: Node* head = reverse(head, NULL); where pre is the previous node(which at start postioin is null); Node* reverse(Node* head, Node* pre){ Node* newNode; if(head == NULL){ newNode = pre; return pre; } Node* temp = head->next; head->next = pre; return reverse(temp, head); }
Looking forward to when you will do graph algorithms and dynamic programming algorithms: MST, shortest path, LCS, Edit distance, longest common substring, longest palindromic substring, ...
We can reverse a linked list this way also. void reverseLinkedList(struct Node* prev, struct Node* curr) { if ( curr == NULL) { head = prev; return; } reverseLinkedList(curr, curr->next); curr->next = prev; } CALL -> reverseLinkedList(NULL, head); His explanation is really tremendous, No one can't recover your place. hats off humblefool
@@latchmanakumar7404 We can pass by reference head and it will update the same: #include using namespace std; struct node { int data; node *next; node(int data) { this->data = data; next = NULL; } }; void reverse(node **head, node *cur) { if (!cur || !cur->next) { *head = cur; return; } reverse(head, cur->next); cur->next->next = cur; cur->next = NULL; } void print_ll(node *head) { while (head) { cout data next; } cout next = new node(2); head->next->next = new node(3); head->next->next->next = new node(4); head->next->next->next->next = new node(5); head->next->next->next->next->next = new node(6); head->next->next->next->next->next->next = new node(7); cout
Amazing explanation of Reversing Linked List using recursion. Such a nice use of algo. It was like watching TV inside TV inside TV and then coming out of it. Kudos to mycodeschool. Hats off ! Please answer a question of how Stack vs Heap works in Java which pure object oriented and donot uses pointers. Hoping to get your reply soon and eagerly waiting for more such videos.
if head is not global variable, try this void Reverse(ListNode** A, ListNode* p){ if(p->next == NULL){ *A = p; return; } Reverse(A,p->next); p->next->next =p; p->next=NULL; } main(){ if(A==NULL) return A; Reverse(&A,A); return A; }
Thanks a lot Kundan, I have replied to your comment on other video.the idea of stack and heap as design concept for execution of programs is same in java also. We do not have pointer variables, but references pretty much work the same way. Its just that language does not give you freedom to see address in a reference variable and increment or decrement it which anyway is dangerous. The heap is totally managed in java. So, you do not have to bother up freeing up memory on heap.
This is awesome. But I think head moves everytime p->next == NULL holds true, which is kinda not what we want. Mycodeschool is my favorite though. superlike.
Kuchh log chale jaate hain par aisi chhap chhor jaate hain ki maano aisa lagta hai jaise vo abhi bhi hamaarre biich hain. Stilll guiding me through your video lectures . _/\_ RIP
I thought why he inserted the statement p->next = NULL; because I thought we can substitute p->next with the next recursion. But the code was needed for the last node - that was first the head node.
Actually we can achieve the same using fewer variables ( though at the cost of code readability ): struct node* reverse_ll_recursive(struct node *head){ if(head->next==NULL) return head; Node *q=reverse_ll_recursive(head->next); head->next->next=head; head->next=NULL; return q; // q stores value of the new head. }
i wrote this way.......my function returns a node pointer and in main function the head is then assigned to the last node. like this ---- head = reverse_list_recursively(head); /*function code*/ node* reverse_list_recursively(node *cur) { if(cur->next == NULL) { return cur; } else { reverse_list_recursively(cur->next)->next = cur; return cur; } }
Python Ruby When exit condition is hit, recursive call Reverse(250) returns and entry of that call will be removed from stack. So, when the actual pointer adjustment starts the top record on stack is for Reverse(150) and hence p was 150
p will be equal to 250 only if (p == NULL) because in this condition the last value will be passed to reverse function will be NULL due to which p=250 will be secured, instead of if(p->next == NULL) where the last value in reverse function is 250 due to which p=250 will not be secured and we get p=150. This all happens because the last call of the reverse function will return first in the if statement.
Please help! you lost me at 6:10 marker! please explain how P is pointing at node 150? also once recursion is finished and last three lines begin, you set Node* q = p -> next; // q is pointing to nullptr and then you set q->next = p; but how can you set a nullptr to point to p?
so after 3 hours of trying to figure out how! It has come to my realization that once the stack begins to unwind it will "start" from Reverse(150) and not Reverse(250) because Reverse(250) was "completed" with the RETURN statement! Phew!! Thank you this is a wonderful video my friend!!
thank you very much mycodeschool!!! do you have any tipnns on how to formulate the algorithms of recursion. i can understand recursion code when i see one but i dont know how to design the algorithm. please help and tips :D
An error is an error, Abhishek. There are many people, who are just beginning to learn, who might not be smart enough to realise that. So stop acting smart!
if (!p) return; // this should be the first statement of the function. If using NULL, can equivalently write "if (p == NULL) return;" This will only be true if the first node, also called the "head" is NULL. Otherwise (if the "head" is not NULL), "if (p->next == NULL)" will always be true before "if (p == NULL)" would ever be true.
can you please explain before q is initialized how p is set to 150 instead of 250 ? as I see the condition p-> next==NULL, so i think it will reach end(250) and not 150. thanks in advance
8 years later, still one of the best video to understand this topic.
you will shock to know the creator of this channel is no more.
I must Say he was Gems ans his content made him eternal.
@@sharcodesthe guy speaking in the video is alive but the other cofounder passed away. Because of that he stopped making these videos but he works at google now
@@sharcodes The creator is alive and well. His friend and cofounder died in an unfortunate accident. He stopped making videos after that.
yes sir
If anyone thinking that what if head pointer is not global then here's the code
struct node* reverse(struct node* ptr){
struct node* head;
if(ptr->next==NULL){
head=ptr;
return head;
}
head=reverse(ptr->next);
struct node* temp=ptr->next;
temp->next=ptr;
ptr->next=NULL;
return head;
}
Thankyou
Thank you
i checked one further on each call, that way you can get rid of temp node
Node* reverse_r(Node * root, Node * out=NULL){
if(root->next->next==NULL){
out=root->next;
root->next->next=root;
}
else{
out = reverse_r(root->next);
root->next->next=root;
root->next=NULL;
}
return out;
}
@@manfredoweber3562 This fails if the size of the LinkedList is 1
Brilliant teaching on tough subject. On 6:50, the memory address of the right most node is 150.
i was so confused
yes
me too
Best videos on Data Structure. I am a masters student and all these videos seriously helped me for interview preparation. Please do post some more videos on Trees and Graphs and bit manipulation. Really appreciate your way of explanation
bhai konsi company me ho ab muje lelo apke company me
He is no more so can't post.
@@redgamer6105 thank you!!
11 years later , revising this topic from the videos feels nostalgic
Come back @mycodeschool❤❤😭😭😭😭😭
He is dead
@@vedsinha9905 yeah 😭
he is dead ????
@@DexTech Nope, he is working in google, one of other cofounder(humble fool) is dead.
@@gauti_ humble fool ??
Only video that explains how the call stack executes and reverses the links of the list...thanks for the explanation
Hi, the way u are presenting the things really awesome...!
I think this is the most easiest way to reverse a list.
explanation: In the last recursive call previous will be last element in the list and that will be turned out to first (header). otherwise just change the next pointer to previous element.
void List::reverse(Node* current,Node* previous)
{
if (current == NULL)
{
m_header = previous;
return;
}
reverse(current->next,current);
current->next=previous;
}
You rock man! I was a little worried because of the accent that I won't be able to understand well, but you explain extremely well and clear. Kudos!
Amazing series of videos so far. I'm very thankful for its quality, and I hope that its author rests in peace.
I had already done linked lists, but I had never used recursion on them. Brilliant. In order to better dive into the topics, I usually try to figure out a solution before watching videos or reading solutions in books. In this case, the solution I came up with did not presuppose a global pointer to the first node, so the function I created is fully self-contained:
list * list_reverse(list *lst, list *prev) {
list *head = NULL;
if(lst != NULL) {
head = list_reverse(lst->next, lst);
lst->next = prev;
} else {
head = prev;
}
return head;
}
It takes two parameters: the first node (lst), and the previous node's pointer (prev), which would be NULL since the first node would not have any node prior to it.
It returns a pointer to the new head of the list, the new first node.
It creates a pointer named head that will be used to keep track of the first node.
It verifies whether the node it received as a parameter is NULL.
If it is not NULL, it calls itself recursively using its next element as the first node, and itself as the previous node, and changes the current node's next to the previous one provided as the prev parameter. (That means that the first node's next will become NULL.)
If the lst parameter (current node) is null, the head pointer is changed to the previous node's address, or to NULL if it was the only node.
After the if statement, the function returns the head pointer. That return of the head pointer is important, as it will be set when the end of the list is reached, and will be preserved as-is across the recursion.
Example of usage:
mylist = list_append(mylist, data1);
mylist = list_append(mylist, data2);
mylist = list_reverse(mylist, NULL);
When using the function, the *prev parameter should always be NULL. If it is not, the list's last node's next pointer will point to whatever you chose, and the list will not end properly. Example of mistake:
mylist = list_reverse(mylist, mylist); //
I guess u'r a teacher. Well explained.
I tried solving this on my own before watching the video and this is what I came up with. The solution in the video is correct and mine works too. Some of you may find it useful. From the main(), I called reverse(head, NULL);
void reverse(struct node* p, struct node * prev)
{
if(head==NULL)
{
return;
}
if(p->ptr==NULL)
{
head=p;
return;
}
rev(p->next,p);
p->next=prev;
}
Before watching the video, I tried to do it on my own and I did it. Guys first try it yourself by using your own logic and implementation. Then you will learn better. Here is my approach -
// called reverseListUsingRecursion(NULL,head) in main()
void reverseListUsingRecursion(Node* prev,Node* current){
if(current==NULL) return;
Node *Current = current;
Node *Next = current->next;
current->next = prev;
head = Current;
reverseListUsingRecursion(Current,Next);
}
BTW this guy is the best teacher :).
where are we printing brother?
After watching so many video , got clarity here -- thank you for such a clean explanation.
thanks man i searched many videos on this topic but found yours's the best
Another approcah::
it will return new head pointer
from main call :: Node* head = reverse(head, NULL);
where pre is the previous node(which at start postioin is null);
Node* reverse(Node* head, Node* pre){
Node* newNode;
if(head == NULL){
newNode = pre;
return pre;
}
Node* temp = head->next;
head->next = pre;
return reverse(temp, head);
}
We are missing your content. You are such a good teacher
Thank you so much ..... whenever I have a doubt in dsa I comeback to your channel....thank u again💗
This guy is a legend.
Looking forward to when you will do graph algorithms and dynamic programming algorithms: MST, shortest path, LCS, Edit distance, longest common substring,
longest palindromic substring, ...
yeah man thats is right :)
still waiting Q.Q
@@parimal7 he passed away few years back
We can reverse a linked list this way also.
void reverseLinkedList(struct Node* prev, struct Node* curr) {
if ( curr == NULL) {
head = prev;
return;
}
reverseLinkedList(curr, curr->next);
curr->next = prev;
}
CALL -> reverseLinkedList(NULL, head);
His explanation is really tremendous, No one can't recover your place. hats off humblefool
Code for C++:
#include
using namespace std;
struct Node {
int data;
Node* next;
};
Node* Insert(Node *head,int data) {
Node *temp1 = new Node;
temp1 -> data = data;
temp1 -> next = nullptr;
if (head == nullptr) head = temp1;
else {
Node *temp2= head;
while(temp2 -> next != nullptr) {
temp2 = temp2->next;
}
temp2 -> next = temp1;
}
return head;
};
Node *RevRecursion(Node *head) {
Node *temp1 = new Node;
Node *temp2 = new Node;
if (head->next == nullptr) {
return head;
}
else {
temp1 =RevRecursion(head->next);
temp2 =head->next;
temp2->next = head;
head->next = nullptr;
}
return temp1;
};
void Print(Node *p) { // Node *p is a local variable
if (p==nullptr) return; //Exit condition
cout data next); // Recursive call
};
int main(){
Node *head = nullptr; // local variable
head = Insert(head,2); // add node at the end of the list
head = Insert(head,4);
head = Insert(head,6);
head = Insert(head,5);// List 2
Print(head);
cout
is there any way to avoid creating a new node temp1 in each recursive call(excluding global variables) in c/c++?
@@latchmanakumar7404
We can pass by reference head and it will update the same:
#include
using namespace std;
struct node
{
int data;
node *next;
node(int data)
{
this->data = data;
next = NULL;
}
};
void reverse(node **head, node *cur)
{
if (!cur || !cur->next)
{
*head = cur;
return;
}
reverse(head, cur->next);
cur->next->next = cur;
cur->next = NULL;
}
void print_ll(node *head)
{
while (head)
{
cout data next;
}
cout next = new node(2);
head->next->next = new node(3);
head->next->next->next = new node(4);
head->next->next->next->next = new node(5);
head->next->next->next->next->next = new node(6);
head->next->next->next->next->next->next = new node(7);
cout
Amazing explanation of Reversing Linked List using recursion. Such a nice use of algo. It was like watching TV inside TV inside TV and then coming out of it. Kudos to mycodeschool. Hats off !
Please answer a question of how Stack vs Heap works in Java which pure object oriented and donot uses pointers.
Hoping to get your reply soon and eagerly waiting for more such videos.
He could't reply back :(
@@aseembaranwal zamn
One of the greatest videos on youtube. Cheers.
Thanks Jalaj !
🅸'🅼 🅷🅰🅿🅿🆈
At 6:45, the next of the 4th link should be set to 150, not 100. Minor correction. Otherwise, great video. :)
Kartik Singh yes..it is 150.
Typo**
your writing on the last is brilliant
Jenny and this guy...Best teachers to learn coding..
But there is mistake, when first second recursion(150) geting to be finished. There the value should be q=150 and p=0.
if head is not global variable, try this
void Reverse(ListNode** A, ListNode* p){
if(p->next == NULL){
*A = p;
return;
}
Reverse(A,p->next);
p->next->next =p;
p->next=NULL;
}
main(){
if(A==NULL)
return A;
Reverse(&A,A);
return A;
}
You are a god mate, I was having a headache with the pointers but this worked perfectly.
Thanks a lot Kundan,
I have replied to your comment on other video.the idea of stack and heap as design concept for execution of programs is same in java also. We do not have pointer variables, but references pretty much work the same way. Its just that language does not give you freedom to see address in a reference variable and increment or decrement it which anyway is dangerous. The heap is totally managed in java. So, you do not have to bother up freeing up memory on heap.
mycodeschool plz make new videos...your videos are awsome nd it helps a lot
Cool one! Thank you! Saved a lot lines!
This is awesome. But I think head moves everytime p->next == NULL holds true, which is kinda not what we want.
Mycodeschool is my favorite though. superlike.
It doesn't move, since p->next= NULL is set after we return from the function call
Thank you brother for this simple explanation
Kuchh log chale jaate hain par aisi chhap chhor jaate hain ki maano aisa lagta hai jaise vo abhi bhi hamaarre biich hain. Stilll guiding me through your video lectures . _/\_ RIP
if you want to return the pointer Node, and use a local head
struct Node* reverse (struct Node* p ){
static struct Node* head ;
if( p->next==NULL ){
head = p ;
return head ;
}
reverse ( p->next );
struct Node* Q = p->next;
Q->next = p ;
p->next = NULL ;
return head ;
}
I thought why he inserted the statement p->next = NULL; because I thought we can substitute p->next with the next recursion. But the code was needed for the last node - that was first the head node.
Actually we can achieve the same using fewer variables ( though at the cost of code readability ):
struct node* reverse_ll_recursive(struct node *head){
if(head->next==NULL)
return head;
Node *q=reverse_ll_recursive(head->next);
head->next->next=head;
head->next=NULL;
return q; // q stores value of the new head.
}
No existing explanations are better than yours. It would be great and really helpful if you consider YouTubing a part-time again.
amazing and flawless explanation
My god, this was so insightful haha. Thanks for the explanation
Finally understood the mystery behind recursion of linked List Reversal.
i wrote this way.......my function returns a node pointer and in main function the head is then assigned to the last node. like this ---- head = reverse_list_recursively(head);
/*function code*/
node* reverse_list_recursively(node *cur)
{
if(cur->next == NULL)
{
return cur;
}
else
{
reverse_list_recursively(cur->next)->next = cur;
return cur;
}
}
very clear explaination
thanku so much sir
great explanation how recursion works thanks to your drawing of the stack. Thank you very much!
Good tutorial,but i can not unstandard why p is 150 and q is 250?when recursion is finished,why p is not equal to 250?
Python Ruby When exit condition is hit, recursive call Reverse(250) returns and entry of that call will be removed from stack. So, when the actual pointer adjustment starts the top record on stack is for Reverse(150) and hence p was 150
Thanks alott!
p will be equal to 250 only if (p == NULL) because in this condition the last value will be passed to reverse function will be NULL due to which p=250 will be secured, instead of if(p->next == NULL) where the last value in reverse function is 250 due to which p=250 will not be secured and we get p=150. This all happens because the last call of the reverse function will return first in the if statement.
Well explained sir , recursion is sort of complicated.
One of the best videos on Data Structures! :)
would love to see mycodeschool do the data structures videos again and in cpp or python!
You are a life saver Thank you so much for your this tutorials
Recursion uses a stack to store calls, so won't this approach take up O(n) memory? As compared to the iterative approach that only takes O(1) memory
+Sammok Kabasi You're right, but its just in interview to check your level of thinking.
Iterative is O(n) since it is going through entire loop.
He was talking about space complexity.Iterative is O(1) in space complexity
what is difference space and memory complexity?
The iterative approach does not take o(1) time.
smartest thing i have ever seen
You are an amazing teacher!! Hats Off!!
Your tutorial has helped me a lot, thanks
awesome explanation!!!
Legends Never Die ! 💙
shouldn't the node that holds 4 have its next link point to 150, not 100? Thanks, by the way, greats videos.
void reverse(Node* current, Node* prev) {
if (current->next == NULL) list = current;
else reverse(current->next, current);
current->next = prev;
}
call reverse(head, NULL)
I dunno know, it just looks cleaner
This is a very clever trick. Thank you so much.
i think exit condition from recursion in revprint should be if(p->link==NULL) return;
Thank you, tq, tq...
Superb thank u
Has anyone managed to do it with this prototype : void reverse_list_using_recursion(struct node **ptr_head) ; ?
I'm having a problem with it
These videos are the best! :)
Even a kid would come to know about DS! :)
Great tutorial. Thank you. @6:46 it SHOULD be 150.
Shouldn't we also add ptr == NULL in the base case for all safety?
hope u reach 1 million soon
great video there is only one issue the node with data 4 at address should point to 150 and not 100 . the code is correct just a writting error
Great explanation!
Can anybody tell about that how to pass parameter in main function in recursive reverse linklist??
I love this tutorial
one decade later, thanks for the help
Please help!
you lost me at 6:10 marker!
please explain how P is pointing at node 150?
also once recursion is finished and last three lines begin,
you set Node* q = p -> next; // q is pointing to nullptr
and then you set q->next = p;
but how can you set a nullptr to point to p?
so after 3 hours of trying to figure out how! It has come to my realization that once the stack begins to unwind it will "start" from Reverse(150) and not Reverse(250) because Reverse(250) was "completed" with the RETURN statement! Phew!! Thank you this is a wonderful video my friend!!
best of all time
I think we can code as below aswell
public void recurReverse()
{
Node prev = null;
Node curr = head;
if(head==null || head.next==null) return;
rReverse(prev,curr);
}
private void rReverse(Node prev,Node curr)
{
if(curr==null)
{
head = prev;
return;
}
rReverse(curr,curr.next);
curr.next=prev;
}
contd.. I will try to get some video for Java also. :)
ruclips.net/video/55UlYzn3l3E/видео.html
Yet again, Amazing !!
great explanation, keep up the good work
Very helpful!
the 4th one should be 150 not 100 right?
exactly
You are amazing.
Wow, very succinct. Thank you so much!
Magnificent work. Thanks a lot for this :)
what does "head->next->next=head" exactly mean ?
using double pointers without a global head :
void ReverseRec(Node **ptrhead)
{
if ((*ptrhead)->next == NULL)
{
return;
}
Node *temp = *ptrhead;
*ptrhead = (*ptrhead)->next;
ReverseRec(ptrhead);
temp->next->next = temp;
temp->next = NULL;
}
Please god come back !!!! Can't believe what you taught exist lol seems impossible better than anything!!!!!
You guys should upload the exact C/C++ code for better understanding I guess.
He is dead brother
@@vedsinha9905 wtf? How and when
ruclips.net/video/55UlYzn3l3E/видео.html
Thanks... nice one. Made it simple.
Thank you so much for these videos!
Thank you for this wonderful lesson
7:31 min kindly tell how is it possible that we are sharing the 100 (place value to both ) in reversed nodes i.e. 4 /100 and then 6/100 .
awesome explanation....thank you.
very clear, good, thanks man!
thank you very much mycodeschool!!! do you have any tipnns on how to formulate the algorithms of recursion. i can understand recursion code when i see one but i dont know how to design the algorithm. please help and tips :D
Java implementation continues:
public void printReverseUsingRecursion(Node head) {
if(head.next == null) return;
printReverseUsingRecursion(head.next);
System.out.println(head.next.data);
}
An initial check to see if "head" is NULL , is missing.
Vijay Rajanna - Good catch Vijay ! Thanks for noticing :)
mycodeschool yes...and the address was also incorrect but thats minor
An error is an error, Abhishek. There are many people, who are just beginning to learn, who might not be smart enough to realise that. So stop acting smart!
john doe it's good he pointed out. A beginner may be puzzled.
if (!p) return; // this should be the first statement of the function. If using NULL, can equivalently write "if (p == NULL) return;"
This will only be true if the first node, also called the "head" is NULL. Otherwise (if the "head" is not NULL), "if (p->next == NULL)" will always be true before "if (p == NULL)" would ever be true.
Thanks man! Good instruction!
YAS! YEAH YEI, i really need this
+Maria Lopez baia baia :v
very informative video thanks
can you please explain before q is initialized how p is set to 150 instead of 250 ?
as I see the condition p-> next==NULL, so i think it will reach end(250) and not 150.
thanks in advance
why P would be 150? after the recursion p should point 250 cause and p->next is NULL