关于链表的一些重要操作（Important operations on a Linked List）

上篇博文中讨论了链表的一些基本操作：

• 链表的基本操作（Basic Operations on a Linked List）

然而，为创建一个多功能的链表，在深度学习之前我们还需要了解更多的链表操作。

• 在表头插入元素。
• 在表中插入元素。
• 在确定的位置插入。
• 在某个元素的后面插入。
• 从链表中删除一个元素。
• 删除整个链表。

在链表头部插入元素

为了在链表头部插入元素，我们要完成一项小任务：创建一个临时节点，把数据存入这个临时节点，将这个节点指向链表的头节点。

/*
Defining a function to add an element at the beginning of the Linked List
*/
struct node * addAtBeg(struct node * head, int number)
{
    //making a temporary node
    struct node * temp = (struct node*)malloc(sizeof(struct node));
 
    //assigning the necessary values
    temp -> data = number;
    temp -> next = head;
 
    //we make the new node as the head node and return
    return temp;
}

在链表的特定位置插入数据

依然创建临时节点，把要插入的数据存入这个节点。将临时节点指向指定位置（假定指定位置在两个节点中间）的下个节点，把指定位置上个节点指向临时节点。

/*Defining a function to add at a particular position in a Linked List*/
struct node * addAtPos(struct node *head, int number, int pos)
{
    //this is our initial position
    int initial_pos = 0;
 
    //This is a very important statement in all Linked List traversals
    //Always create some temporary variable to traverse the list.
    //This is done so that we do not loose the starting point of the
    //Linked List, that is the HEAD
    struct node * mover = head;
 
    while(initial_pos != pos)
    {
        //we need to traverse the Linked List, until
        //we reached the userdefined position
        mover = mover -> next;
 
        //incrementing initial position
        initial_pos++;
    }
 
    //Now mover points to the user defined position
 
    //Create a temporary node
    struct node * temp = (struct node*)malloc(sizeof(struct node));
    temp -> data = number;
 
    //Inserting the node.
    temp -> next = mover -> next;
    mover -> next = temp;
 
    return head;
}

在指定节点后插入数据

整个过程其实和上面的一样，唯一的区别是我们需要遍历整个链表找到指定节点，然后执行过程大同小异。

/*
Defining a function to insert after a specified node
*/
struct node * addAfterNode(struct node * head, int number, int after_num)
{
    //creating a temporary node to iterate
    struct node * mover = head;
 
    while(mover -> data != after_num)
    {
        // We need to iterate until we reach the desired node
        mover = mover -> next;
    }
 
    //Now mover points at the node that we want to insert
 
    struct node *temp = (struct node*)malloc(sizeof(struct node));
    temp -> data = number;
    temp -> next = mover -> next;
    mover -> next = temp;
 
    return head;
}

删除节点

删除节点，我们需要遍历链表找到要删除的节点。删除节点不需要什么高级的操作，只要将被删除节点的前个节点的next指向被删除节点的下个节点就完成了。

/*
Defining a function to delete a node in the Linked List
*/
struct node * deleteANode(struct node * head, int node_data)
{
    //In this function we will try to delete a node that
    //has the particular node data given by the user
 
    struct node * mover = head;
 
    //Creating a variable to store the previous node
    struct node * prev;
 
    while(mover -> data != node_data)
    {
        prev = mover;
        mover = mover -> next;
    }
 
    //Now mover point to the node that we need to delete
    //prev points to the node just before mover.
 
    //Deleting the node mover
    prev -> next = mover -> next;
 
    return head;
}

删除整个链表

简单清空HEAD就能删除整个链表，但数据仍然在内存中，只是丢失对它的连接。要彻底删除我们可以用free()函数。

/*
Defining a function to delete the entire List
*/
struct node * deleteList(struct node * head)
{
    struct node * temp;
 
    while(head != NULL)
    {
        temp = head;
        head = head -> next;
        free(temp);
    }
 
    return NULL;
}

