经典算法_链表

1 创建一个链表，包含在尾部插入数据、删除所有结点（清空链表）、逆转链表、排序、统计结点个数、查找、修改的函数。

头文件linknode.h

源文件

源文件main.c

源文件linknode.c

2 创建一个静态链表，实现增加、删除、修改功能

3 创建一个动态链表，实现增加、删除、修改功能

4 创建一个链式栈，实现十进制转换为二进制

头文件stacklinknode.h

源文件

源文件main.c

源文件stacklinknode.h

5 创建一个链队列，实现优先队列

头文件Queue.h

源文件

源文件main.c

源文件Queue.c

1 创建一个链表，包含在尾部插入数据、删除所有结点（清空链表）、逆转链表、排序、统计结点个数、查找、修改的函数。

头文件linknode.h

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

struct student
{
    int num;
    float score;
    struct student *pNext;
};

typedef struct student ST;

void add(ST **phead, int inum, float iscore);//函数声明，传入头结点的地址，然后插入

void showall(ST *head);//传递头结点，显示所有数据

ST *rev(ST *head);//实现链表逆转

void sort(ST *head, char ch);//ch == '>' 从大到小排序，ch == '<' 从小到大排序，选择排序法不适合，采用冒泡

int getnum(ST *head);//获取结点个数

ST *search(ST *head, int num);//根据编号查找结点

void change(ST *head, int oldnum, int newnum);//查找oldnum，修改为newnum

ST *HeadInsert(ST *head, int num, int inum, float iscore);//根据结点，在结点前面插入

ST *BackInsert(ST *head, int num, int inum, float iscore);//根据结点，在结点后面插入

ST *delete(ST *head, int num);//传入头结点，删除结点的编号，返回头结点

 

源文件main.c

#define _CRT_SECURE_NO_WARNINGS

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

