C语言链表全操作（增，删，改，查，逆序，递增排序，递减排序，链式队列，链式栈）

一，数据结构——链表全操作：

     链表形式：

        

     其中，每个节点（Node）是一个结构体，这个结构体包含数据域，指针域，数据域用来存放数据，指针域则用来指向下一个节点；

     特别说明：对于单链表，每个节点（Node）可以通过指针域（Node *next）来找到下一个节点，但却不能够找到上一个节点；

                   只需要知道头结点就可以确定整个链表；

                   对链表进行的操作一般都需要遍历链表，而链表结束的标志为NULL（要么next指针为空，要么头结点为空）；

                   若要断开两个节点联系，要先保存下个节点，否则后面的节点无法找到；

                   关于链表逆序，思想为将指针方向对调，最后头节点为原链表最后一个节点；

  

     以下为链表增，删，改，查，逆序，排序的函数实现：

     link.h

#ifndef LINK_H_INCLUDED
#define LINK_H_INCLUDED
#include <stdio.h>
#include <stdlib.h>
#define datatype int

struct node
{
    int num;
    int data;
    struct node* next;
};

typedef struct node Node;

void backaddnode(Node **ppnode, int num, datatype data);//增加节点
Node *backaddnodeA(Node *pnode, int num, datatype data);//
void showallnode(Node *pnode);//显示所有的节点
Node *searchfirst(Node *pnode, int num);//查询
int change(Node *pnode, int oldnum, int newnum);//修改失败返回0，成功返回1
Node *rev(Node *pnode);//链表的逆转
Node *del(Node *pnode, int num);//删除
Node *insert(Node *pnode, int findnum, int newnum, datatype data);//实现插入，前面插入
void sort(Node *pnode, char ch);//ch==>  ch==<


#endif // LINK_H_INCLUDED

     link.cpp

#include "link.h"

void  backaddnode(Node **ppnode, int num, datatype data)
{
    Node *newnode = (Node*)malloc(sizeof(Node));
    newnode->num = num;
    newnode->data = data;
    newnode->next = NULL;

    if (*ppnode == NULL)
    {
        *ppnode = newnode;
    }
    else
    {
        Node *p = *ppnode;
        while (p->next != NULL)
        {
            p = p->next;
        }
        p->next = newnode;
    }
}

Node *backaddnodeA(Node *pnode, int num, datatype data)
{
    Node *newnode = (Node*)malloc(sizeof(Node));
    newnode->num = num;
    newnode->data = data;
    newnode->next = NULL;

    if (pnode == NULL)
    {
        pnode = newnode;
    }

    else
    {
        Node *p = pnode;
        while (p->next != NULL)
        {
            p = p->next;
        }
        p->next = newnode;
    }
    return pnode;
}

