有序链式队列





  1. 编写头文件

struct
queue

{

int
num;           
//代表数据

int
high;          
//优先级1111

struct
queue *pNext;//存储下一个节点的地址

};

typedef 
struct
queue
Queue;                          
//简化队列

Queue
* init(Queue
*queueHead);                       
//初始化

Queue
* EnQueue(Queue
*queueHead,
int
num,
int
high); 
//入队

Queue
* DeQueue(Queue
*queueHead,
Queue *pOut);       
//出队

Queue
* freeall(Queue
*queueHead);                  
//清空

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

void
printfall(Queue
*queueHead);                     
//打印所有数据，递归

Queue *
insertEnQueue(Queue
*queueHead,
int
num,
int
high);

  1. 编写实现队列的代码

#include
"Queue.h"

#include
<stdio.h>

#include
<stdlib.h>

//初始化

Queue
* init(Queue
*queueHead)

{

return
NULL;

}

//入队

Queue
* EnQueue(Queue
*queueHead,
int
num,
int
high)

{

//分配内存

Queue *pnewnode
= (Queue *)malloc(sizeof(Queue));

pnewnode->num
= num;

pnewnode->high
= high;

pnewnode->pNext
= NULL;

if (queueHead
== NULL)

{

queueHead =
pnewnode;

}

else

{

Queue *p
= queueHead;

while (p->pNext
!= NULL)

{

p =
p->pNext;

}

//确定要插入的位置

//插入,这里是尾部插入

p->pNext
= pnewnode;

}

return
queueHead;

}

//出队

Queue
* DeQueue(Queue
*queueHead,
Queue *pOut)

{

if (queueHead
== NULL)

{

return
NULL;

}

else

{

//这里相当于是

pOut->num
= queueHead->num;

pOut->high
= pOut->high;

Queue *pTemp
= queueHead;

//记录要删除的地址

queueHead =
queueHead->pNext;

//释放节点

free(pTemp);

return
queueHead;

}

}

////优先级排队

//void sort(Queue *queueHead)

//{

// 
if (queueHead == NULL || queueHead->pNext == NULL)

// 
{

//     
return;

// 
}

// 
else

// 
{

//     
for (Queue *p1 = queueHead; p1 != NULL;p1 = p1->pNext)

// 
    {

//         
for (Queue *p2 = queueHead; p2 != NULL;p2 = p2->pNext)

//         
{

//             
if (p1->high > p2->high)

//             
{

//                 
Queue temp;

//                 
temp.num = p1->num;

//                 
p1->num = p2->num;

//                 
p2->num = temp.num;

//

//                 
temp.high = p1->high;

//                 
p1->high = p2->high;

//                 
//交换节点数据

//                 
p2->high = temp.high;

//             
}

//         
}

// 
    }

// 
}

//}

//打印所有数据，递归

void
printfall(Queue
*queueHead)

{

if (queueHead
== NULL)

{

return;

}

else

{

printf("%d,%d,%p,%p\n",
queueHead->num,
queueHead->high,
queueHead,
queueHead->pNext);

printfall(queueHead->pNext);

}

}

Queue
* insertEnQueue(Queue
*queueHead,
int
num,
int
high)

{

//分配内存

Queue 
*pnewnode = (Queue
*)malloc(sizeof(Queue));

pnewnode->num
= num;

pnewnode->high
= high;

//节点为空

if (queueHead
== NULL)

{

pnewnode->pNext
= NULL;

queueHead =
pnewnode;

return
queueHead;

}

else

{

//头插

if (pnewnode->high
> queueHead->high)

{

//头部插入

pnewnode->pNext
= queueHead;

//指向这个节点

queueHead =
pnewnode;

return
queueHead;

}

else

{

//头节点

Queue *p
= queueHead;

while (p->pNext
!= NULL)

{

p =
p->pNext;

}

//循环到尾部

if (pnewnode->high
<= p->high)

{

p->pNext
= pnewnode;

pnewnode->pNext
= NULL;

return
queueHead;

}

else

{

Queue *p1,
*p2;

p1 =
p2 =
NULL; 
//避免野指针

p1 =
queueHead; 
//头结点

while (p1->pNext
!= NULL)

{

p2 =
p1->pNext;

if (p1->high
>= pnewnode->high
&& p2->high<pnewnode->high)

{

pnewnode->pNext
= p2;

p1->pNext
= pnewnode;//插入

break;

}

p1 =
p1->pNext;

}

return
queueHead;

}

}

}

}

3.编写主函数

#include
"Queue.h"

#include
<stdio.h>

#include
<stdlib.h>

int
main(int
argc,char
*argv[])

