Introduction to Linked Lists (Data Structures & Algorithms #5)

Learn the basics of linked lists. Java & Python sample code below.
Check out Brilliant.org (brilliant.org/..., a website for learning math and computer science concepts through solving problems. First 200 subscribers will get 20% off through the link above.
Special thanks to Brilliant for sponsoring this video.
Find sample code in Python and Java here: www.csdojo.io/...
This was #5 of my data structures & algorithms series. You can find the entire series in a playlist here: goo.gl/wy3CWF
Also, keep in touch on Facebook: / entercsdojo

[@CSDojo]

Hey everyone! If you are looking for more practice problems for arrays and linked lists, I’d also recommend my Udemy course, “11 Essential Coding Interview Questions” here: goo.gl/v35LCa It’s supposed to be for programming interview questions, but it should be a good resource for improving your problem-solving skills in general. Anyway, thanks as always for watching! If you don’t want to pay for the course, remember that I have a ton of other free videos right here on this KZbin channel :)

[@technicalilm8999]

make a video on hash tables and hashing please

[@astonchui808]

Thank you very much for another good quality lesson! Please consider making a complete computer science course! Even on Udemy, very interested to buy it!

[@benshkabanka9044]

CS Dojo hey there! I like your videos and would like to ask you something, so here goes: "How do you learn something new, so that you don't forget it sometime soon?" Because I often find myself forgetting stuff that I have just learned a few days or weeks ago. For example I learn about lists, maps and dictionaries. Then a few days later I want to realize a Programm and start cracking my head what I should use and how it worked. Then I have to Google again and look it up. I have this kind of problem for many things except the absolute basics. How did you Crack everything in your head so you don't forget it again?

[@nadavhacmun2560]

i had the exact same solution like you and now i'm happy :)

[@No1lolizone]

Thanks bro. You are providing us a very great and simple knowledge about programming. Keep going.

[@davidemilan59]

When a KZbin video teaches you better than your programming professor at University lol

[@TheJoaohc]

Exactly!

[@zclee7325]

it always to be like that

[@ahiduzzamanahir1338]

@Xiogenes You're paying money for the syllabus....lol

[@ysheepy4907]

Cant agree more. My professor explains it so terribly that my brain went spaghetti ...

[@realnice3672]

@@ysheepy4907 tasty lol

[@Artouple]

My solution, writing before watching the solution: int countNodes(Node head){ var count = 1; //As head is not null while(head.next.data != null){ count++; head = head.next; } return count; }

[@balajiramadoss6014]

header.next.data will throw null pointer exception if header.next is null

[@damiajayi2081]

Really proud of myself for doing this without looking at any hints. I don't get a lot of exercise questions. I love your method of teaching My Java Code: public class LinkedList { public static void main(String[] args) { Node head = new Node(6); Node nodeB = new Node(5); Node nodeC = new Node(5); Node nodeD = new Node(5); Node nodeE = new Node(5); head.next = nodeB; nodeB.next = nodeC; nodeC.next = nodeD; nodeD.next = nodeE; System.out.println(countNodes(head)); } static int countNodes(Node head){ int count = 1; Node current = head; while(current.next != null){ count++; current = current.next; } return count; } }

[@Michael-f8x4h]

it doesn't run tho

[@tpsspace7397]

@@Michael-f8x4h his code is fine

[@zeno5053]

12:04 a three-line solution from python def countNodes(head, count = 1): if head.next != None: return countNodes(head.next, count + 1) return count

[@zydiz]

a great solution but butting the "if" expression in the same line with the statement doesn't actually reduce a line.

[@codekarlebhai]

@@zydiz its not if, its ternary operator with combination of recursion(but yeh logic is same)

[@balajiramadoss6014]

fcuk your 3 lines or 2 lines. you must say that you are using recursion instead of iteration. that's it. nothing impressive from this code

[@tomseinfeld7124]

In JavaScript function countNode(node) { let totalNodes = 1; let myNode = node; while(myNode.next) { total++; myNode = myNode.next; } return totalNodes; }

[@sourabhkumar3852]

inside while loop it will be totalNodes++ . Rest everything is absolutely correct.

[@The_Bruh_26]

For this to work the totalNodes must be set to 0 or myNode and totalNodes operations inside the while loop should be switched, as head is being counted twice in this example

[@vivek3861]

Best and simplest teaching ever...thanks.

[@waelassaf4740]

Bless Up.

[@heavysaber9431]

I wish I learned programming at high school, all I did was play video games...

[@aryanshmahato]

@@heavysaber9431 I feel lucky now

[@heavysaber9431]

@@aryanshmahato I envy you brother, dedicate that time to programming!

[@shadowagent3]

divide by 2 each time and pick higher / lower half. its ez

[@ivanrsbr]

Excellent videos, thank you for this great tutorial. My solution in Java is to add the following function to the Node class: int countNodes() { if (this.next == null) return 1; else return this.next.countNodes()+1; } This will recursively search for child nodes and return the count.

[@ArmandoAlejandro2014]

I've been a developer for 25 yrs and i got 2 weeks to prepare for a Google technical interview and I'm relying on your videos to help me prepare. I have to relearn alot of stuff I haven't used in years. You have to go into teaching. America's kids need somebody that can teach as well as you. Thanks kid.

[@muwongenicholas6281]

did you get the job?

[@DanNjeru1]

Don't leave us hanging Armando. It's been two years.

[@snoudoubts1745]

Armando now works for the Government of Texas ;)

[@webknowledge9989]

@@snoudoubts1745 how u know?

[@eliadaballazhi2982]

@@DanNjeru1 hahahaahahah dead

[@satan9487]

I was struggling with this for ages! Thank you a lot

[@emmettanderson9185]

YK your amazing I love that you quit your high paying job at google to teach on KZbin I hope your channel blows up and you become famous!

[@UnrecycleRubdish]

looks like your wish became true. he has more than a million followers in 2020 =)

