郝斌老师-数据结构 离散存储-链表 （创建、遍历、排序、插入、删除）

#include <stdio.h>
#include<malloc.h>
#include<stdlib.h>
typedef struct Node
{
    int data;//数字域，数字域可以很复杂
    struct Node *pNext;//指针域
}NODE, *PNODE;//NODE等价于struct Node，PNODE等价于struct Node *

//函数声明,把结构体声明放到最上面，没声明之前NODE，PODE没法使用
PNODE create_list(void);//创建链表不需要参数
void traverse_list(PNODE pHead);//遍历不需要返回值
bool is_empty(PNODE pHead);//判断链表是否为空，一般不会判断链表是否为满
int length_list(PNODE);//测试链表的长度

//在pHead所指向链表的第pos个节点的前面插入一个新的节点，该节点的值是val，并且pos的值是从1开始
bool insert_list(PNODE, int, int);//PNODE表示链表，int插入的位置，int需要插入的数值

bool delete_list(PNODE, int, int*);//PNODE表示链表，int删除的是那一个节点,可以将删除的节点的参数放到int*里
//调用形式：delet_list(pHead, 3,&val);

void sort_list(PNODE);//排序
int main(void)

{
    PNODE pHead = NULL;//等价于struct Node *pHead=NULL
    int val;
    pHead = create_list();//create_list（）功能：创建一个非循环单链表，并将该链表的头结点的地址赋给pHead
    traverse_list(pHead);//traverse_list访问遍历，将链表中的内容逐一访问

    insert_list(pHead, 3, NULL);
    traverse_list(pHead);

    if (delete_list(pHead, 4, &val))
    {
        printf("删除成功，您删除的元素是： %d\n", val);
    }
    else
    {
        printf("删除失败！\n");
    }


    int len = length_list(pHead);
    printf("链表的长度是%d\n", len);

    sort_list(pHead);
    traverse_list(pHead);

    if (is_empty(pHead))
        printf("链表为空！\n");
    else
        printf("链表不空！\n");
    return 0;
}

PNODE create_list(void)
{
    int len;//用来存放有效节点的个数
    int i;
    int val;//用来临时存放用户输入的节点的值

    //分配了一个不存放有效数据的头结点，pHead是头指针，指向的是头结点
    PNODE pHead = (PNODE)malloc(sizeof(NODE));//sizeof（NODE）返回节点本身的数据类型
    if (NULL == pHead)//一定要判断申请内存是否成功
    {
        printf("分配失败，程序终止！\n");
        exit(-1);
    }

    //pTail永远指向尾节点
    PNODE pTail = pHead;//将pHead赋给pTail，两者都指向头结点
    pTail->pNext = NULL;//将pTail的指针域清空，使得pTail永远指向尾节点
    printf("请输入你需要生成的的链表节点的个数：len= ");
    scanf_s("%d", &len);
    //在for循环前面先生成头结点，再生成有效节点
    for (i = 0; i < len; i++)
    {
        printf("请输入第%d个节点的值", i+1);//生成有效节点的值
        scanf_s("%d", &val);

        //p指向一个临时分配的节点，循环一次p就指向临时分配的新的节点，然后挂到已有的节点的后面
        //每循环一次，就有一个新节点pNew（分配新的节点）
        PNODE pNew = (PNODE)malloc(sizeof(NODE));
        if (NULL == pNew)//一定要判断申请内存是否成功
        {
            printf("分配失败，程序终止！\n");
            exit(-1);
        }

        /*//存在问题（生成的节点全部挂到了头结点的后面且指针域全为空）
        pNew->data = val;//pNew生成一个临时节点，将val的数据放到临时节点的数据域中
        pHead->pNext = pNew;//将新节点挂到pHead的尾节点，pHead指向头结点的指针域是pNew
        pNew->pNext = NULL;//将临时指针域清空，临时节点已变成最后节点*/

        //解决问题的方法是定义一个指针，永远指向最后一个节点
        //生成的节点不是挂到头结点的后面，而是挂到整个链表的节点的后面
        pNew->data = val;
        pTail->pNext = pNew;//pNew挂到了尾节点的后面
        pNew->pNext = NULL;//新节点变成尾节点
        pTail = pNew;//pNew赋给pTail，尾节点的名字变为pTail
    }
    return pHead;
}

