我怎样才能理解链表？

Question

I'm trying to understand how they work, but I'm having a lot of difficulties. Does anyone care to explain them intuitively, or offer resources they think work well for those who are just beginning with the topic?

So let's say I have this:

struct node
{
   int nodeNum;
   nodes *next;
}

To create the "head" node I'd do the following: node *head = new node; so that my linked list now looks like . After assignment:

head->nodeNum = 10;
head->next = NULL;

we have . Now, if I wanted to write a function that inserts a node, can I write:

void insert(node *previousNode, int num)
{
    previousNode = new node;
    previousNode->nodeNum = num;
    previousNode->next = NULL;
}

So that if I were to do, say, insert(head, 20); my new list looks like ?

If everything is correct, how can I use this information to search and/or remove nodes from the list? Traversing through the nodes isn't really intuitive as described head = head->next; , for example. How does this work?

Any advice you can offer to make this topic easier to understand would be great. Thanks for the help everyone!

Answer 1

Your insert function doesn't work properly; it just creates a new node without adding it to the list, and loses it (giving a memory leak) when the function returns:

head -> 10 -> NULL     becomes    head -> 10 -> NULL
                                  (lost)  20 -> NULL

Instead, it should link the old tail of the list to the new node, and insert the new node after the old one:

void insert(node * prev, int num) {
    node * new_node = new node;
    new_node->nodeNum = num;
    new_node->next = prev->next;  // add the old tail after the new node
    prev->next = new_node;        // add the new node after the old node
}

insert(head, 20); // insert 20 after the head
// head -> 10 -> NULL   becomes    head -> 20 -> 10 -> NULL

How can I use this information to search and/or remove nodes from the list?

To iterate, you maintain your own pointer to the element you're looking at; this begins at head , and then follows the next pointer until it reaches the end (ie next is null):

for (node * n = head; n; n = n->next) {
    if (n->nodeNum == 20) {
        std::cout << "Found node 20!\n";
        break;
    }
}

To remove a node from a singly-linked list, you need a pointer to the node before it in order to update its next pointer:

void remove_next(node * prev) {
    if (prev->next) {
        node * next = prev->next->next;  // Get the tail after the removed node
        delete prev->next;
        prev->next = next;               // Add the tail after the remaining node
    }
}

remove_next(head);
// head -> 20 -> 10 -> NULL    becomes    head -> 10 -> NULL

Answer 2

Your problem is here:

void insert(node *previousNode, int num)
{
previousNode = new node;
previousNode->nodeNum = num;
previousNode->next = NULL;
}

insert(head, 20);

Here is what this bit of code does: previousNode = new node; makes a pointer to a node and assignes that pointer to previousNode. PreviousNode started off as a copy head, it now points to something new. You now assign values to the new node. In other words, this implementation of insert doesn't insert.

What you want to do is something more like:

void better_insert(node *previousNode, int num)
{
    node *post_node = new node;    #create a brand new pointer to a brand new node
    post_node->nodeNum = num;      #give it a number
    post_node->next = previousNode->next; #we want previousNode to be behind new node
    previousNode->next = post_node;     
}

What this does is: after creating a new node and pointing to it with a new pointer we give it a number. Next thing is to sort out where the pointers are pointing...

let's pretend we wave some nodes in a linked list. All lower case letters are pointers, ok?

a->next = b

