链表中的节点到底是什么？

Question

https://www.geeksforgeeks.org/linked-list-set-1-introduction/

https://beginnersbook.com/2013/12/linkedlist-in-java-with-example/

is there a diffence? Like why does the geek one have likes nodes

    llist.head = new Node(1); 
    Node second = new Node(2); 
    Node third = new Node(3); 

But the other link did

  list.add("Steve");
  list.add("Carl");
  list.add("Raj");
  list.add("Negan");
  list.add("Rick");

like I feel like either im just overthinking it, or the the sites arent clearly explaining things. the linkedlists seem to be functionally the same as arraylists.

I basically did my arraylist assignment, and really only changed

LinkedList list from ArrayList list

    for(int i = 0; i < listSize; i++)
    {
        System.out.print("Enter a number to go in the list: ");
        int num = scan.nextInt();
        list.add(num);
    }

and everything functions fine, so what are all these nodes, and stuff that geeks site did?

Answer 1

An ArrayList is a list which is backed by an array with additional features to grow dynamically, etc. These lists are also random access which means you can specify the exact location via an index.

A linkedList has what are call nodes. In Java, nodes are simple classes that have at least two fields. One for the next node and one for the data. In other languages they can be structures . They are not random access because to find a certain element you would have to start at the head (top node) and count as the list is traversed. The nodes themselves are of an internal nature and are of no concern to the user.

Preference of one over the other should be based on how it is to be used. How often it needs to be updated and speed of access are considerations, among others.

Answer 2

As previously answered the two examples you gave are just different implementations of the same concept. The main point you should take away from this is that a linked list is composed of various nodes which point to each other and the list has a head. Inserting an element to the list consists of (implicitly or explicitly) creating a node and adding it to the end while deleting an element requires first searching for the element one node at a time and removing it from the list once found.

Now what is all the business about nodes?

Well, nodes can be thought of as containers for data that also point to other nodes. The simplest LinkedList is a singly-linked LinkedList, meaning that each nodes "points" to the next node in the list.

The implication of this is that you technically never have to implement a LinkedList and can instead just make a node class and create a node that is treated as the head of the list. Then, since you have the head you can then access any node in that list because each node points to each other, you just have to search one by one. Same thing with adding an element to the list; start with the head and check if it points to another node, if it doesn't create a new node and set it as the "next" node after head. On the other hand if it didn't have a next node that head points to check if that next node points to another node and just repeat until you find the last node in the list which doesn't point to anything. Deleting a node would require a similar process of iterating through each node until you find the one you want to delete, then remove it. This implementation is what the first example is showing.

On the other hand in the second example they've actually implemented the LinkedList which fundamentally operates the same way as I just described only that the user no longer has to write a loop to find the last node in a list, create a node, and finally set it as the next node. Instead, to add a node they just call add(node) and the LinkedList class will deal with all the in between steps.

Implementation

Whichever implementation you choose will produce the same result but I do want to warn you about using an ArrayList. In a way you've kinda gotten lucky since the ArrayList add() method always adds to the end of the list similarly to how a LinkedList works. You can get away with all LinkedList operations (that I can think of) using an ArrayList but fundamentally these two operate very differently in terms of amount of memory they use and how well they perform when adding, finding or deleting an element. Lasly, you just might not be able to take away the key points of a LinkedList without implementing one yourself.