单向链表的基本操作（创建，插入，删除，销毁，输出）（c语言）

线性链表的基本操作：基础知识：熟练掌握动态数组，结构体，指针

（单向链表的创建）

基本思想：首先创建一个头节点，让头指针和尾指针指向刚创建的空间；

然后动态建立一个空间，用pnew指向这个空间，tail指向的指针域（即结构体内存放地址的地方）存放pnew指向的空间的地址；

最后，将pnew赋值给tail；循环这个过程

如图，代码如下

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

struct student
{
    int score;
    struct student* next;
};

typedef struct student student;

student* Creatlist()
{
    student* head, * tail, * pnew;
    int score;
    head = (student*)malloc(sizeof(student));
    if (head == NULL)
    {
        printf("the memory is no enough\n");
        return NULL;
    }
    head->next = NULL;
    tail = head;
    printf("input the score:\n");
    while (1)
    {
        scanf("%d", &score);
        if (score < 0)
            break;
        pnew = (student*)malloc(sizeof(student));
        if (pnew == NULL)
        {
            printf("the memory is no enough\n");
            return NULL;
        }
        pnew->score = score;
        pnew->next = NULL;

        tail->next = pnew;
        tail = pnew;
    }
    return (head);
}



int main()
{
    student* p = Creatlist();

    return 0;
}

（单向链表的插入操作）

基本思想：通过单链表的头指针head，找到链表的第一个节点（即将head指向的地址赋给pnew）；然后，通过遍历单向查找第i个节点，pnew指向第i个节点之后；插入后将新节点的指针域指向第i个节点的后继结点，再将第i个节点的指针域指向新的节点；

如此，插入的节点平滑的与链表连接了起来

struct NODE
{
    int score;
    struct student* next;
};
typedef struct NODE NODE;


void Insert_Linklist(NODE* head,NODE* pnew,int i)
{
    NODE* p;
    int j;
    
    p = head;
    for (j = 0; j < i && p != NULL; j++)
        p = p->next;
    if (p == NULL)
    {
        printf("the %d node not found\n");
        return;
    }
    pnew->next = p->next;
    p->next = pnew;
}

（单向链表的删除）

基本思想：查找操作都一直，设置两个指针p，q；

for操作后p指向第i个节点的前驱节点；

q指向第i个节点；删除时执行p->next=q->next即可，最后释放第i个节点的空间；

void Delete_Linklist(NODE* head, int i)
{
    NODE* p, * q;
    int j;
    if (i == 0)
        return;

    p = head;
    for (j = 1; j < i && p->next != NULL; j++)
        p = p->next;
    if (p->next == NULL)
    {
        printf("the %d node not found\n", i);
        return;
    }

    q = p->next;
    p->next = q->next;
    free(q);
}

（单链表的销毁）(操作与每次删除一个节点相同)

即将创建的链表从内存中释放；

基本思想：每次删除头节点的后继结点，最后删除头节点。

同时每次都用free（）释放内存。

不要以为删除了头节点就是删除了整个链表，这其实只是无法访问这个链表，但仍然还会占用大量空间。

void free_Linklist(NODE* head)
{
    NODE* p, * q;
    p = head;
    while (p->next != NULL)
    {
        q = p->next;
        p->next = q->next;
        free(q);
    }
    free(head);
}

（链表的输出）

基本思想：通过单链表的头指针head，让指针p指向下个节点访问操作，然后输出其数据值，一直循环，直到访问到尾节点NULL停止

void Display_Linklist(NODE* head)
{
    NODE* p;

    for (p = head->next; p != NULL; p = p->next)
        printf("%d ", p->score);
    printf("\n");
}