C语言版实现链队列

本文实例为大家分享了C语言实现链队列的具体代码,供大家参考,具体内容如下

源文件部分:  指针没学好的同学很难看懂^_^,有点乱,希望对大家有点帮助。

#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
#include<string.h>
typedef int Elemtype;
#include"LQueue.h"
int main()
{
 Deque head;
 instruction(head);
 return 0;
}
头文件部分:
typedef struct Queue
{
 Elemtype data;
 struct Queue *next;
}LQnode,*LQueue;

typedef struct
{
 LQnode *front;
 LQnode *rear;
}Deque;

void Init_queue(Deque *head)  //初始化+清空操作==其实这里的清空是指将头节点后的节点给丢弃掉
{
 LQnode *p=NULL;
 p=(LQueue)malloc(sizeof(LQnode));
 head->front=p;
 head->rear=p;
 p->next=NULL;
}

int Empty_queue(Deque *head)      //判空
{
 if(head->front->next==head->rear->next)
 return 1;
 return 0;
}

int Lenght_queue(Deque arrow)
{
 LQnode *p=NULL;
 int len=0;
 p=arrow.front->next;
 while(p)
 {
 len++;
 p=p->next;
 }
 return len;
}

void Enqueue(Deque *arrow,Elemtype e)    //入队操作
{
 LQueue p=NULL;
 p=(LQueue)malloc(sizeof(LQnode));
 if(!p)
 {
 printf("已无更多的内存单元得到分配!\n");
 return ;
 }
 p->data=e;
 p->next=NULL;         //插入时,队首指针是不需要动的
 arrow->rear->next=p;
 arrow->rear=p;
 return ;
}

void Dequeue(Deque *arrow,Elemtype *e)    //出队操作
{
 LQnode *p=NULL;
 if(Empty_queue(arrow))
 {
 printf("当前链队列为空,无法完成出队操作!!!\n");
 return ;
 }
 p=arrow->front->next;
 (*e)=p->data;
 arrow->front->next=p->next;
 printf("元素%d已退出队列!!!\n",*e);
 if(Lenght_queue(*arrow)==0)
 return ;            //当最后一个元素出列以后,arrow->rear不知道指向了哪里
 free(p);
 return ;
}

int Queue_top(Deque *arrow)  //返回队首元素
{
 if(Empty_queue(arrow))
 {
 printf("当前链队列为空,队首元素不存在!!!\n");
 return 0;
 }
 printf("当前队首元素是:%d\n",arrow->front->next->data);
}

void Destroy_queue(Deque *arrow)  //链队列的销毁
{
 LQnode *p=NULL;
 if(Empty_queue(arrow))
 {
 printf("当前链队列为空,无须完成销毁操作!!!\n");
 return ;
 }
 while(arrow->front->next)
 {
 p=arrow->front->next;
 arrow->front->next=p->next;
 if(Lenght_queue(*arrow)==0)
  break;
 free(p);
 }
 printf("销毁成功!\n");
 return ;
}

void Print_queue(Deque arrow)
{
 LQnode *p=NULL;
 p=arrow.front->next;
 while(p)
 {
 printf("%d ",p->data);
 p=p->next;
 }
 printf("\n");
}

void Modify_queue(Deque *arrow,Elemtype index,Elemtype e)  //修改函数
{
 int i=0;
 LQnode *p=NULL;
 p=arrow->front->next;
 while(i<index-1)
 {
 p=p->next;
 }
 p->data=e;
 printf("已完成修改操作!\n");
}

int Insearch_queue(Deque arrow,Elemtype e)      //查找函数
{
 LQnode *p=NULL;
 int i=1;
 if(Empty_queue(&arrow))
 {
 printf("当前链队列为空,没有元素可查找!!!\n");
 return 0;
 }
 p=arrow.front->next;
 while(p!=NULL)
 {
 if(e==p->data)
 {
  return i;
  break;
 }
 i++;
 p=p->next;
 }
 if(p==NULL)
 printf("查找失败,队列内无该元素存在!\n");
 return 0;
}