void traverse_list(PNODE pHead)
{
    PNODE p = pHead->pNext;//p指向第一个有效节点，p的值可能为空，则只有一个头结点无有效节点

//p的指针域不为空，输出数值data，同时p向后移动一个节点，否则只输出数值data
    while (NULL != p)//意味着p指向了一个有效节点
    {
        printf("%d ", p->data);
        p = p->pNext;
    }
    printf("\n");
    return;
}

//判断是否为空，若是链表为空则只有头结点
bool is_empty(PNODE pHead)
{
    if (NULL == pHead->pNext)
        return true;
    else
        return false;
}

//检测链表的长度
int length_list(PNODE pHead)
{
    PNODE p = pHead->pNext;//p指向的节点不为空，len+1，直到p指向为NULL
    int len = 0;
    while (NULL != p)
    {
        len++;
        p = p->pNext;
    }
    return len;
}

//数组排序函数
/*数组的排序算法：升序排列
{
    int i, j, t, len;
    for (i = 0; i < len - 1; i++)
    {
        for (j = i + 1; j < len; j++)
        {
            if (a[i] > a[j])
            {
                t = a[i];
                a[i] = a[j];
                a[j] = t;
            }
        }
    }

}*/

//链表排序，对比数组的排序
void sort_list(PNODE pHead)
{
    int i, j, t;
     int len = length_list(pHead);
    PNODE p, q;

    //i=0是数组中第一个有效元素的下标，p=pHead->pNext是链表中第一个有效元素的地址
    for (i = 0,p=pHead->pNext; i < len- 1; i++,p=p->pNext)
    {//j是数组中a[i]下一个元素的下标，q是p的下一个节点
        for (j = i + 1,q=p->pNext; j < len; j++,q=q->pNext)
        {
            if (p->data>q->data)//类似于数组中：a[i] > a[j]
            {
                t = p->data;      //类似于数组中：t = a[i];
                p->data = q->data;//类似于数组中：a[i] = a[j];
                q->data = t;      //类似于数组中：a[j] = t;
            }
        }
    }
    return;
}

//在pHead所指向链表的第pos个节点的前面插入一个新的节点，该节点的值是val，并且pos的值是从1开始
//链表一般不存在满的问题，但是要判断pos的值链表的长度的大小，如pos=10，链表的长度i=5，不可插入
//插入不须确保第pos个节点是存在的，删除必须确保第pos节点是存在的
bool insert_list(PNODE pHead, int pos, int val)
{
    int i = 0;
    PNODE p = pHead;

    //不需要判断链表是否为空，是否溢出，同时也不需要求链表的长度
    //最后结果为（pos-1）结束循环，若链表的长度为（pos-1），插入的位置的数最大是pos即链表的最后一位
    //如链表的长度为5，插入的节点的值最大为6
    while(NULL != p&&i < pos - 1)//在第pos个节点插入，必须确保pos的前一个节点存在
    {
        p = p->pNext;
        i++;
    }
    if (i > pos - 1 || NULL == p)
        return false;//搞定


    //如果程序能执行到这一行说明p已经指向了第pos-1个结点,但第pos-1个节点是否存在无所谓
    //分配新的结点
    PNODE pNew = (PNODE)malloc(sizeof(NODE));//一定要判断申请内存是否成功
    if (NULL == pNew)
    {
        printf("动态内存分配失败！\n");
        exit(-1);
    }
    pNew->data = val;

    //将新的结点存入p节点的后面
    PNODE q = p->pNext;
    p->pNext = pNew;
    pNew->pNext = q;
    return true;
}

//删除节点
bool delete_list(PNODE pHead, int pose, int *pVal)
{
    int i = 0;
    PNODE p = pHead;
    while (NULL != p->pNext&&i < pose - 1)//必须确保第pos个节点是存在的
    {
        p = p->pNext;
        i++;
    }
    if (NULL == p->pNext || i > pose - 1)
        return false;

    //如果程序能执行到这一行说明p已经指向了第pos-1个结点，并且第pos个节点是存在的
    PNODE q = p->pNext;//q指向待删除的结点
    *pVal = q->data;

    //删除p节点后面的节点
    p->pNext = p->pNext->pNext;

    //释放q所指向的节点所占的内存
    free(q);
    q = NULL;

    return true;
}

[注]：刚开始学习链表，可能存在理解上的误差