C语言链表的操作算法

#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct Node
{
    int data;
    struct Node *pNext;
} NODE, *PNODE;

PNODE init(int);

void show(PNODE);

bool isEmpty(PNODE);

int length(PNODE);

bool insert(PNODE, int, int);

bool deleteNode(PNODE, int, int *);

void sort(PNODE); //第一种写法

void sort1(PNODE); // 第二种写法

void destroy(PNODE);

int main(void)
{
    int length;
    printf("请输入链表的个数：");
    scanf("%d", &length);
    PNODE pHead = init(length);
    // sort1(pHead);
    // insert(pHead, 2, 6);
    // destroy(pHead);
    show(pHead);
    return 0;
}

PNODE init(int length)
{
    //使用尾插法
    int i;
    int val;
    PNODE pHeadNode = (PNODE)malloc(sizeof(NODE)); //头结点
    PNODE pTail = pHeadNode;                       //尾指针
    PNODE pHead = pHeadNode;                       //头指针
    for (i = 0; i < length; i++)
    {
        printf("请输入第%d个值:", i + 1);
        scanf("%d", &val);
        PNODE pNew = (PNODE)malloc(sizeof(NODE));
        pNew->pNext = NULL;
        pNew->data = val;
        pTail->pNext = pNew;
        pTail = pNew;
    }
    return pHead;
}

void show(PNODE pNode)
{
    PNODE p = pNode->pNext;
    while (p != NULL)
    {
        printf("%d ", p->data);
        p = p->pNext;
    }
}

bool isEmpty(PNODE pNode)
{
    if (pNode->pNext == NULL)
    {
        return true;
    }
    return false;
}

int length(PNODE pNode)
{
    PNODE p = pNode->pNext;
    int length = 0;
    if (p != NULL)
    {
        length++;
        p = p->pNext;
    }
    return length;
}

bool insert(PNODE pNode, int pos, int val)
{
    PNODE p = pNode;
    int i = 0;
    while (p != NULL && i < pos - 1) //找到第pos位置的前一个NODE
    {
        p = p->pNext;
        i++;
    }
    if (p == NULL)
    {
        return false;
    }
    PNODE pNew = (PNODE)malloc(sizeof(NODE));
    pNew->pNext = p->pNext;
    p->pNext = pNew;
    pNew->data = val;
    return true;
}

bool deleteNode(PNODE pNode, int pos, int *val)
{
    PNODE p = pNode;
    int i = 0;
    while (p != NULL && i < pos - 1) //找到第pos位置的前一个NODE
    {
        p = p->pNext;
        i++;
    }
    if (p == NULL)
    {
        return false;
    }
    PNODE pTemp = p->pNext;
    *val = pTemp->data;
    p->pNext = p->pNext->pNext;
    free(pTemp);
    pTemp = NULL;
    return true;
}

void sort(PNODE pNode)
{
    PNODE pHead = pNode->pNext;
    PNODE pTemp = NULL;
    while (pHead != pTemp)
    {
        while (pHead->pNext != pTemp)
        {
            int temp;
            if (pHead->data > pHead->pNext->data)
            {
                temp = pHead->data;
                pHead->data = pHead->pNext->data;
                pHead->pNext->data = temp;
            }
            pHead = pHead->pNext;
        }
        pTemp = pHead;
        pHead = pNode->pNext;
    }
}

void sort1(PNODE pNode)
{
    PNODE pFirstNode = pNode;
    PNODE pSecondNode = pFirstNode->pNext;
    while (pFirstNode->pNext != NULL)
    {
        while (pSecondNode->pNext != NULL)
        {
            int temp;
            if (pFirstNode->pNext->data > pSecondNode->pNext->data)
            {
                temp = pFirstNode->pNext->data;
                pFirstNode->pNext->data = pSecondNode->pNext->data;
                pSecondNode->pNext->data = temp;
            }
            pSecondNode = pSecondNode->pNext;
        }
        pFirstNode = pFirstNode->pNext;
        pSecondNode = pFirstNode->pNext;
    }
}

void destroy(PNODE pNode)
{
    PNODE cur = pNode->pNext;
    PNODE next = cur->pNext;
    while (cur != NULL)
    {
        free(cur);
        cur = next;
        if (next == NULL)
            break;
        next = next->pNext;
    }
    pNode->pNext = NULL;
}