void instruction(Deque head)
{
 int n,m,t,a,b,len1,index;
 printf("\t\t1、队列初始化 \n");
 printf("\t\t2、新增队列元素\n");
 printf("\t\t3、返回队首元素\n");
 printf("\t\t4、元素出队列 \n");
 printf("\t\t5、查找队列元素\n");
 printf("\t\t6、修改队列元素\n");
 printf("\t\t7、销毁队列  \n");
 printf("\t\t8、队列的长度 \n");
 printf("\t\t9、打印队列元素\n");
 printf("\t\t10、退出程序  \n");
 printf("请输入你所需要完成的指令:\n");
 do{
 scanf("%d",&n);
 if(n<1||n>10)
  printf("对不起,你输入的指令编号是无效的,请重新输入!!!\n");
 }while(n<1||n>10);
 switch(n)
 {
 case 1:
  Init_queue(&head);
  printf("已完成链队列初始化,请输入你要添加的元素个数!\n");
  scanf("%d",&n);
  while(n--)
  {
  int x;
  scanf("%d",&x);
  Enqueue(&head,x);
  }
  printf("完成建队操作!\n");
  break;
 case 2:
  printf("请输入你要添加的元素个数!\n");
  scanf("%d",&n);
  while(n--)
  {
  int x;
  scanf("%d",&x);
  Enqueue(&head,x);
  }
  printf("增添成功!\n");
  break;
 case 3:
  Queue_top(&head);
  break;
 case 4:
  Dequeue(&head,&t);
  break;
 case 5:
  printf("请输入你所要查找的元素:\n");
  scanf("%d",&m);
  index=Insearch_queue(head,m);
  if(index)
  printf("你所要查找的元素位于队列的第%d个位置上!!!\n",index);
  break;
 case 6:
  printf("请输入你更改的元素队列位置:\n");
  do{
  scanf("%d",&a);
  if(a<1||a>Lenght_queue(head))
   printf("对不起,你所输入的元素位置不在区域内,请重新输入!!!\n");
  }while(a<1||a>Lenght_queue(head));
  printf("请输入修改后的值:\n");
  scanf("%d",&b);
  Modify_queue(&head,a,b);
  break;
 case 7:
  Destroy_queue(&head);
  break;
 case 8:
  len1=Lenght_queue(head);
  printf("当前链队列的长度为:%d\n",len1);
  break;
 case 9:
  Print_queue(head);
  break;
 case 10:
  return;
 default:
  instruction(head);
  break;
 }
 instruction(head);
}

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持我们。

(0)