now say we want node x to come after a , and have the number 10... we call `better_insert(a, 10)

post_node points to a new node (our node x), and is assigned 10. cool...

we want:

a->next = x
x->next = b

we have:

a->next = b
x->next = null

the last two lines of the function just shuffle stuff til it fits the bill

So in more detail...

we have:

a->next = b
x->next = null

so we call:

post_node->next = previousNode->next; #we want previousNode to be behind new node

now we have: a->next = b x->next = b

now we call:

previousNode->next = post_node;

and we end up with:

a->next = x
x->next = b

or in other 'words':

a->next = x
a->next->next = b

Answer 3

You need to use more variables in your code. An insert operation modifies two nodes. The previous node needs to be changed to point to the new node, and the new node needs to be created and made to point to the node after the previous node (which may or may not be NULL).

void insert(node *previousNode, int num)
{
    node *newnode = new node;
    newnode->nodeNum = num;
    newnode->next = previousNode->next;
    previousNode->next = newnode;
}

To traverse the list, you keep track of a "current node", which you can change from one node to the next:

while (currentNode != 0) {
    do_something_with(currentNode);
    currentNode = currentNode->next;
}

Of course, if do_something_with removes the node then you can't step forward from it afterwards. Also, to remove a node from a singly-linked list you need a pointer to the node before it. So in that case your loop would likely track two nodes, current and previous, rather than just one.

Answer 4

The terminology you're using is confusing you. Hopefully this analogy doesn't further confuse you. Essentially, imagine the linked list as this horrifying set of doorways where once you enter one doorway, it closes behind you and you can only see what's in that room or go to the next room. From the outside of this hallway, you only know where the entrance is, not what's inside.

So, from outside of your linked list structure, all you know is the entrance, some pointer ll_node *head; . Inside of head is some data and a pointer to the next node in your linked list. Traversing that linked list is as simple as starting from the entrance to the hallway, head , and entering one hallway at a time until you find the node you're looking for.

ll_node *current_location = head;
while (current_location != NULL)
{
   // if we are at the node that you were hoping to reach, exit.
   if (current_location->nodeNum == target_data_im_looking_for)
   {
      break;
   }
   // this isn't the node you're looking for, go to the next one.
   current_location = current_location->next;
}

Similarly, inserting a node should traverse to the end of the linked list (until current_location->next == NULL ) and replace the last element's next pointer with the memory location of a new ll_node you create. I won't implement that for you so you have a chance to learn, but there's enough here to get to where you want to be.

Answer 5

Typically a linked list's node does not contain its number. It, usually, consist of a Data, and a pointer to the next node. Also you should get your code free of typos.

typedef Data int;

struct node
{
   Data data; // some Data
   node *next;   // pointer to the next node
}

In general you also don't want a new node after a specified one, but rather to a list. void insert(node *previousNode, int num) signature suggest you want new node after some specified previous one.

Technically you can add a new node to a list in three ways. To the beginning or the end of a list or somewhere in the middle. Adding to the beginning is the fastest and most simple.

void insert(Data num)
{
    node* tmp = new node;  //make a new node
    tmp->data = num;       //fill in data
    tmp->next = head;      //set the next element of new one to be the current head
    head = tmp;            //set new element as the head
}

This way you put a new element in front of the list. You always traverse a one-way linked list from head to the end.

void print_all()
{
   node* current = head;      // start at head
   while(current != NULL){    // while element exists
     cout << current->data << ' ';   //print its data
     current = current->next; //move to the next one
   }
}

It is very easy to understand when you have pictures with boxes for data, and arrows for node* next .

That's for starters. You need to modify the insert function to handle special case where the list is initially empty. Ie head == NULL .

Also I would strongly encourage you to try to implement it in a Object Oriented way. Write class List that makes use of struct node .

class List {
  private:
    node* head;
  public:
    List();
    void insert(data);
    void print_all();
}

Try implementing these functions. From my experience it helps organize your thinking about data structures and container when you do things this way and it's kinda more c++ way to do things like that.

Answer 6

In your above mentioned list you have very little information ie nodeNum. you should keep more ionformation into it. For example at on Node with value nodeNum = 10 there should be some other information you want to get from that Node.So that when user call

node* search(node *head,int num){
      node *temp = head;//copy node reference into temp variable
      while (temp != NULL){
            if (temp->nodeNum == num){
               return temp;
            }
            temp = temp->next;
      }

} 

you can get data in that node with node

 res = search(head,10);

For delete

bool delete(node *head,int num){
      node *temp = head;//copy node reference into template
      node *prev = NULL;
      bool isDelete = false;
      while (temp != NULL){
            if (temp->nodeNum == num){
               break;
            }else
               prev = temp;
               temp = temp->next;
            }
      }
      if (temp != NULL){
          prev-> next = temp->next;//maintain list
          delete temp;
          isDelete = true;
      }
      return  isDelete;
}