main1()//清空链表
{
    struct student *head = NULL;//头结点指针

    add(&head, 1, 70);
    add(&head, 2, 80);
    add(&head, 3, 90);
    add(&head, 4, 91);
    add(&head, 5, 92);

    showall(head);

    head = freeall(head);

    printf("删除以后
");
    showall(head);

    system("pause");
}

main2()//逆转链表
{
    struct student *head = NULL;//头结点指针

    add(&head, 1, 70);
    add(&head, 2, 80);
    add(&head, 3, 90);
    add(&head, 4, 91);
    add(&head, 5, 92);

    printf("逆转链表前
");
    showall(head);

    head = rev(head);//逆转链表
    
    printf("逆转链表后
");
    showall(head);

    system("pause");
}

main3()//排序
{
    struct student *head = NULL;//头结点指针

    add(&head, 10, 70);
    add(&head, 2, 80);
    add(&head, 30, 90);
    add(&head, 4, 91);
    add(&head, 50, 92);

    printf("排序前
");
    showall(head);

    sort(head, '>');

    printf("排序>后
");
    showall(head);
    
    sort(head, '<');

    printf("排序<后
");
    showall(head);

    system("pause");
}

main4()//统计结点个数
{
    struct student *head = NULL;//头结点指针

    add(&head, 1, 70);
    add(&head, 2, 80);
    add(&head, 3, 90);
    add(&head, 4, 91);
    add(&head, 5, 92);

    showall(head);

    printf("%d
", getnum(head));//统计结点个数

    system("pause");
}

main5()//查找
{
    struct student *head = NULL;//头结点指针

    add(&head, 1, 70);
    add(&head, 2, 80);
    add(&head, 3, 90);
    add(&head, 4, 91);
    add(&head, 5, 92);

    showall(head);

    ST *psearch = search(head, 3);

    printf("%d,%f
", psearch->num, psearch->score);

    system("pause");
}

main6()//修改
{
    struct student *head = NULL;//头结点指针

    add(&head, 1, 70);
    add(&head, 2, 80);
    add(&head, 3, 90);
    add(&head, 4, 91);
    add(&head, 5, 92);

    printf("修改前
");
    showall(head);

    change(head, 3, 30);

    printf("修改后
");
    showall(head);

    system("pause");
}

main7()//根据结点，在结点前面、后面插入
{
    struct student *head = NULL;//头结点指针

    add(&head, 1, 70);
    add(&head, 2, 80);
    add(&head, 3, 90);
    add(&head, 4, 91);
    add(&head, 5, 92);

    printf("在结点前面插入前
");
    showall(head);

    head = HeadInsert(head, 2, 20, 90.0);

    printf("在结点前面插入后
");
    showall(head);

    printf("在结点后面插入前
");
    showall(head);

    head = BackInsert(head, 1, 100, 100.9);

    printf("在结点后面插入后
");
    showall(head);

    system("pause");
}

main()//传入头结点，删除结点的编号，返回头结点
{
    struct student *head = NULL;//头结点指针

    add(&head, 1, 70);
    add(&head, 2, 80);
    add(&head, 3, 90);
    add(&head, 4, 91);
    add(&head, 5, 92);

    printf("删除结点前
");
    showall(head);

    head = delete(head, 3);//删除中间值

    printf("删除结点后
");
    showall(head);

    head = delete(head, 1);//删除第一个

    printf("删除结点后
");
    showall(head);

    head = delete(head, 5);//删除最后一个

    printf("删除结点后
");
    showall(head);

    system("pause");
}

 

源文件linknode.c

#include "linknode.h"

void add(ST **phead, int inum, float iscore)//函数声明，传入头结点的地址，然后插入
{
    if (*phead == NULL)
    {
        ST *newnode = (ST *)malloc(sizeof(ST));//分配内存
        if (newnode == NULL)
        {
            printf("内存分配失败");
            return;
        }
        newnode->num = inum;//结点初始化
        newnode->score = iscore;
        newnode->pNext = NULL;

        *phead = newnode;//让头指针指向这个结点
    }
    else
    {
        //链表不为空，尾部插入
        ST *p = *phead;//指向头结点
        while (p->pNext != NULL)//循环到最后一个结点的地址
        {
            p = p->pNext;
        }
        ST *newnode = (ST *)malloc(sizeof(ST));//分配内存
        newnode->num = inum;//结点初始化
        newnode->score = iscore;
        newnode->pNext = NULL;

        p->pNext = newnode;//链接上
    }
}

void showall(ST *head)//传递头结点，显示所有数据
{
    while (head != NULL)//判断指针是否指向为空
    {
        printf("num=%d,score=%f,%x,%x
", head->num, head->score, head, head->pNext);
        head = head->pNext;//指针不断向前循环
    }
}

void *freeall(ST *head)//删除所有结点
{
    ST *p1, *p2;
    p1 = p2 = NULL;
    p1 = head;//头结点

    while (p1->pNext != NULL)//循环遍历所有的结点
    {
        p2 = p1->pNext;//p2为p1下一个结点
        p1->pNext = p2->pNext;//p1存储了p2的下一个结点的地址
        free(p2);
        printf("
");
        showall(head);//显示删除的中间状态
    }

    free(head);

    return NULL;
}

ST *rev(ST *head)
{
    ST *p1, *p2, *p3;
    p1 = p2 = p3 = NULL;

    if ((head == NULL) || (head->pNext == NULL))//如果只有一个结点，或者链表为空
    {
        return head;//返回头结点
    }

    p1 = head;
    p2 = head->pNext;

    while (p2 != NULL)//从第二个到最后一个结点进行循环
    {
        p3 = p2->pNext;//布局3个结点
        p2->pNext = p1;//指向前面一个结点
        p1 = p2;//指针向前移动，从第二个到最后一个结点全部指向前面的结点
        p2 = p3;
    }

    head->pNext = NULL;//代表链表的结束，设置第一个结点指向为空
    head = p1;//指向最后一个结点

    return head;//副本机制，改变的head并不会生效，需要返回值赋值生效
}

void sort(ST *head, char ch)
{
    if (ch == '>')
    {
        for (ST *p1 = head;p1 != NULL;p1 = p1->pNext)//必须用冒泡，必须遍历所有链表，数组可以规避一些无意义的，但是链表必须全部刷一遍
        {
            for (ST *p2 = head;p2 != NULL;p2 = p2->pNext)
            {
                if (p1->num < p2->num)
                {
                    ST temp;
                    temp.num = p1->num;
                    p1->num = p2->num;
                    p2->num = temp.num;

                    temp.score = p1->score;
                    p1->score = p2->score;
                    p2->score = temp.score;
                }
            }
        }
    }
    else if (ch == '<')
    {
        for (ST *p1 = head;p1 != NULL;p1 = p1->pNext)
        {
            for (ST *p2 = head;p2 != NULL;p2 = p2->pNext)
            {
                if (p1->num > p2->num)
                {
                    ST temp;
                    temp.num = p1->num;
                    p1->num = p2->num;
                    p2->num = temp.num;

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

int getnum(ST *head)
{
    int i = 0;

    while (head != NULL)//判断指针是否指向为空
    {
        i++;
        head = head->pNext;//指针不断向前循环
    }

    return i;//统计个数
}

ST *search(ST *head, int num)//根据编号查找结点
{
    while (head != NULL)//判断指针是否指向为空
    {
        if (head->num == num)
        {
            return head;//返回当前结点的指针地址
        }
        head = head->pNext;//指针不断向前循环
    }

    return NULL;//找不到，返回NULL
}

void change(ST *head, int oldnum, int newnum)//查找oldnum，修改为newnum
{
    ST *psearch = search(head, oldnum);//调用查找函数
    
    if (psearch == NULL)
    {
        printf("没有找到
");
    }
    else
    {
        psearch->num = newnum;
        printf("修改成功
");
    }
}

ST *HeadInsert(ST *head, int num, int inum, float iscore)//根据结点，在结点前面插入
{
    ST *p1, *p2;
    p1 = p2 = NULL;
    p1 = head;//从头结点开始

    while (p1 != NULL)//一直循环到最后一个结点
    {
        if (p1->num == num)//判断相等
        {
            break;
        }
        else
        {
            p2 = p1;//记录当前结点
            p1 = p1->pNext;//循环到下一个结点
        }
    }

    if (head == p1)
    {
        ST *newnode = (ST *)malloc(sizeof(ST));//分配内存
        newnode->num = inum;//初始化结点
        newnode->score = iscore;
        newnode->pNext = head;//指向第一个结点
        head = newnode;//newnode成为第一个结点
    }
    else
    {
        ST *newnode = (ST *)malloc(sizeof(ST));//分配内存
        newnode->num = inum;//初始化结点
        newnode->score = iscore;
        newnode->pNext = p1;//新结点指向p1
        p2->pNext = newnode;//指向新结点
    }

    return head;
}

ST *BackInsert(ST *head, int num, int inum, float iscore)//根据结点，在结点后面插入
{
    ST *p1, *p2;
    p1 = p2 = NULL;
    p1 = head;//从头结点开始

    while (p1 != NULL)//一直循环到最后一个结点
    {
        if (p1->num == num)//判断相等
        {
            break;
        }
        else
        {
            p1 = p1->pNext;//循环到下一个结点
        }
    }

    if (p1->pNext == NULL)//最后一个结点
    {
        ST *newnode = (ST *)malloc(sizeof(ST));//分配内存
        newnode->num = inum;//初始化结点
        newnode->score = iscore;
        newnode->pNext = NULL;//指针域此时为空，代表最后一个结点
        p1->pNext = newnode;//指向新开辟的结点
    }
    else
    {
        p2 = p1->pNext;//记录下一个结点的位置
        ST *newnode = (ST *)malloc(sizeof(ST));//分配内存
        newnode->num = inum;//初始化结点
        newnode->score = iscore;
        newnode->pNext = p2;//链接下一个结点
        p1->pNext = newnode;//指向新结点
    }

    return head;
}

ST *delete(ST *head, int num)//传入头结点，删除结点的编号，返回头结点
{
    ST *p1, *p2;
    p1 = p2 = NULL;
    p1 = head;//从头结点开始循环

    while (p1 != NULL)
    {
        if (p1->num == num)//判断是否相等
        {
            break;
        }
        else
        {
            p2 = p1;//记录当前结点
            p1 = p1->pNext;//继续往后循环
        }
    }

    if (p1 == head)//要删除的在头结点
    {
        head = p1->pNext;//跳过头结点
        free(p1);//释放第一个结点
    }
    else
    {
        p2->pNext = p1->pNext;//跳过p1
        free(p1);//释放
    }

    return head;
}

 

2 创建一个静态链表，实现增加、删除、修改功能

#define _CRT_SECURE_NO_WARNINGS

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

struct Node
{
    int num;
    struct Node *pNext;
};

//链表增加，删除，修改，不需要移动，直接操作
//查询与修改，无法像数组定位位置，需要用循环的方式来定位，查找与修改相对麻烦

main()
{
    struct Node *p = NULL;//存储指针的开头
    struct Node n1, n2, n3, n4, n5;
    
    n1.num = 1;
    n2.num = 2;
    n3.num = 3;
    n4.num = 4;
    n5.num = 5;
    
    p = &n1;//串联结构体
    n1.pNext = &n2;
    n2.pNext = &n3;
    n3.pNext = &n4;
    n4.pNext = &n5;
    n5.pNext = NULL;

    struct Node *px = p;//创建一个指针副本，保存头结点的地址

    printf("删除前
");
    while (p != NULL)//为空，指针访问结束
    {
        printf("num=%d,%x
", p->num, p);//访问数据
        p = p->pNext;//指针往后移动
    }
    
    //删除，删除某个结点
    n2.pNext = &n4;//实现了删除n3结点，链表的删除非常方便，不需要移动

    p = px;
    printf("删除，删除某个结点
");
    while (p != NULL)//为空，指针访问结束
    {
        printf("num=%d,%x
", p->num, p);//访问数据
        p = p->pNext;//指针往后移动
    }

    //增加，尾部插入
    struct Node n6;
    n6.num = 6;
    n6.pNext = NULL;//链接起来

    n5.pNext = &n6;

    p = px;
    printf("增加，尾部插入
");
    while (p != NULL)//为空，指针访问结束
    {
        printf("num=%d,%x
", p->num, p);//访问数据
        p = p->pNext;//指针往后移动
    }

    //增加，2-4之间插入一个10
    struct Node n7;//插入不需要移动，改变指向即可
    n7.num = 10;
    
    n2.pNext = &n7;
    n7.pNext = &n4;

    p = px;
    printf("增加，2-4之间插入一个10
");
    while (p != NULL)//为空，指针访问结束
    {
        printf("num=%d,%x
", p->num, p);//访问数据
        p = p->pNext;//指针往后移动
    }

    //修改，把10改成8
    p = px;
    printf("修改，把10改成8
");
    while (p != NULL)//为空，指针访问结束
    {
        if (p->num == 10)
        {
            p->num = 8;
        }
        printf("num=%d,%x
", p->num, p);//访问数据
        p = p->pNext;//指针往后移动
    }

    system("pause");
}

3 创建一个动态链表，实现增加、删除、修改功能

#define _CRT_SECURE_NO_WARNINGS

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

struct Node
{
    int num;
    struct Node *pNext;
};

//动态链表，删除、插入非常容易，不需要移动
//查询、修改，非常麻烦，无法像数组，需要循环遍历所有的结点

main()
{
    struct Node *p = NULL;//头指针
    struct Node *p1, *p2, *p3, *p4, *p5;//创建5个结点指针

    p1 = (struct Node *)malloc(sizeof(struct Node));//分配内存
    p2 = (struct Node *)malloc(sizeof(struct Node));
    p3 = (struct Node *)malloc(sizeof(struct Node));
    p4 = (struct Node *)malloc(sizeof(struct Node));
    p5 = (struct Node *)malloc(sizeof(struct Node));

    p1->num = 1;//初始化结点数据
    p2->num = 2;
    p3->num = 3;
    p4->num = 4;
    p5->num = 5;

    p = p1;//进行链接
    p1->pNext = p2;
    p2->pNext = p3;
    p3->pNext = p4;
    p4->pNext = p5;
    p5->pNext = NULL;

    struct Node *px = p;//副本指针

    while (p != NULL)
    {
        printf("num=%d
", p->num);
        p = p->pNext;
    }

    //修改
    p = px;
    printf("修改，修改以后
");
    while (p != NULL)
    {
        if (p->num == 3)
        {
            p->num = 30;
        }
        printf("num=%d
", p->num);
        p = p->pNext;
    }

    //删除
    p2->pNext = p4;
    free(p3);

    p = px;
    printf("删除，删除以后
");
    while (p != NULL)
    {
        printf("num=%d
", p->num);
        p = p->pNext;
    }

    //插入，尾部插入
    struct Node *p6;
    p6 = (struct Node *)malloc(sizeof(struct Node));
    p6->num = 6;
    p6->pNext = NULL;

    p5->pNext = p6;//尾部插入

    p = px;
    printf("插入，尾部插入
");
    while (p != NULL)
    {
        printf("num=%d
", p->num);
        p = p->pNext;
    }

    //插入，中间插入
    struct Node *p10;
    p10 = (struct Node *)malloc(sizeof(struct Node));
    p10->num = 10;
    p10->pNext = p4;

    p2->pNext = p10;

    p = px;
    printf("插入，中间插入
");
    while (p != NULL)
    {
        printf("num=%d
", p->num);
        p = p->pNext;
    }

    system("pause");
}

4 创建一个链式栈，实现十进制转换为二进制

头文件stacklinknode.h

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

struct stacknode
{
    int num;
    int data;
    struct stacknode *pNext;//指针域
};

typedef struct stacknode StackNode;//简写

StackNode *init(StackNode *phead);//初始化

StackNode *push(StackNode *phead, int num, int data);//进栈，增加头结点，返回头结点

StackNode *printfall(StackNode *phead);//全部打印

StackNode *pop(StackNode *phead, StackNode *poutdata);//出栈

StackNode *freeall(StackNode *phead);//清空

源文件

源文件main.c

#define _CRT_SECURE_NO_WARNINGS

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

main1()
{
    StackNode *phead = NULL;//创建一个链式栈的头结点

    phead = init(phead);//设置栈为空

    phead = push(phead, 1, 1);
    phead = push(phead, 2, 11);
    phead = push(phead, 3, 111);
    phead = push(phead, 4, 1111);
    phead = push(phead, 5, 11111);

    printf("进栈以后
");
    printfall(phead);//全部打印

    printf("清空以后
");
    phead = freeall(phead);
    printfall(phead);//全部打印

    //while (phead->pNext != NULL)
    //{
    //    printf("出栈
");
    //    StackNode *pout = (StackNode *)malloc(sizeof(StackNode));
    //    phead = pop(phead, pout);
    //    printf("出栈以后
");
    //    printfall(phead);//全部打印
    //    printf("出栈以后的数据%d,%d
", pout->num, pout->data);
    //}

    system("pause");
}

main()
{
    int num;
    scanf("%d", &num);
    printf("num=%d
", num);
    StackNode *phead = NULL;//创建一个链式栈的头结点
    
    while (num)//进栈
    {
        phead = push(phead, num % 2, 0);
        num /= 2;
    }

    while (phead != NULL)//出栈
    {
        StackNode *pout = (StackNode *)malloc(sizeof(StackNode));
        phead = pop(phead, pout);

        printf("%d", pout->num);
    }

    system("pause");
}

源文件stacklinknode.c

#include "stacklinknode.h"

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

StackNode *push(StackNode *phead, int num, int data)//进栈，增加头结点，返回头结点
{
    StackNode *pnewnode = (StackNode *)malloc(sizeof(StackNode));

    pnewnode->num = num;
    pnewnode->data = data;
    pnewnode->pNext = NULL;//开辟结点并赋值
    
    if (phead == NULL)//空链表，直接连接上
    {
        phead = pnewnode;//连接一个结点
    }
    else
    {
        StackNode *p = phead;
        while (p->pNext != NULL)
        {
            p = p->pNext;//一直向前
        }
        p->pNext = pnewnode;//插入
    }

    return phead;
}

StackNode *printfall(StackNode *phead)//全部打印
{
    if (phead == NULL)
    {
        return NULL;
    }
    else
    {
        printf("%d,%d,%x,%x
", phead->num, phead->pNext, phead, phead->pNext);
        printfall(phead->pNext);
    }
}

StackNode *pop(StackNode *phead, StackNode *poutdata)//出栈
{
    if (phead == NULL)//已经没有元素
    {
        return NULL;
    }
    else if (phead->pNext == NULL)//只有一个结点
    {
        poutdata->num = phead->num;//取出数据
        poutdata->data = phead->data;
        free(phead);
        phead = NULL;
        return NULL;
    }
    else
    {
        StackNode *p = phead;//建立指针，返回指针
        while (p->pNext->pNext != NULL)
        {
            p = p->pNext;//循环到倒数第二个结点
        }
        poutdata->num = p->pNext->num;//取出数据
        poutdata->data = p->pNext->data;
        free(p->pNext);
        p->pNext = NULL;
    }
}

StackNode *freeall(StackNode *phead)//清空，算法思想：先把p1后面的结点删除，最后把p1删除
{
    if (phead == NULL)
    {
        return NULL;
    }
    else
    {
        StackNode *p1 = NULL, *p2 = NULL;
        p1 = phead;//头结点
        
        while (p1->pNext != NULL)
        {
            p2 = p1->pNext;//保存下一个结点
            p1->pNext = p2->pNext;//跳过p2
            free(p2);
        }

        free(phead);

        return NULL;
    }
}

5 创建一个链队列，实现优先队列

链队列比一般队列的好处，没有范围限制。

头文件Queue.h

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

struct queue
{
    int num;
    int high;//优先级
    struct queue *pNext;//存储下一个结点的地址
};

typedef struct queue QUEUDE;//简化队列

QUEUDE *init(QUEUDE *queueA);//初始化
QUEUDE *EnQueue(QUEUDE *queueA, int num, int high);//顺序入队
QUEUDE *DeQuedu(QUEUDE *queueA, QUEUDE *pout);//顺序出队
QUEUDE *freeall(QUEUDE *queueA);//清空
QUEUDE *insertEnQuedu(QUEUDE *queueA, int num, int high);//队列插入，采用插入排序，不要用冒泡排序，原因：优先级相同，也可能会交换
void printall(QUEUDE *queueA);//打印所有数据，递归

源文件

源文件main.c

#define _CRT_SECURE_NO_WARNINGS

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

main()
{
    QUEUDE *phead = NULL;//创建头结点
    phead = init(phead);//初始化

    phead = insertEnQuedu(phead, 1, 3);
    printall(phead);//打印所有数据，递归
    printf("
");

    phead = insertEnQuedu(phead, 2, 12);
    printall(phead);//打印所有数据，递归
    printf("
");

    phead = insertEnQuedu(phead, 3, 3);
    printall(phead);//打印所有数据，递归
    printf("
");

    phead = insertEnQuedu(phead, 4, 14);
    printall(phead);//打印所有数据，递归
    printf("
");

    phead = insertEnQuedu(phead, 5, 5);
    printall(phead);//打印所有数据，递归
    printf("
");

    phead = insertEnQuedu(phead, 6, 16);
    printall(phead);//打印所有数据，递归
    printf("
");

    phead = insertEnQuedu(phead, 7, 0);
    printall(phead);//打印所有数据，递归
    printf("
");

    phead = insertEnQuedu(phead, 8, 0);
    printall(phead);//打印所有数据，递归
    printf("
");

    phead = insertEnQuedu(phead, 9, 1);
    printall(phead);//打印所有数据，递归
    printf("
");

    phead = insertEnQuedu(phead, 10, 0);
    printall(phead);//打印所有数据，递归
    printf("
");

    phead = insertEnQuedu(phead, 11, 16);
    printall(phead);//打印所有数据，递归
    printf("
");

    phead = insertEnQuedu(phead, 111, 19);
    printall(phead);//打印所有数据，递归
    printf("
");

    //while (phead != NULL)//出队
    //{
    //    QUEUDE *ptemp = (QUEUDE *)malloc(sizeof(QUEUDE));
    //    phead = DeQuedu(phead, ptemp);
    //    printf("出队一次
");
    //    printall(phead);//打印所有数据，递归
    //    printf("出队的是%d,%d
", ptemp->num, ptemp->high);
    //}
    
    system("pause");
}

源文件Queue.c

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

QUEUDE *init(QUEUDE *queueA)//初始化
{
    return NULL;
}

QUEUDE *EnQueue(QUEUDE *queueA, int num, int high)//顺序入队
{
    QUEUDE *pnewnode = (QUEUDE *)malloc(sizeof(QUEUDE));//分配内存
    pnewnode->num = num;
    pnewnode->high = high;
    pnewnode->pNext = NULL;

    if (queueA == NULL)//链表为空
    {
        queueA = pnewnode;
        return queueA;
    }
    else
    {
        QUEUDE *p = queueA;//头结点
        while (p->pNext != NULL)//确定要插入的位置
        {
            p = p->pNext;
        }
        p->pNext = pnewnode;//插入

        return queueA;
    }
}

QUEUDE *DeQuedu(QUEUDE *queueA, QUEUDE *pout)//顺序出队
{
    if (queueA == NULL)
    {
        return NULL;
    }
    else
    {
        pout->num = queueA->num;
        pout->high = queueA->high;
        QUEUDE *ptemp = queueA;//记录要删除的地址
        queueA = queueA->pNext;//跳过queueA
        free(ptemp);
        return queueA;
    }
}

QUEUDE *freeall(QUEUDE *queueA)//清空
{

}

QUEUDE *insertEnQuedu(QUEUDE *queueA, int num, int high)//队列插入，采用插入排序，不要用冒泡排序，原因：优先级相同，也可能会交换
{
    //实现从大到小插入
    QUEUDE *pnewnode = (QUEUDE *)malloc(sizeof(QUEUDE));//分配内存
    pnewnode->num = num;
    pnewnode->high = high;
    
    if (queueA == NULL)//原队列为空
    {
        pnewnode->pNext = NULL;
        queueA = pnewnode;
        return queueA;
    }
    else 
    {
        if (pnewnode->high > queueA->high)//头部插入1/3
        {
            pnewnode->pNext = queueA;
            queueA = pnewnode;//指向这个结点
            return queueA;
        }
        else
        {
            QUEUDE *p = queueA;//头结点
            while (p->pNext != NULL)
            {
                p = p->pNext;//p循环到尾部
            }
            if (pnewnode->high <= p->high)//尾部插入2/3
            {
                p->pNext = pnewnode;
                pnewnode->pNext = NULL;
                return queueA;
            }
            else//中间插入3/3
            {
                QUEUDE *p1, *p2;
                p1 = p2 = NULL;//避免野指针
                p1 = queueA;//头结点
                while (p1->pNext != NULL)
                {
                    p2 = p1->pNext;
                    if (p1->pNext >= pnewnode->high  && p2->high <= pnewnode->high)
                    {
                        pnewnode->pNext = p2;
                        p1->pNext = pnewnode;//插入
                        break;
                    }
                    p1 = p1->pNext;
                }
                return queueA;
            }
        }
    }
}

void printall(QUEUDE *queueA)//打印所有数据，递归
{
    if (queueA == NULL)
    {
        return;
    }
    else
    {
        printf("%d,%d,%x,%x
", queueA->num, queueA->high, queueA, queueA->pNext);
        printall(queueA->pNext);//进入下一个
    }
}