相关推荐

  • C语言数据结构链表队列的实现

    C语言数据结构链表队列的实现 1.写在前面 队列是一种和栈相反的,遵循先进先出原则的线性表. 本代码是严蔚敏教授的数据结构书上面的伪代码的C语言实现代码. 分解代码没有包含在内的代码如下: #include <stdio.h> #include <stdlib.h> #define OK 1 #define ERROR 0 typedef int QElemtype; typedef int status; 2.代码分解 2.1对队列和节点的结构定义 typedef struct

  • C语言实现链队列代码

    本文实例为大家分享了C语言实现链队列的具体代码,供大家参考,具体内容如下 #include <stdio.h> /* 队列的结构体 */ typedef int DataType; #define NODE_LEN sizeof(NODE) /* 队列的节点 */ typedef struct stNode { DataType data; struct stNode* next; }NODE; /* 队列 */ typedef struct stQueue { NODE* head; //队

  • C语言实现链队列

    记录一下C语言实现的链队列代码,供大家参考,具体内容如下 #include<stdio.h> #include<stdlib.h> #include<stdbool.h> typedef int ElemType; //链队列的结点定义 typedef struct node{ ElemType val; struct node* next; }QueueNode; //链队列的定义,包含队头指针和队尾指针 typedef struct queue { QueueNod

  • C语言单链队列的表示与实现实例详解

    1.概述: C语言的队列(queue),是指先进先出(FIFO, First-In-First-Out)的线性表.在具体应用中通常用链表或者数组来实现.队列只允许在后端(称为rear)进行插入操作,在前端(称为front)进行删除操作. 而单链队列使用链表作为基本数据结果,因此不存在伪溢出的问题,队列长度也没有限制.但插入和读取的时间代价会比较高 2.实例代码: /* 单链队列--队列的链式存储结构 */ typedef struct QNode { QElemType data; struct

  • C语言版实现链队列

    本文实例为大家分享了C语言实现链队列的具体代码,供大家参考,具体内容如下 源文件部分:  指针没学好的同学很难看懂^_^,有点乱,希望对大家有点帮助. #include<stdio.h> #include<malloc.h> #include<stdlib.h> #include<string.h> typedef int Elemtype; #include"LQueue.h" int main() { Deque head; inst

  • 深入浅析C语言中堆栈和队列

    1.堆和栈 (1)数据结构的堆和栈 堆栈是两种数据结构. 栈(栈像装数据的桶或箱子):是一种具有后进先出性质的数据结构,也就是说后存放的先取,先存放的后取.这就如同要取出放在箱子里面底下的东西(放入的比较早的物体),首先要移开压在它上面的物体(放入的比较晚的物体). 堆(堆像一棵倒过来的树):是一种经过排序的树形数据结构,每个结点都有一个值.通常所说的堆的数据结构,是指二叉堆.堆的特点是根结点的值最小(或最大),且根结点的两个子树也是一个堆.由于堆的这个特性,常用来实现优先队列,堆的存取是随意,

  • C语言用栈和队列实现的回文检测功能示例

    本文实例讲述了C语言用栈和队列实现的回文功能.分享给大家供大家参考,具体如下: #include<stdio.h> #include<malloc.h>//内存分配头文件 #include<math.h>//在math.h中已定义OVERFLOW的值为3 #define SIZE 100 #define STACKINCREMENT 10 #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 typede

  • 学生信息管理系统C语言版

    C语言学生信息管理系统包括以下功能: 1.学生信息的整体注册 2.学生信息的修改 3.学生成绩信息的录入 4.学生信息的添加 5.恢复误删的学生信息 6.学生信息的删除 7.密码修改保存函数 8.学生信息的查询 9.密码修改函数 10.学生信息管理系统的菜单函数 #include "stdio.h" #include "malloc.h" #include "string.h" #include "stdlib.h" #inc

  • C利用语言实现数据结构之队列

    目录 一.链队列 二.链队的表示 三.链队的基本操作 1. 链队的初始化 2. 链队的销毁 3. 入队 4. 出队 四.顺序队列 五.循环队列 1. 初始化 2. 求队列长度 3. 入队 4. 出队 前言: 队列在生活中也比较常见,例如购物排队--新来的成员总是加入队尾,每次离开的成员总是队列头上的. 队列按存储方式可以分为两种:顺序队列和链队列. 一.链队列 链式队列中每个元素定义成一个结点,含数据域与指针域(指向下一结点),并设头尾指针.用图表示就是. 二.链队的表示 前面的链式结构,总是使

  • C语言超详细讲解队列的实现及代码

    目录 前言 队列的概念 队列的结构 队列的应用场景 队列的实现 创建队列结构 队列初始化 队列销毁 入队列 出队列 队列判空 获取队列元素个数 获取队列头部元素 获取队列尾部元素 总代码 Queue.h 文件 Queue.c 文件 Test.c 文件 前言 队列的概念 队列:只允许在一端进行插入数据操作,在另一端进行删除数据操作的特殊线性表,队列具有先进先出FIFO(First In First Out) 入队列:进行插入操作的一端称为队尾 出队列:进行删除操作的一端称为队头 队列和前文所学的栈

  • C语言详解链式队列与循环队列的实现

    目录 队列的实现 链式队列 链式队列的定义 链式队列的实现 循环队列 循环队列的定义 循环队列的实现 队列的实现 队列是一种先进先出(First in First Out)的线性表,简称FIFO.与栈不同,栈是一种后进先出(先进后出)的线性表.在队列中,允许插入的一端称为队尾,允许删除的一端称为队头.假设队列是q=(a1,a2,…,an),那么a1就是队头元素,而an是队尾元素.这样我们就可以删除时,总是从a1开始,而插入时,列在最后.这也比较符合我们通常生活中的习惯,排在第一个的优先出列,最后

  • C语言实现二叉树链式结构的示例详解

    目录 前言 1. 链式二叉树结构 2. 二叉树的遍历 2.1 前序遍历 2.2 中序遍历 2.3 后序遍历 2.4 层序遍历 3. 常见功能 3.1 二叉树结点个数 3.2 二叉树叶子结点个数 3.3 第K层结点的个数 3.4 二叉树的深度 3.5 判断是不是树是不是完全二叉树 3.6 在二叉树中查找值为x的结点 3.7 拿到每一层的数据 4. 二叉树的创建和销毁 4.1 二叉树的创建 4.2 二叉树的销毁 前言 前面我们已经对堆进行学习,堆就是一个顺序结构的二叉树,把数组看成二叉树,下面一起学

随机推荐