void showallnode(Node *pnode)
{
    printf("链表:
");
    while (pnode != NULL)
    {
        printf("%d->", pnode->data);
        pnode = pnode->next;
    }
    printf("NULL
");
}

Node *searchfirst(Node *pnode, int num)
{
    while (num != pnode->num&&pnode != NULL)
    {
        pnode = pnode->next;
    }
    return pnode;
}

int change(Node *pnode, int oldnum, int newnum)
{
    while (oldnum != pnode->num&&pnode != NULL)
    {
        pnode = pnode->next;
    }
    if (pnode != NULL)
    {
        pnode->num = newnum;
        return 1;
    }
    else
    {
        return 0;
    }
}

Node *del(Node *pnode, int num)
{
    Node *p = pnode;
    Node *ppre = pnode;

    while (p->num != num&&p != NULL)
    {
        ppre = p;
        p = p->next;
    }
    if (p != pnode)
    {
        ppre->next = p->next;
        free(p);
        p = NULL;

    }
    else
    {
        pnode = pnode->next;
        free(p);
    }
    return pnode;
}

Node * insert(Node *pnode, int findnum, int newnum, datatype data)
{
    Node *newnode = (Node*)malloc(sizeof(Node));
    newnode->num = newnum;
    newnode->data = data;
    newnode->next = NULL;
    Node *p = pnode;
    Node *ppre = pnode;
    while (p->num != findnum&&p != NULL)
    {
        ppre = p;
        p = p->next;
    }

    if (p == pnode)
    {
        newnode->next = pnode;
        pnode = newnode;
    }
    else if (p != NULL)
    {
        ppre->next = newnode;
        newnode->next = p;
    }
    return pnode;
}


void sort(Node *pnode, char ch)
{
    if (ch == '>')
    {
        Node temp;
        for (Node *p1 = pnode; p1!=NULL; p1=p1->next)
        {
            for (Node *p2 = p1; p2 != NULL; p2 = p2->next)
            {
                if (p1->data<p2->data)
                {
                    temp.num = p1->num;
                    p1->num = p2->num;
                    p2->num = temp.num;

                    temp.data = p1->data;
                    p1->data = p2->data;
                    p2->data = temp.data;
                }
            }
        }
    }
    else
    {
        Node temp;
        for (Node *p1 = pnode; p1 != NULL; p1 = p1->next)
        {
            for (Node *p2 = p1; p2 != NULL; p2 = p2->next)
            {
                if (p1->data>p2->data)
                {
                    temp.num = p1->num;
                    p1->num = p2->num;
                    p2->num = temp.num;

                    temp.data = p1->data;
                    p1->data = p2->data;
                    p2->data = temp.data;
                }
            }
        }
    }
}

Node *rev(Node *pnode)
{
    Node *p1, *p2, *p3;
    if (pnode == NULL || pnode->next==NULL)
    {
        return pnode;
    }
    else
    {
        p1 = pnode;
        p2 = pnode->next;
        while (p2 != NULL)
        {
            p3 = p2->next;
            p2->next = p1;
            p1 = p2;
            p2 = p3;
        }
        pnode->next = NULL;
        pnode = p1;
        return pnode;
    }
}

二，链式队列（入列，出列，清空，打印，优先队列，递归实现）

     队列特点：先进先出（FIFO）

     入列：在链表尾部插入节点；

     出列：指针p记录链表头节点head，然后将头结点head赋值为head->next，释放p并赋值为NULL,新队列头节点为head;

    清空与打印：使用递归，打印时先输出节点信息，再进入下一层递归；清空队列时先进入下一层递归后释放节点空间；

    优先队列：在插入元素时，按优先级使用插入排序即可得到按优先级排列的队列；

    queue_link.h

struct queue
{
    int num;//代表数据
    int high;//优先级1111
    struct queue *pNext;//存储下一个节点的地址
};

typedef  struct queue Queue;//简化队列

Queue * initque(Queue *queueA);//初始化
Queue * EnQueue(Queue *queueA, int num, int high);//入队
Queue * DeQueue(Queue *queueA, Queue *pout);//出队
Queue * freeall(Queue *queueA);//清空
void  sort(Queue *queueA);//优先级排队
void printfall(Queue *queueA);//打印所有数据，递归
Queue * insertEnQueue(Queue *queueA, int num, int high);

    queue_link.c

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

Queue *initque(Queue *queueA)//初始化
{
    queueA = NULL;
    return queueA;
}

Queue *EnQueue(Queue *queueA, int num, int high)//入队
{
    Queue *newnode = (Queue *)malloc(sizeof(Queue));
    newnode->num = num;
    newnode->high = high;
    newnode->pNext = NULL;

    if (queueA == NULL)
    {
        queueA = newnode;
    }
    else
    {
        Queue *p = queueA;
        while (p->pNext!=NULL)
        {
            p = p->pNext;
        }
        p->pNext = newnode;
    }
    return queueA;
}

Queue *DeQueue(Queue *queueA, Queue *pout)//出队
{
    if (queueA == NULL)
    {
        pout = NULL;
        return NULL;
    }
    else
    {
        pout->num = queueA->num;
        pout->high = queueA->high;
        pout->pNext = NULL;

        Queue *p = queueA;
        queueA = queueA->pNext;
        free(p);
    }
    return queueA;
}

Queue *freeall(Queue *queueA)//清空
{
    if (queueA == NULL)
    {
        return queueA;
    }
    else
    {
        freeall(queueA->pNext);
        free(queueA);
        queueA = NULL;
    }
}

//void  sort(Queue *queueA);//优先级排队

void printfall(Queue *queueA)//打印所有数据，递归
{
    if (queueA==NULL)
    {
        return;
    }
    else
    {
        printf("num=%d,high=%d,addr=%p
",queueA->num,queueA->high,queueA);
        printfall(queueA->pNext);
    }
}


Queue * insertEnQueue(Queue *queueA, int num, int high)//按优先级插入队列
{
    Queue *newnode = (Queue *)malloc(sizeof(Queue));
    newnode->num = num;
    newnode->high = high;
    newnode->pNext = NULL;

    if (queueA == NULL)
    {
        queueA = newnode;
    }
    else if (queueA->high>newnode->high)
    {
        newnode->pNext = queueA;
        queueA = newnode;
    }
    else
    {
        Queue *p1;
        for (p1 = queueA; p1->pNext!=NULL; p1=p1->pNext)
        {
            if (newnode->high < p1->pNext->high)
            {
                break;
            }
        }
        
        newnode->pNext = p1->pNext;
        p1->pNext = newnode;
    }
    return queueA;
}

   

三，链式栈（入栈，出栈，显示，清空）

    栈特点：先进后出（FILO）

    入栈：在链表最后增加新节点；

    出栈：将链表第一个元素输出，并将其从链表删除；

    stack_link.h

#define  datatype  int
struct stacknode
{
    int num;//编号
    datatype data;//数据
    struct stacknode *pNext;//指针域

};
typedef struct stacknode  StackNode;//简化
StackNode * init(StackNode * phead);//初始化
StackNode * push(StackNode * phead, int num, datatype data);//进栈
StackNode * pop(StackNode * phead, StackNode * poutdata);//出栈
StackNode * freeall(StackNode * phead);//清空
void printfall(StackNode * phead);//打印

   stack_link.c

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

StackNode * init(StackNode * phead)//初始化
{
    phead = NULL;
    return phead;
}

StackNode * push(StackNode * phead, int num, datatype data)//进栈
{
    StackNode *newnode = (StackNode*)malloc(sizeof(StackNode));
    newnode->num = num;
    newnode->data = data;
    newnode->pNext = NULL;
    if (phead == NULL)
    {
        phead = newnode;
    }
    else
    {
        StackNode *p = phead;
        while (p->pNext!=NULL)
        {
            p = p->pNext;
        }
        p->pNext = newnode;
    }
    return phead;

}

StackNode * pop(StackNode * phead, StackNode * poutdata)//出栈
{
    if (phead == NULL)
    {
        poutdata = NULL;
    }
    else if (phead->pNext == NULL)
    {
        poutdata->num = phead->num;
        poutdata->data = phead->data;
        poutdata->pNext = NULL;
        free(phead);
        phead = NULL;
    }
    else
    {
        StackNode *p = phead;
        while (p->pNext->pNext!=NULL)
        {
            p = p->pNext;
        }
        poutdata->num = p->pNext->num;
        poutdata->data = p->pNext->data;
        poutdata->pNext = NULL;

        free(p->pNext);
        p->pNext = NULL;
    }
    return phead;
}


StackNode * freeall(StackNode * phead)//清空
{
    if (phead == NULL)
    {
        return NULL;
    }
    
    else
    {
        /*StackNode *p1 = phead, *p2 = phead;
        while (p1->pNext!=NULL)
        {
            p2 = p1->pNext;
            p1->pNext = p2->pNext;
            free(p2);
            p2 = NULL;
        }
        free(phead);
        phead = NULL;*/
        freeall(phead->pNext);
        free(phead);
        phead = NULL;
    }
}


void printfall(StackNode * phead)//打印
{
    if (phead == NULL)
    {
        return ;
    }
    else
    {
        printf("num=%d,data=%d,addr=%p
",phead->num,phead->data,phead);
        printfall(phead->pNext);
    }
}