c/c++链队列

链队列

链队列就是简化了的单链表

nodequeue.h

#ifndef __NODEQUEUE__
#define __NODEQUEUE__

#include <stdio.h>
#include <malloc.h>
#include <assert.h>
#include <memory.h>
#include <stdbool.h>

#define ElemType int

typedef struct Node{
  ElemType data;
  struct Node* next;
}Node;

typedef struct NodeQueue{
  Node*  front;
  Node*  tail;
  size_t size;
}NodeQueue;

void init(NodeQueue*);
void enQueue(NodeQueue*, ElemType);
void deQueue(NodeQueue*);
void show_list(NodeQueue*);
int length(NodeQueue*);
void clear(NodeQueue*);
void destroy(NodeQueue*);

#endif

nodequeue.c

#include "nodequeue.h"

void init(NodeQueue* queue){
  queue->front = queue->tail = (Node*)malloc(sizeof(Node));
  queue->tail->next = NULL;
  queue->size = 0;
}
//入队(尾插)
void enQueue(NodeQueue* queue, ElemType val){
  Node* p = (Node*)malloc(sizeof(Node));
  p->data = val;
  if(queue->front->next == NULL){
    queue->front->next = p;
  }
  else{
    queue->tail->next = p;
  }
  queue->tail = p;
  p->next = NULL;
  queue->size++;
}
//出队(头删)
void deQueue(NodeQueue* queue){
  if(queue->size == 0)return;
  Node* tmp = queue->front->next;
  queue->front->next = queue->front->next->next;
  free(tmp);
  queue->size--;
}
int length(NodeQueue* queue){
  return queue->size;
}
void show_list(NodeQueue* queue){
  Node* p = queue->front;
  while(p->next != NULL){
    printf("%d\n", p->next->data);
    p = p->next;
  }
}
void clear(NodeQueue* queue){
  if(queue->size == 0)return;
  Node* p = queue->front;
  Node* tmp;
  while(p->next != NULL){
    tmp = p->next;
    p = p->next;
    free(tmp);
  }
  queue->tail = queue->front;
  queue->tail->next = NULL;
  queue->size = 0;
}
void destroy(NodeQueue* queue){
  clear(queue);
  free(queue->front);
}

nodequeuemain.c

include "nodequeue.h"

int main(){
  NodeQueue list;
  init(&list);
  int select = 1;
  ElemType item;
  int index;
  while(select){
    printf("*****************************************\n");
    printf("*** [1]   push        [2]  pop        ***\n");
    printf("*** [3]   show_list   [4]  length     ***\n");
    printf("*** [5]   clear       [6]  destroy    ***\n");
    printf("*** [0]   quit                        ***\n");
    printf("*****************************************\n");
    printf("请选择:>");
    scanf("%d", &select);
    if(0 == select)
      break;
    switch(select){
    case 1:
      printf("请输入要插入的数据>\n");
      scanf("%d",&item);
      enQueue(&list, item);
      show_list(&list);
      break;
    case 2:
     deQueue(&list);
      show_list(&list);
      break;
    case 3:
      show_list(&list);
      break;
    case 4:
      printf("length is %d\n", length(&list));
      break;
    case 5:
      clear(&list);
      show_list(&list);
      break;
    case 6:
      destroy(&list);
      break;
    default:
      printf("输入的选择错误,请重新选择\n");
      break;
    }
  }
  destroy(&list);
}

原文地址:https://www.cnblogs.com/xiaoshiwang/p/9246493.html

时间: 2024-11-08 22:38:43

c/c++链队列的相关文章

链队列代码及应用

链队列代码 #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <time.h> #define OK 1 #define ERROR 0 #define OVERFLOW -2 #define TRUE 1 #define FALSE 0 typedef int Status; typedef int ElemType; typedef struct Qnode{ int

链栈和链队列的类实现

#include<iostream>#include<cassert> using namespace std; template <class T>//链栈 struct LinkNode{T data;LinkNode<T> *Link;LinkNode(LinkNode<T> *pr=NULL){Link=pr;}LinkNode(const T& item,LinkNode<T> *pr=NULL){data=item

09.循环队列与链队列

一.队列与循环队列 1.队列 (1)队列(queue)是只允许在一端进行插入操作,而在另一端进行删除操作的线性表.队列是一种先进先出(Fiirst In First Out)的线性表,简称FIFO.允许插入的一端称为队尾,允许删除的一端称为队头. 从队列的定义可知,队列的入队操作,其实就是在队尾追加一个元素,不需要移动任何元素,因此时间复杂度为O(1).队列的删除操作,与栈不同的是,队列元素的出列是在队头,即小标为0的位置,若要删除一个元素的话,需要移动队列的所有元素,因此事件复杂度为O(n).

链队列-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; } 头文件部分: type

数据结构(C实现)------- 链队列

链队列,即队列的链式存储结构,它是仅在表头删除和表尾插入的单链表,因此一个链队列需要设置两个分别指示队头元素和队尾元素的指针,为了操作方便,给链队列添加一个头结点,并令队头指针指向头结点,由此,空的链队列的判断条件就是队头指针和队尾指针均指向头结点. 链队列的类型描述: //链队列类型描述 typedef int QElemType; typedef struct node{ QElemType data; struct node *next; }QNode,*QueuePtr; typedef

数据结构(二):链表、链队列

上一篇博文中主要总结线性表的顺序存储结构实现.比方顺序表.顺序队列和顺序栈.详细能够參考上篇博文 http://blog.csdn.net/lg1259156776/article/details/46993591 以下要进行学习和总结的是线性表的链式存储结构实现,比方链表和链队列. 顺序存储结构的优缺点 长处是逻辑相邻,物理相邻,可随机存取任一元素,存储空间使用紧凑:缺点是插入.删除操作须要移动大量的元素.平均移动n/2,预先分配空间需依照最大空间分配.利用不充分(C++ STL模板库中实现的

【算法设计-链栈和链队列】链栈和链队列的实现

1.链队列.利用带有头结点的单链表来实现链队列,插入和删除的复杂度都为o(1) 代码: #include<stdio.h> #include<stdlib.h> typedef struct Qnode { int data; Qnode *next; }Qnode; typedef struct LinkQueue { Qnode *front; Qnode *rear; }LinkQueue; void initialize(LinkQueue *LinkQueue) { Li

链队列的C++实现

#include<iostream> using namespace std; //节点类 template<class T> struct QNode { T data; QNode *next; }; //队列类 template<class T> struct LinkList { QNode<T> * front; QNode<T> * rear; size_t size; }; //构造一个空队列 template<class T

链队列的初始化、入队、出队等操作实现

链队列的初始化.入队.出队等基本操作实现代码如下: #include<iostream> using namespace std; #define  TRUE 1 #define  FALSE 0 //链队列定义 typedef struct Node { int data;//数据域 struct Node *next;//指针域 }LinkQueueNode; typedef struct { LinkQueueNode *front;//队头指针front LinkQueueNode *

java实现链队列

java实现链队列的类代码: package linkqueue; public class LinkQueue { class Element { Object elem; Element next; } private Element front; private Element rear; private Element header = null; /** * 初始化队列 * */ void initQueue() { header = new Element(); front = ne