{

//创建头结点

Queue *phead
= NULL;

//初始化

phead =
init(phead);

phead =
insertEnQueue(phead,
1, 1);

printfall(phead);

phead =
insertEnQueue(phead,
2, 12);

printfall(phead);

phead =
insertEnQueue(phead,
3, 3);

printfall(phead);

phead =
insertEnQueue(phead,
4, 14);

printfall(phead);

phead =
insertEnQueue(phead,
5, 5);

printfall(phead);

phead =
insertEnQueue(phead,
6, 16);

printfall(phead);

phead =
insertEnQueue(phead,
6, 0);

printfall(phead);

phead =
insertEnQueue(phead,
7, 0);

printfall(phead);

phead =
insertEnQueue(phead,
8, 0);

printfall(phead);

phead =
insertEnQueue(phead,
9, 1);

printfall(phead);

phead =
insertEnQueue(phead,
10, 0);

printfall(phead);

phead =
insertEnQueue(phead,
11, 16);

printfall(phead);

phead =
insertEnQueue(phead,
111, 19);

printfall(phead);

printf("打印排序后的链式队列:\n");

printfall(phead);

getchar();

return 0;

}

有序链式队列,布布扣,bubuko.com

时间： 2024-11-29 06:05:50

有序链式队列的相关文章

数据结构Java实现07----队列：顺序队列&amp;顺序循环队列、链式队列、顺序优先队列

数据结构Java实现07----队列:顺序队列&顺序循环队列.链式队列.顺序优先队列 一.队列的概念: 队列(简称作队,Queue)也是一种特殊的线性表,队列的数据元素以及数据元素间的逻辑关系和线性表完全相同,其差别是线性表允许在任意位置插入和删除,而队列只允许在其一端进行插入操作在其另一端进行删除操作. 队列中允许进行插入操作的一端称为队尾,允许进行删除操作的一端称为队头.队列的插入操作通常称作入队列,队列的删除操作通常称作出队列. 下图是一个依次向队列中插入数据元素a0,a1,...,an-

数据结构之---C语言实现链式队列

//链式队列的存储 //杨鑫 #include <stdio.h> #include <stdlib.h> typedef int QElemType; //定义节点 typedef struct QNode { QElemType data; struct QNode *next; }QNode, *QueuePtr; //定义指针 typedef struct { QueuePtr front; QueuePtr rear; }LinkQueue; //插入元素e进入队列 vo

【数据结构-队列】链式队列

关于链式队列 链式队列又称为链队,是使用单链表实现的,需要一个头指针一个尾指针 结构图: 链队需要的元素组成 /*链式队列的每一个节点*/ struct node{ int data;//存储数据 struct node *next;//指向下一个节点的指针 }; /*链式队列*/ typedef struct{ struct node *head;//头指针 struct node *tail;//尾指针 }LinkedQueue; 创建一个带头节点的空队列 创建一个节点p 将p节点的next

C++链式队列

LinkQueue: //链式队列 #include<iostream> using namespace std; typedef int elemType; struct QNode { elemType data; QNode *next; }; struct LinkQueue { QNode *front; QNode *rear; }; //初始化 void InitQueue(LinkQueue *q) { q->front = q->rear = new QNode;

数据结构基础(14) --链式队列的设计与实现

链式队列是基于单链表的一种存储表示, 其形状如下图所示: (队列的队头指针指向单链表的第一个结点, 队尾指针指向单链表的最后一个结点, 注意没有无用的空[头/尾]节点) 用单链表表示的链式队列特别适合于数据元素变动比较大的情况, 而且不存在队列满而产生溢出的情况; 链式队列结点构造: [这次我们将节点构造成了类LinkQueue的嵌套类] struct ChainNode { ChainNode(const Type &_data, ChainNode *_next = NULL) :data(

链式队列的实现

链式队列数据结构如下: typedef struct qnode{ ElemType data; struct qnode* next; //指向下一节点指针 }QNode; typedef struct{ QNode* front; //队首指针 QNode* rear; //队尾指针 }ListQueue; 实现以下函数: void InitQueue(ListQueue* &q); //初始化队列 void ClearQueue(ListQueue* &q); //清空队列 int

不带头结点的链式队列进出队操作

/* 不带头结点的链式队列进出队操作 */ #include <stdio.h> #include <stdlib.h> #define ElementType int typedef struct QNode *Queue; typedef struct Node{ ElementType Data; struct Node *Next; }; typedef struct QNode{ struct Node *front; struct Node *rear; }; void

顺序队列和链式队列的实现

队列是一种常用的数据结构,它跟栈一样,操作都受到限制,队列只允许从一端进数据,另一端出数据.队列跟栈不同,栈是一种"后进先出"的模式,而队列是一种"先进先出"的操作模式.就好比日常排队一样,先排队的先出,后排队的后出.例如,进入队列的顺序是1,2,3,4,5则出队列的顺序是1,2,3,4,5(只考虑一次性出列的情况). 队列也分顺序队列和链式队列,跟顺序栈和链表栈一样,顺序队列同样是基于数组实现,链式队列则是基于链表实现. 顺序队列: //顺序队列 #include

链式队列总结

基本数据结构之-链式队列 链式队列就是一个操作受到限制的单链表,学会了单链表再来写这个就是轻松加愉快,但是貌似我去用了两个小时搞定,主要是基础差! 队列的基本操作就是入栈和出栈,还可以看到对头和对尾 如果维护了长度参数,那么也可以返回一个长度 不说理论了,直接上代码吧! 首先定义基本数据结构的结构体: typedef struct _LINKQUEUENODE { struct _LINKQUEUENODE *next; }LinkQueueNode; typedef struct _LINKQ