完整代码如下：

#include<stdio.h>
#include<stdlib.h>

//creating the basic structure of a node of a Linked List
struct node
{
    int data;
    struct node * next;
};

/*
Code obtained from

http://www.studyalgorithms.com
*/
/* Defining a function to create a new list.
The return type of the function is struct node, because we will return the head node
The parameters will be the node, passed from the main function.
The second parameter will be the data element.
*/
struct node * createList(struct node *head,int number)
{
    //creating a temporary node for our initialization purpose
    
    //the below line allocates a space in memory that can hold the data in a node.
    struct node *temp = (struct node *)malloc(sizeof(struct node));
    
    //assigning the number to data
    temp -> data = number;
    
    //assigning the next of this node to NULL, as a new list is formed.
    temp -> next = NULL;
    
    //now since we have passed head as the parameter, we need to return it.
    head = temp;
    return head;
}

/*
Defining a case when we need to element in the Linked List.
Here 2 cases can arise:-
    -The Linked List can be empty, then we need to create a new list
    -The Linked List exists, we need to add the element
*/
struct node * addElement(struct node *head, int number)
{
    if(head == NULL)
        head = createList(head, number);   // we can directly call the above function
    else
    {
        // now this is a case when we need to add an element to an existing list.
        
        //Creating a new node and assigning values
        struct node * temp = (struct node*)malloc(sizeof(struct node));
        temp -> data = number;
        temp -> next = NULL;
        
        //Now we have created the node but, we need to insert it at the right place.
        //A Linked List terminates when we encounter a NULL
        //Feel free to copy but please acknowledge studyalgorithms.com
        //Let us traverse the List using another temporary variable.
        //We will point it to the start
        struct node * temp2 = head;
        
        //The limiting condition of the while loop "until temp2's NEXT is not equal to NULL
        //This will happen only in case of the last node of the list.
        while(temp2 -> next != NULL)
        {
            // We need to go to the next node
            temp2 = temp2 -> next;
        }
        
        //Now temp2 points at the last node of the list.
        //We can add the node at this position now.
        
        temp2 -> next = temp;  // the number is added to the end of the List.
    }
    
    return head; // because we only need the HEAD pointer for a Linked List.
}

