关于链表的理解

数据结构是与指针密不可分的，没有指针数据结构就没意思了

这是我学的第一个数据结构——链表（增，删，改，查）

#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
#include<stdbool.h>
typedef struct Node 
{
    int date;//数据域
    struct Node *pNext;//指针域，指向的是一个与它本身数据类型的节点，但不是一个节点
}NODE,*PNODE;//node等价于struct node，pnode等价于struct node*
void traverse_list(PNODE pHead);//遍历链表
PNODE creat_list(void);//创建链表
bool is_empty(PNODE pHead);
int length_list(PNODE pHead );//长度
bool insert_list(PNODE pHead,int pos ,int val );//插入
bool delete_list(PNODE pHead,int pos ,int *pval);//删除节点
void sort_list(PNODE pHead);
int main(void)
{
    //分配内存
    PNODE pHead =NULL;//先让头指针为空，pHead是一个头指针
    pHead=creat_list();//创建一个非循环单链表，并将该链表的头结点，在一个函数里面分配内存，可以在另一个函数用
    traverse_list(pHead);//遍历链表
    if(is_empty(pHead))
    {
        printf("链表为空\n");
    }
    else
    {
        printf("链表不空\n");
    }
    int len=length_list(pHead);
    int val;
    printf("链表长度是%d\n",len);
    sort_list(pHead);
    traverse_list(pHead);
    //insert_list(pHead,4,33);
    //traverse_list(pHead);
    if(delete_list(pHead,4,&val))
    {
        printf("您删除的元素是%d\n",val);
    }
    else
    {
        printf("删除失败\n");
    }
    return 0;
}
PNODE creat_list(void)//生成链表
{
    int len;//有效节点的个数
    int i;
    int val;//用来临时储存用户输入的值
    //分配了一个不存放有效数据的头结点，phead是头指针
    PNODE pHead=(PNODE)malloc(sizeof(NODE));//分配的头结点用于找出后面所有的节点
    if(NULL==pHead)//如果头结点为空，则证明分配失败了
    {
        printf("分配失败，程序终止");
        exit(-1);//程序终止
    }
    PNODE pTail=pHead;//定义一个永远指向尾结点的指针
    pTail->pNext=NULL;//如果指向的下一个节点为空，则证明已经结束
    printf("请输入您要生成的链表节点的个数：len=");//用户输入的节点个数
    scanf("%d",&len);
    for(i=0;i<len;i++)//每循环一次就造出来一个新的节点，根据用户输入节点的个数，进行遍历创造节点
    {
        printf("请输入第%d个节点的值：",i+1);//i从0开始
        scanf("%d",&val);//用户输入的值
        PNODE pNew=(PNODE)malloc(sizeof(NODE));//创造的新的节点，每循环一次创造一个新的节点
         if(NULL==pHead)//如果头指针你为空，分配失败
    {
        printf("分配失败，程序终止");
         exit(-1);
    }//pNew生成的节点挂在整个链表的尾结点，再定义一个指针永远指向尾结点
    pNew->date=val;//令用户输入的值存放在新的节点的数据域部分
    pTail->pNext=pNew;//让新的节点的地址存放在尾的指针域
    pNew->pNext=NULL;//让新产生的节点的指针域为空
    pTail=pNew;
    }
    return pHead;
}
void traverse_list(PNODE pHead)
{
    PNODE p=pHead->pNext;
    while(p!=NULL)
    {
        printf("%d ",p->date);
        p=p->pNext;
    }
    printf("\n");   
    return;
}
bool is_empty(PNODE pHead)
{
    if(pHead->pNext==NULL)
    {
        return true;
    }
    else return false;
}
int length_list(PNODE pHead)
{
    PNODE p=pHead->pNext;
    int len=0;
    while(NULL!=p)
    {
        len++;
        p=p->pNext;
    }
    return len;
}
void sort_list(PNODE pHead)
{
    int i,j,t;
    int len=length_list(pHead);
    PNODE p,q;
    for(i=0,p=pHead->pNext;i<len;i++,p=p->pNext)
    {
        for(j=i+1,q=p->pNext;j<len;j++,q=q->pNext)
        {
            if(p->date>q->date)
            {
                t=p->date;
                p->date=q->date;
                q->date=t;//类似于数组中的a[i]>a[j]
            }
        }
    }
    return ;
}
//在pHead所指向链表的第pos个节点的前面插入一个新的节点，该节点的值是val,并且pos从0开始
bool insert_list(PNODE pHead,int pos ,int val)
{
    int i=0;
    PNODE p= pHead;
    while(NULL!=p&&i<pos-1)
    {
        p=p->pNext;
        ++i;
    }
    if(i>pos-1||NULL==p)
        return false;
        PNODE pNew=(PNODE)malloc(sizeof(NODE));
        if(NULL==pNew)
        {
            printf("动态分配失败");
            exit(-1);
        }
        pNew->date=val;
        PNODE q=p->pNext;
        p->pNext=pNew;
        pNew->pNext=q;
        return true;
}//链表不存在满的情况，需要判断pos的值是否合法
bool delete_list(PNODE pHead,int pos ,int *pval)
{//要删除第五个节点就必须知道第四个节点在哪放着，找到pos-1，因为第四个存放着第五个的地址
    int i=0;
    PNODE p=pHead;
    while(NULL!=p->pNext&&i<pos-1)
    {
        p=p->pNext;
        ++i;
    }
    if(i>pos-1||NULL==p->pNext)//
    return false;//这是针对于上一个while循环不成立时要做出的判断
    PNODE q=p->pNext;
    *pval=q->date;
    //删除p节点后面的节点
    p->pNext=p->pNext->pNext;
    free(q);
    q=NULL;
    return true;
}

head头指针存放着的是第一个节点的地址，即首节点的地址，而head->next是第二个节点的地址，依次往复，最后一个节点的指针域为NULL

206. 反转链表 - 力扣（LeetCode） (leetcode-cn.com)

反转一个链表只需要改地址就行，把箭头倒过来指

//c
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* reverseList(struct ListNode* head) {
    struct ListNode* pre = NULL;//将pre初始化
    struct ListNode* cur = head;//把头指针给cur存起来，头指针的地址就是第一个节点首节点的地址
    while (cur!=NULL) {//遍历链表
        struct ListNode* p = cur->next;//定义一个结构体指针变量来存放下一个节点的地址，依次的将箭头倒过来
        cur->next = pre;//将pre存放的地址给下一个节点
        pre = cur;
        cur = p;
    }
    return pre;
}