[@realnice3672]

@@UnrecycleRubdish yeah lol

[@acidtears]

You're the Khanacademy of programming! Love this series and your step-by-step explanations.

[@suyashsharma7088]

You have the best explanation of all the KZbin tutorials out there! Keep up with the good work. I had so much trouble understanding and learning Linked List. If I would have had watched your videos earlier, it would have had definitely made my struggle period shorter. Thank you very much and keep up with the good work. :D

[@heidik1757]

You're an incredible teacher. Hope these videos never end and stretch across even the most advanced of topics. Very enjoyable.

[@highmaths7698]

You're doing a great job CS. I have already recommended your channel to a dozen friends. Keep up the good work!

[@MesitaButClean]

best video i ever see about linked list, my teacher explained TWO weeks and THIS MAN EXPLAINS IT IN 18 MINUTES, AND IM STUDYING C++!!!

[@ananshnawang2360]

My code for c++: int sizeof_list(){ Node* ptr = head; int count = 0; while( ptr != NULL ){ ptr = ptr->next; count++; } return count; } This code has no parameters since its assumed that this function is specific to object and has access to private members of class.

[@aglovecraft]

Did it recursively: int countNodes(Node head) { if (head.next == null) { return 1;} else {return 1 + countNodes(head.next);}

[@leelakrishna5815]

at the last node, when the head reaches its end, and there are no other nodes, your count will just return 1.

[@nathanunderwood6920]

if you have a single line statement screw the skwigglies if(head.next==null) return 1;

[@kyosena113]

@@leelakrishna5815 ..plus 1 for every node before it. It checks out.

[@zalavatari8416]

.

[@scoutiano4441]

why would you do it recursively if you can do it using a while loop in a few lines?

[@citec123x]

You're just amazing, what I like the most is, you just go straight to the point with very clear examples and NO MUMBO JUMBO...!!! An old timer Cobol programmer from last century... *lol*

[@nimmiverma1565]

int countNode(Node head){ int count = 1; Node temp = head; while(temp.next != NULL){ count++; temp = temp.next; } return count; }

[@dungletien4676]

So how do you solve that problem in the case with 1 Node

[@buzzikea]

@@dungletien4676 if there is only 1 Node, temp.next will always be null, so while loop never executed,hence returned 1

[@ericnarciso9156]

Python recursive count: def count_nodes(head, c=0): if head: c += 1 return count_nodes(head.next, c) return c

[@tailcatch5704]

I learned in 20 minutes what my teachers were trying to teach me for 2 hours...

[@suman-majhi]

my teacher trying to teach me this for last 2 years😂😂

[@biqbicle4982]

@@suman-majhi nah fundamentals shouldnt go for 2 years your teacher brain damaged

[@kyrinky]

I like the fact that he uses visual examples and actual code to explain the concepts. Most of the time books only have visual examples, and I would understand them, but once it came down to coding it I would just blank out.

[@HungNguyen-oz1jc]

Can you please next one do using LinkedList for Stack and Queue?

[@HungNguyen-oz1jc]

@B0bby that’s ok, I already graduated 😂

[@ericlansher6101]

@@HungNguyen-oz1jc 🤣

[@zaurs0]

Hi, i used Recursion int countNode(Node head){ System.out.println(head.data); nodeCounter++; if(head.next != null) return countNode(head.next); else return nodeCounter; } i think it works :3

[@hamiltonkahonde7939]

I love this dude!!! He explains this sooo damn well

[@MitraNami]

It was a great video! Thnx Go Python!# Recursion def count_nodes(head): current = head if current.next == None: return 1 return 1 + count_nodes(current.next)

[@yiyingzhang9585]

def countNodes(head): count = 0 node = head while node.next != null: count +=1 node = node.next return count

[@arjunsingh6264]

Hello! I'm new to the coding scene, and am mostly self taught. I was working with Data Structures but most of my test cases would time out from being too long, and so I tried learning more about Linked Lists but I'm having some trouble with the syntax for Python. You obviously are familiar with it, could you please suggest some tutorials or material I could get a basic idea from? I'd really appreciate it, Thanks!

[@coddude3284]

static int countNode(Node head) { int c = 1; // head is node 1 Node nextNode = null; while(head.next != null) { nextNode = head.next ; // i know pffff head = nextNode ; c = c + 1; } return c; }

[@patrickmayer9218]

*Think of arrays as one box with many partitions, whereas a linked list is many boxes tethered together. *Head = first node, *Linked lists can be represented in one direction (singly LL) or both (doubly LL) Great video, thanks for the clear explanation!

[@finncollins5696]

only think i consider is your blasphemous image. try to be educated and ethical as a computer science student. Christ the king image has changed and it's so blasphemous.....

[@patrickmayer9218]

@@finncollins5696 Dude, I'm a born-again Baptist Christian. I'm not mocking Jesus, it's just a meme.

[@Zero-bg2vr]

static int countNodes(LinkNode head){ int lengthTracker = 0; // COMMENT 1 SEE BELOW while (head!= null){ // COMMENT 2 SEE BELOW head = head.next; lengthTracker++; } System.out.println(lengthTracker); return lengthTracker; } I'll make this as simple as possible based on how i understood it: Comment 1: The variable "lengthTracker" keeps track of the length. Comment 2: We can assume that we don't know the length of the linked list hence why were using a while loop. Basically we're checking whether the parameter value which is ""LinkNode head" is null or not. If it the head is not null we will move to the next node making it the new head and increment (increase) the lengthTracker variable (lengthTracker++). Now when the while loop runs again it will check whether or not the new value is null or not. If the new head is null then it will quit the while loop, print lengthTracker and return it. Hope that clarify's stuff.

[@codingwithsam9194]

hey sir. a 12 year old boy is inspired by you

[@mryup6100]

Keep it up!

[@scum3112]

Are you still coding? I wish I started as early as you. I was only interested in games (although I still love games) kudos to u kid

[@II_xD_II]

im 13 :D

[@pratapkumarsahu8717]

Me too

[@Nicolas-L-F]

16 here, keep it up man

[@thereaper489]

class Node(): def __init__(self, data=None): self.data = data self.next = None class LinkedList(): def __init__(self): self.head = None def append(self, data): #add something to the next node in the list new_node = Node(data) if not self.head: self.head = new_node return current_node = self.head while current_node.next: current_node = current_node.next current_node.next = new_node def prepend(self, data): #add something to the beginning of the list new_node = Node(data) new_node.next = self.head self.head = new_node def print_list(self): #prints the stupid list current_node = self.head while current_node: print(current_node.data) current_node = current_node.next my_list = LinkedList() my_list.append(1) my_list.append(2) my_list.append(3) my_list.prepend(0) my_list.print_list()

[@randomorigami6416]

My code for java: static int countNodes(Node head){ int i = 1; while (head.next != null){ i++; head = head.next; } return i; } Node-object is defined as in the video. For the sake of understandability, it could make sense to add a 'cursor' variable like: Node cursor = head before the while-loop, since it is not really the head you are using for the rest. *Like done in the video with current.

[@psionicxxx]

You can simplify the while statemet to: while (head.next) { ... It will loop while the statement in parentheses is True. Null is always False when using in conditional statements, thus as long as there's something in head.next, it will report it as True.

[@programwithviggo2197]

@@psionicxxx In Java that's gonna give you an error. Null doesn't evaluate to false and an object that isn't null doesn't evaluate to true.

[@himanshuupreti9457]

Nicely explained, can you please show this class, linkedlist in memory as you did for video of array inside memory... That was fun to know what's inside..

[@blue-hydra]

Node current = head; int count = 0; int countNodes(head){ while (current!= null){ current= current.next; count++; } return count; }

[@varmarocks009]

def count_nodes(linked_list): count_nodes = 0 while linked_list is not None: count_nodes +=1 linked_list = linked_list.next return (count_nodes)

[@tanbirmahmud3101]

Thx

[@picumtg5631]

exactly same solution. Now io dont feel stupid

[@NripendraPatwa]

My code in python for 11:47 def countNodes(head): temp = 0 list1 = [4, 2, 3, 10, 2] head = (list1[0]) if print(head) for x in list1: x = 1 temp += x return(temp) print(head) My computer shows this function is wrong, but I don't understand what. Please tell me (also thank you because I am just a starting beginner and your python for absolute beginners series was a ginormous help)

[@TorIvanBoine]

This is cool and all. But what is the practical use of linked lists? Easier to understand the concept if we know what its used for.

[@clebersonfrodriguesjunior2060]

dynamic allocation in memory, i guess. items of same collection can be stored in different locations of memory...

[@delaghetto0]

kzbin.info/www/bejne/lZu0mXSCfpmooMk

[@GurpreetSingh-et8ix]

One of the most widely used data types in computing is hash tables. If you would like to create one from scratch, linked lists are the easiest way to implement them. First learn how to implement a linked list from scratch and then learn how to use that to create a hash table.

[@technicalilm8999]

python implementation ::: def countNodes(head): if head.Next != None: countNodes.count += 1 ConsecutiveNode = head.Next countNodes(ConsecutiveNode) return countNodes.count class Node: def __init__(self,data): self.data = data self.Next = None head = Node(4) nodeB = Node(2) nodeC = Node(3) nodeD = Node(10) nodeE = Node(34) countNodes.count = 1 # Assuming head is not null head.Next = nodeB nodeB.Next = nodeC nodeC.Next = nodeD nodeD.Next = nodeE print(countNodes(head))

[@adityamandal8604]

what should it really print?

[@technicalilm8999]

Aditya Mandal no of nodes

[@adityamandal8604]

It prints out 1

[@technicalilm8999]

Aditya Mandal there might be problem with the indentation while copying and pasting

[@mesta5539]

replace the if with a while

[@SMAOS1]

public static int Counter(node n) { int counter = 0; node head = n; while (head != null) { head = head.next; counter++; } return counter; }

[@Eclipse-san]

Hey CS Dojo, I absolutely loved how you gave us a practice question. I felt really good after solving it ! My Solution in python: class Node: def __init__(self, data): self.data = data self.next = None def countNodes(self): while(self.next != None): print(self.data) class LinkedList: def __init__(self): self.Head = None def push(self, data): new_node = Node(data) new_node.next = self.Head self.Head = new_node def countNodes(self): temp = self.Head count = 0 while(temp): count += 1 temp = temp.next return count linked_list = LinkedList() linked_list.push(1) linked_list.push(2) linked_list.push(3) linked_list.push(4) print(f"The LinkedLists has {linked_list.countNodes()} Nodes.")

[@Zerimarvin]

AaaAAAAaaaAAAAAAAAAaAAaaaaaAAAAAAAAAAAAAAAaaaaaAaAaAAAAAAaaaaaaaaaaaa

[@Zerimarvin]

Aaa

[@Zerimarvin]

Aaaa

[@Zerimarvin]

Aaa

[@Zerimarvin]

Aa

[@stephaniemartinez1468]

I used recursion to solve the problem. public static int countNodes(Main head){ if (head == null){ return 0; } else { return 1 + countNodes(head.next); } }

[@debarkachakraborty3857]

Thanks a lot man! You have explained it precisely for a beginner to understand. I would request you to post video for doubly and circular Linked list too.

[@azimuth809]

*** C++ CODE *** // there are many ways to do that // You can make it by using Recursive way // if you want to append strings or another arguments you can do it ~ // You can add any function except mine like remove etc // ~ by using Templates // I would recommend you boos *** C++ Early Objects // Any questions, leave comment // *** GOOD LUCK *** #include using namespace std; class LinkedList // name of a class { protected: // our struct would be protected so we could manipulate data with Child Classes struct Node{ double data; // value in the node Node *next; // next pointer which points to the next node // Constructor Node (int data1, Node *next1 = NULL) { data = data1; next = next1; } }; Node * head = NULL; // pointing the head front of the node(Make it to point first node) public: void add(double); // adding function when we add the new value to our node int getSize(); // getting the size of a Node void DisplayList(); // Displaying the list }; // Adding function with argument double *** We can make it with template so we can ~ // ~ append any type of an argument void LinkedList::add(double number) // { Node *ptr = head; // both ptr and head points to the first node of the Node list if (head==NULL) head = new Node(number); // when it is empty just append the number else { while (ptr->next!=NULL) // Compile it if the first node not point to the NULL ***not next node { ptr = ptr->next; // go to the next node } ptr->next = new Node(number); // append the number instead of NULL } } // Displaying the LIST void LinkedList::DisplayList() { Node * ptr = head; // both of them begin from front Node list if(!head) // if it is empty return; while (ptr!=NULL) // while it is not empty { coutnext!=NULL) { len++; ptr= ptr->next; } return len+1; // since last node is NULL it would not add consider the last value ~ // ~ so we added it by ourselves } } int main() { class LinkedList list; list.add(1); list.add(2); list.add(3); list.add(5); list.add(12); // you can add your own code // code~~~ list.DisplayList(); cout

[@tauseeqali3898]

Thanks!

[@zalavatari8416]

Nice

[@zlove1010]

thank you, going to analysis the code in an IDE appreciate it

[@natestrings673]

My solution is nowhere near optimized (most likely super elementary), but I'm proud it works - static int countNodes(Node head){ //assuming head != null int count = 1; Node temp = head.next; while(temp != null){ count++; temp = temp.next; } return count; }

[@seanymiller2]

This is the best explanation of a Linked List BY FAR. Great job!

[@escrituratalks]

Here is my solution def countNodes(head): If head.next == None : return 1 else: return 1 + countNodes(head.next)

[@ogsconnect1312]

public int getLength(ListNode head) { int i = 1; // counter while(head.next != null ){ i++; head = head.next; } return i; } // end method getLength

[@dead-mb1zc]

thank you thank you I finally REALLY understand how this shit works

[@amrohany6818]

swift 5.0 recursive function: func countNodes(_ node: Node) -> Int { // recursive function if node.next != nil { return countNodes(node.next!) + 1 } return 1 }

[@rukna3775]

public class Main { public static void main(String[] args) { Node node1 = new Node(5); Node node2 = new Node(14); Node node3 = new Node(77); node1.next = node2; node2.next = node3; node3.next = null; LinkedList.printNodes(node3); } } public class Node { int data; Node next; Node(int data) { this.data = data; } } public class LinkedList { static int countNodes(Node node) { int i = 0; while(node != null) { ++i; node = node.next; } return i; } static void printNodes(Node node) { int nodes = countNodes(node); for(int i = 0; i < nodes; i++) { System.out.print(node.data + " "); node = node.next; } } }

[@pranathikanamarlapudi2726]

hi sir, u explained it very well! just a small doubt- how does the doubly linked list prev node work? how will it know that prev is the previous one?

[@arunakumari634]

From where I can find the advance link list concepts

[@mythos257]

class Node: def __init__(self, data, next=None): self.data = data self.next = next Head = Node(5,Node(1,Node(2,Node(8)))) def count_Nodes(head): count = 0 a = head while True: count += 1 if a.next == None: return count a = a.next print(count_Nodes(Head)) I used a different Generator because this way it's much more compact

[@Tips4Tat]

Short and sweet

[@yannick2247]

My solution java: int countNodes(Node head) { int counter = 1; boolean nextNodes = true; Node nextHead = head; while (nextNodes) { if (nextHead.next != null) { // next nodes inside counter++; nextHead = head.next; } else { nextNodes = false; } } return counter; }

[@vanessashultz2330]

I love your teaching! I learned a lot!

[@ahmed_yussuf]

Thank you! I am taking Algorithm and data structure in community college. I think spending 900 dollars on that course the professor can not do half of what you do. BRAVO!

[@isabellahernandez2403]

I really liked all of your visuals. They all really helped me. Especially having drawn out images next to the code. I really like how you explain everything as well.

[@somyajain9526]

int countNodes(Node head){ int count=0; while(head!=null){ count=count +1; head=head.next; } return count; }

[@deanmurray7626]

or int countNodes (Node head) { if head == null return 0; return countNodes(head.next) + 1; }

[@muratderekoylu4673]

My Java Code: int countNodes(Node head) { Node tmp = head; int counter = 0; while(tmp != null) { counter++; tmp = tmp.next; } return counter; }

[@CBECH22]

I was looking at this and I confused myself. I was trying to challenge myself and was thinking this code might be one count short because you werent accounting for the first head. You would either need to start counter at 1 or increment counter by one at the end. Very well done though, and easy to read!

[@SureshKumar-kd3fx]

Counter=1 Not 0

[@ikercasillas1786]

@@SureshKumar-kd3fx it works when counter is set to 0 because it stills loops through and increments it.

[@ikercasillas1786]

@@SureshKumar-kd3fx in the video the loop was based on current.next and not current, that is the difference between his and Murat's code.

[@SmartassEyebrows]

@@SureshKumar-kd3fx @Chance Bechly Actually, it is correct. Look closely at the order of the code; counter++ happens Before the jump to the next item. So starting at head, you increment the counter from 0 to 1 (thus counting the head), then you go to head.next, check if it is null, if not, increment counter from 1 to 2, and so on till you hit a null. If you started the counter at 1, in the case where there -is no list at all-, you would incorrectly count 1 node, when no nodes exist in the first place.

[@thegaribovv]

Thank you very much)), step by step and very simple.

[@ryanlynch2674]

Hey guys, I'm not sure if anyone has posted this before but if you wanted to solve this recursively you could use this: static int countNodes(Node head) { if(head.next == null) { return 1; } else { return countNodes(head.next) + 1; } }

[@SplyGuy]

I'm very late, but this is extremely helpful. Thank you.

[@jushas9276]

Youuu are aaawesome👏👏👏👏...

[@andreandrews6237]

my solution: int countNodes(Node head){ int result = 1; //should always start with one because if you have a head then 1 node by default, NOT 0 Node currentNode = head; while( currentNode.next != null){ result ++ (can also do += 1, style thing) try{currentNode = currentNode.next} catch (Exception e){break;} } return result; } try catch may not even be necessary, but can never be too careful lol, written in c# btw

[@rintarouokabe7237]

assume that tail is the last box. tail = last box from the linkedlist Solution: int CountNodes = 1; //since we initially start at head and head also considered as nodes while(nodes!=tail+1){ if(nodes != null){ countNodes++; } return countNodes; }

[@rintarouokabe7237]

btw guys im only a beginner in programming so pls don't judge my code but if there are some corrections or you've suggestion feel free to comment it thanks. :P

[@AS-os3lj]

But why should we use a linked list?

[@SudiptaKarmakar87]

Depends on use case. Like when you need fast (constant time) insert/delete in a list but you are not looking for dynamic access to any element of that list.

[@nirash8018]

Its the same like an array, but with the advantage of being able to not having to insert the amount of objects you want to enter in the List. But tbh its just way too much work so i'd always go with the array

[@SudiptaKarmakar87]

If you do not know any better the least you can do is not spread misinformation. It's NOT like an array. Instead a linked list is maintained using pointers to next node/element. And I'm not even sure what "being able to not having to insert the amount of objects you want to enter in the List" means.

[@nirash8018]

saying that it’s LIKE an array doesn’t means it is an array dumbass. And if you don’t understand my sentences bcs in your poor country the education system is fucked I’m not to blame.. Please think before writing some shit

[@SudiptaKarmakar87]

Appreciate your intellectual responses. Real class. "saying that it’s LIKE an array" is wrong by itself! And no, "being able to not having to insert the amount of objects you want to enter in the List" - does not make any sense in whichever language you try.

[@joysehgal8105]

def countnodes(node): if node.next==None: return 1 else: return 1+countnodes(node.next)

[@bruhop3074]

I have been trying to learn LinkedList from yesterday, watched many tutorials, read many blogs but I was not getting the clarity as even the code of LinkedList is very intimidating. this video helped a lot!! I am finally a bit confident and ready to learn more about it and solve problems. Thank You Dojo!🙌

[@ToyMachine22122]

Like your videos! I get that linked lists are a required topic to understand for purposes of passing tests (either at university or for a job screening), but the reality is that linked lists are practically useless, at least in 99%+ of cases. Almost all of the time, you’d get much better performance using a dynamic array (called a vector in C++). I know: supposedly linked lists have better performance for random insertions and deletions. Supposedly. But the fact is that CPU caches work MUCH better with arrays than with linked lists. On average, Linked lists incur a cache miss EVERY TIME you want to advance your iterator, whereas dynamic arrays only incur a cache miss once per SizeOf(CPU Cache)/SizeOf(YourDataType) So yeah, nice explanation, but basically don’t use linked lists, *almost* ever. The only conceivable situation where linked lists win over vectors despite their poor cache performance is when you want to MAINTAIN AN ITERATOR TO A RANDOM POSITION in the list - a position where you KNOW that your next insertion or deletion will be performed. Such situation is very rare and I can’t even think of an example. So yeah, that’s linked lists, now don’t use them cause they almost always suck.

[@raushankumarraman7259]

Sir please make more videos on python.

[@Hateusernamearentu]

watched your video twice. This time finally get the "head" idea. Thank you !!! You simplify everything yet does not lose the key point!!!! Great Work!!!!

[@JagroopSingh-wd6kj]

//Method returns count of Nodes int countNodes(Node head){ //This method returns the number of Nodes int count = 0; while(head != null){ head.next; count ++; } return count; }

[@MandeepKaur-km3ds]

Well explained !! one of the best resources for learning linkedList

[@josedanielgallegos10]

Another solution using Python def countNodes_(self, headval): currentNode = headval.next_val if currentNode is not None: return 1 + self.countNodes_(headval.next_val) else: return 1

[@briannnnn6743]

Python code (not sure if it works): def Node_Counter(head): counter = 1 while(true): if head.next != None: counter+=1 head = head.next else: return counter

[@Bestshivam]

Really very helpful. Saw a lot of videos on LL but this code made concept very clear and the code was so simple. Thanks.plz complete this whole DS series...

[@sooryajagadeesan7017]

int count ; while ( head ! = NULL) { count++; head= head-> next; } return count;

[@mahaveerjanagouda77]

my code :(please do tell me if this has any case errors) public class Linked { int data; Linked link; Linked(int data,Linked link) { this.data = data; this.link = link; } static int countnum =0; public static int count(Linked link){ if(link!=null) { count(link.link); countnum++; return countnum; } else return countnum; } public static void main(String[] args) { Linked forth = new Linked(1, null); Linked third = new Linked(2, forth); Linked second = new Linked(3, third); Linked first = new Linked(6, second); count(first); System.out.println(countnum); } }

[@asdfghjkl1770]

wow! good job ,yk! keep teaching us! you're amazing!

[@fredianriko5648]

I hope you were my programming language teacher back in the college day, I didn't understand it until watching your explanation

[@phucnguyenducanh]

Using pointer represent a NODE, another good way:)

[@GunelMammadova93]

Thank you very much for all these awesome videos with the best explanation I have seen so far!

[@NoorAfshanFathima]

JS: class Node{ constructor(data, next){ this.data = data this.next = next } } let head = new Node(4) let nodeB = new Node(5) let nodeC = new Node(6) let nodeD = new Node(7) head.next = nodeB nodeB.next = nodeC nodeC.next = nodeD console.log(head, nodeB, nodeC, nodeD) let countNodes = function(head){ let count = 0 if (head.data === undefined) return count if (head.next === undefined) return count++ let currentNode = head count++ while(currentNode.next !== undefined){ count++ currentNode = currentNode.next } return count } console.log(countNodes(head))

[@gabrielmunoz2845]

Best video I have seen in learning a concept. Thank you very much!

[@md.shakibhassan8960]

For PHP (please ,correct if I've made any mistakes) ------------------------

[@wmrdwijerathna680]

Thank you so much. your explanation was very clear and excellent. this was the first video that I learned about a linked list. your video helped me to understand linked Lists very well. Keep up the good work.

[@EmadElSherif]

why assume the head is not null, meanwhile we can check it easily by starting counter from zero and checking the head first? like this: public static int numberofnodes(Node head) { int numberofnodes=0; Node currentnode= head; while(currentnode!=null) { numberofnodes+=1; currentnode=currentnode.next; } return numberofnodes; }

[@egehanasal710]

YES YES YES SO MUCH LOVE FOR YOU THANK YOU !!!

[@mcoyid]

Middle?? This is confusing if the numers are even.

[@thotamounika5633]

Wow Thank you so much for making the linked list easy to understand. :) You're awesome!

[@sandhyas4802]

public static int countnode(Node head) { if(head.next!= null) { return 1+countnode(head.next); } else { return 1; } }

[@richie.edwards]

// Javascript function countNodes(headNode) { var next = headNode.next; if(next == null) { return 1; } else return 1 + countNodes(next); }

[@chee_tash]

The syntax here might not be exact and not sure if this solution works 100% but I used recursion public int numberNodes(Node node){ int counter = 0; if(node.next != null){ counter++ return numberNodes(node.next) } return counter; } so basically if the node has a next node, we increment the counter and call the function again, if not we just return counter?

[@eiramavepanambo543]

Thank you YK for your clear explanation and samples :)

[@vigneshrajans5814]

Hi YK - Thanks for your valuable teaching.. I have a doubt While defining data type of next(attribute) - you gave datatype as class name.. How it works here..

[@hariharasudhann17]

def countNodes(head): total = 0 while hasattr(head, "next"): total += 1 head = head.next return total print(countNodes("d"))

[@ove12lord73]

my solution: class LinkedList: def __init__(self,number=None,next=None): self.number=number self.next=next o1=LinkedList() o2=LinkedList() o3=LinkedList() o4=LinkedList() o1.number=1 o2.number=2 o3.number=3 o4.number=4 o1.next=o2 o2.next=o3 o3.next=o4 def number_object(objectt): size=0 while True: try: objectt=objectt.next size+=1 except: print(size) break number_object(o1)

[@DelphyM]

Have you realised, that using `current.next` in the `while()` loop as condition, will always consume the next node? See the footage at 14:46. I think, the way to do it is questioning if `current` is not `null`, like this: ``` private static List createListFromLinkedList(String linkedListName, ListNode current) { System.out.println("Linked List " + linkedListName); List list = new ArrayList(); while (current != null) { System.out.print(current.val); list.add(String.valueOf(current.val)); current = current.next; } System.out.println(" There are " + list.size() + " elements."); return list; } ```

[@ilia9788]

javascript: var head = {num: 1}; var nodeA = {num: 2}; var nodeB = {num: 3}; var nodeC = {num: 4}; head.next = nodeA nodeA.next = nodeB; nodeB.next = nodeC; var count = 0; var currentNext = head.next; while(currentNext){ ++count; currentNext = currentNext.next } console.log(count)