/*
A function to print the Linked List.
The return type of this function will be void, as we do not need to return anything.
We just need the HEAD as the parameter, to traverse the Linked List.
*/
void printList(struct node * head)
{
    printf("
The list is as:- 
");
    // The terminating point of a Linked List is defined when we encounter a NULL
    while(head != NULL)
    {
        printf("%d ",head->data);
        
        //now we need to move to the next element
        head = head->next;
        //Feel free to copy but please acknowledge studyalgorithms.com        
    }
    printf("
");
}

/*
Defining a function to add an element at the beginning of the Linked List
*/
struct node * addAtBeg(struct node * head, int number)
{
    //making a temporary node
    struct node * temp = (struct node*)malloc(sizeof(struct node));
    
    //assigning the necessary values
    temp -> data = number;
    temp -> next = head;
    
    //we make the new node as the head node and return
    return temp;
}

/*Defining a function to add at a particular position in a Linked List*/
struct node * addAtPos(struct node *head, int number, int pos)
{
    if(head == NULL)
    {
        printf("
List is EMPTY");
        return NULL;
    }
    //this is our initial position
    int initial_pos = 0;
    
    //This is a very important statement in all Linked List traversals
    //Always create some temporary variable to traverse the list.
    //This is done so that we do not loose the starting point of the 
    //Linked List, that is the HEAD
    struct node * mover = head;
    
    while(initial_pos != pos)
    {
        //we need to traverse the Linked List, until
        //we reached the userdefined position
        mover = mover -> next;
        
        //incrementing initial position
        initial_pos++;
        //Feel free to copy but please acknowledge studyalgorithms.com        
    }
    
    //Now mover points to the user defined position
    
    //Create a temporary node
    struct node * temp = (struct node*)malloc(sizeof(struct node));
    temp -> data = number;
    
    //Inserting the node.
    temp -> next = mover -> next;
    mover -> next = temp;
    
    return head;
}

/*
Defining a function to insert after a specified node
*/
struct node * addAfterNode(struct node * head, int number, int after_num)
{
    if(head == NULL)
    {
        printf("
List is EMPTY");
        return NULL;
    }

    //creating a temporary node to iterate
    struct node * mover = head;
    
    while(mover -> data != after_num)
    {
        // We need to iterate until we reach the desired node
        mover = mover -> next;
    }
    
    //Now mover points at the node that we want to insert
    
    struct node *temp = (struct node*)malloc(sizeof(struct node));
    temp -> data = number;
    temp -> next = mover -> next;
    //Feel free to copy but please acknowledge studyalgorithms.com    
    mover -> next = temp;
    
    return head;
}

/*
Defining a function to delete a node in the Linked List
*/
struct node * deleteANode(struct node * head, int node_data)
{
    if(head == NULL)
    {
        printf("
List is EMPTY");
        return NULL;
    }

    //In this function we will try to delete a node that
    //has the particular node data given by the user
    
    struct node * mover = head;
    
    //Creating a variable to store the previous node
    struct node * prev;
    
    while(mover -> data != node_data)
    {
        prev = mover;
        mover = mover -> next;
    }
    
    //Now mover point to the node that we need to delete
    //prev points to the node just before mover.
    
    //Deleting the node mover
    prev -> next = mover -> next;
    
    return head;
}

/*
Defining a function to delete the entire List
*/
struct node * deleteList(struct node * head)
{
    if(head == NULL)
    {
        printf("
List is EMPTY");
        return NULL;
    }

    struct node * temp;
    
    while(head != NULL)
    {
        temp = head;
        head = head -> next;
        free(temp);
    }
    
    return NULL;
}

//Defining the main function to implement all the above defined functions
int main(void)
{
    int choice = 10;
    int flag = 0;
    int num;
    int pos;
    
    struct node *listHead = NULL;
    
    while(flag != 1)
    {
        printf("
What do you want to do?
1.>Create a List
2.>Add an element at the end
3.>Add an element at the beginning
4.>Add an element at a position
5.>Add an element after a certain element
6.>Delete at node.
7.>Print the List
8.>Delet the List
9.>Exit.

Enter choice:- ");
        scanf("%d",&choice);
        
        switch(choice)
        {
            case 1:
            printf("Enter a number:- ");
            scanf("%d",&num);
            listHead = createList(listHead, num);
            //Feel free to copy but please acknowledge studyalgorithms.com            
            printList(listHead);
            break;

            case 2:
            printf("Enter a number:- ");
            scanf("%d",&num);
            listHead = addElement(listHead, num);
            printList(listHead);
            break;

            case 3:
            printf("Enter a number:- ");
            scanf("%d",&num);
            listHead = addAtBeg(listHead, num);
            printList(listHead);
            break;

            case 4:
            printf("Enter a number:- ");
            scanf("%d",&num);
            printf("Enter a position:- ");
            scanf("%d",&pos);
            listHead = addAtPos(listHead, num, pos);
            printList(listHead);
            break;

            case 5:
            printf("Enter a number:- ");
            scanf("%d",&num);
            printf("Enter a node:- ");
            scanf("%d",&pos);
            listHead = addAfterNode(listHead, num, pos);
            printList(listHead);
            break;

            case 6:
            printf("Enter a node to delete:- ");
            scanf("%d",&num);
            listHead = deleteANode(listHead, num);
            printList(listHead);
            break;

            case 7:
            printList(listHead);
            break;
            
            case 8:
            listHead = deleteList(listHead);
            break;

            case 9:
            flag = 1;
            break;
            
            default:
            printf("Invalid choice
");
            //Feel free to copy but please acknowledge studyalgorithms.com            
            break;
        }
    }
    
    return 0;
}