栈 LIFO
- 顺序存储
- - 初始化
  - 入栈
  - 出栈
  - 整体代码
- 链式存储
- - 入栈
  - 出栈
  - 整体代码
队列 FIFO
- 顺序结构 -- 循环队列（解决假溢出）
- - 初始化
  - 入队
  - 出队
  - 整体代码
- 链式存储
- - 初始化
  - 入队
  - 出队
  - 整体代码
传送门

栈 LIFO

顺序存储

typedef int elemtype;
typedef struct stack{elemtype *base,*top;
}stack;

初始化

void init_stack(stack& sqstack){sqstack.base = new elemtype[maxsize];if(!sqstack.base) exit(OVERFLOW);sqstack.top=sqstack.base;
}

入栈

void push(stack& sqstack,elemtype e){if(sqstack.top-sqstack.base == maxsize) return ;*sqstack.top = e;sqstack.top++;
}

出栈

void pop(stack& sqstack,elemtype *e){if(sqstack.top == sqstack.base) return;*e = *(--sqstack.top);
}

整体代码

#include<iostream>
using namespace std;
#include<stdlib.h>
#include<math.h>#define maxsize 20
typedef int elemtype;
typedef struct stack{elemtype *base,*top;
}stack;void init_stack(stack& sqstack);
void push(stack& sqstack,elemtype e);
void pop(stack& sqstack,elemtype *e);
int main(){stack sqstack;init_stack(sqstack);push(sqstack,56);push(sqstack,32);elemtype e;pop(sqstack,&e);cout<<e<<endl;pop(sqstack,&e);cout<<e<<endl;;return 0;
}
void init_stack(stack& sqstack){sqstack.base = new elemtype[maxsize];if(!sqstack.base) exit(OVERFLOW);sqstack.top=sqstack.base;
}
void push(stack& sqstack,elemtype e){if(sqstack.top-sqstack.base == maxsize) return ;*sqstack.top = e;sqstack.top++;
}
void pop(stack& sqstack,elemtype *e){if(sqstack.top == sqstack.base) return;*e = *(--sqstack.top);
}

链式存储

typedef int elemtype;
typedef struct node{elemtype data;struct node *next;
}node,*link_node;typedef struct Stack{link_node top;int length;
}Stack;

入栈

void push(Stack &stack,elemtype e){ // 头插 - 逆序link_node p = new node;p->data = e;p->next = stack.top;stack.top = p;stack.length ++;
}

出栈

void pop(Stack &stack,elemtype *e){if(stack.top == NULL) return;link_node p=stack.top;stack.top = p->next;*e = p->data;delete p;stack.length--;
}

整体代码

#include<iostream>
using namespace std;typedef int elemtype;
typedef struct node{elemtype data;struct node *next;
}node,*link_node;typedef struct Stack{link_node top;int length;
}Stack;void push(Stack &stack,elemtype e);
void pop(Stack &stack,elemtype *e);
int main(){Stack stack;stack.top = NULL;stack.length = 0;push(stack,12);push(stack,10);elemtype e;pop(stack,&e);cout<<e<<endl;pop(stack,&e);cout<<e<<endl;return 0;
}
void push(Stack &stack,elemtype e){ // 头插 - 逆序link_node p = new node;p->data = e;p->next = stack.top;stack.top = p;stack.length ++;
}
void pop(Stack &stack,elemtype *e){if(stack.top == NULL) return;link_node p=stack.top;stack.top = p->next;*e = p->data;delete p;stack.length--;
}

队列 FIFO

顺序结构 – 循环队列（解决假溢出）

typedef int elemtype;
typedef struct queue{elemtype data[maxsize];int head,tail;int length;
} Squeue;

初始化

void init_queue(Squeue &queue){queue.head=queue.tail=0;queue.length = 0;
}

入队

void en_queue(Squeue &queue,elemtype e){if(queue.length == maxsize) return;queue.data[queue.tail] = e;queue.tail = (queue.tail+1)%maxsize; // 注意点queue.length=(queue.tail-queue.head+maxsize)%maxsize;
}

出队

void de_queue(Squeue &queue,elemtype *e){if(queue.length == 0) return ;*e = queue.data[queue.head];queue.head = (queue.head+1)%maxsize;// 注意点queue.length=(queue.tail-queue.head+maxsize)%maxsize;
}

整体代码

#include<iostream>
using namespace std;#define maxsize 4
typedef int elemtype;
typedef struct queue{elemtype data[maxsize];int head,tail;int length;
} Squeue;void init_queue(Squeue &queue);
void en_queue(Squeue &queue,elemtype e);
void de_queue(Squeue &queue,elemtype *e);int main(){Squeue queue;init_queue(queue);en_queue(queue,10);en_queue(queue,11);en_queue(queue,12);elemtype e;de_queue(queue,&e);cout<<e<<endl;de_queue(queue,&e);cout<<e<<endl;en_queue(queue,13);en_queue(queue,14);de_queue(queue,&e);cout<<e<<endl;de_queue(queue,&e);cout<<e<<endl;de_queue(queue,&e);cout<<e<<endl;return 0;
}
void init_queue(Squeue &queue){queue.head=queue.tail=0;queue.length = 0;
}
void en_queue(Squeue &queue,elemtype e){if(queue.length == maxsize) return;queue.data[queue.tail] = e;queue.tail = (queue.tail+1)%maxsize; // 注意点queue.length=(queue.tail-queue.head+maxsize)%maxsize;
}
void de_queue(Squeue &queue,elemtype *e){if(queue.length == 0) return ;*e = queue.data[queue.head];queue.head = (queue.head+1)%maxsize;// 注意点queue.length=(queue.tail-queue.head+maxsize)%maxsize;
}

链式存储

typedef int elemtype;
typedef struct node{elemtype data;struct node *next;
}node,*link_node;
typedef struct queue{node head;link_node tail;
}Queue;

初始化

void init_queue(Queue &queue){queue.head.data=0;queue.head.next = NULL;queue.tail=    &queue.head;
}

入队

void en_queue(Queue &queue,elemtype e){link_node p;p = new node;if(!p) exit(OVERFLOW);p->data = e;p->next = NULL;queue.tail->next= p;queue.tail = p;queue.head.data++;
}

出队

void de_queue(Queue &queue,elemtype *e){if(queue.head.data == 0) return ;link_node p=queue.head.next;*e=p->data;queue.head.next = p->next;delete p;queue.head.data--;if(queue.head.data == 0) queue.tail = &queue.head ; // 注意点
}

整体代码

#include<iostream>
using namespace std;
#include<math.h>
#include<stdlib.h>typedef int elemtype;
typedef struct node{elemtype data;struct node *next;
}node,*link_node;
typedef struct queue{node head;link_node tail;
}Queue;void init_queue(Queue &queue);
void en_queue(Queue &queue,elemtype e);
void de_queue(Queue &queue,elemtype *e);
int main(){Queue queue;init_queue(queue);en_queue(queue,10);en_queue(queue,11);en_queue(queue,12);elemtype e;de_queue(queue,&e);cout<<e<<'d'<<queue.head.data<<endl;de_queue(queue,&e);cout<<e<<'d'<<queue.head.data<<endl;de_queue(queue,&e);cout<<e<<'d'<<queue.head.data<<endl;en_queue(queue,13);de_queue(queue,&e);cout<<e<<'d'<<queue.head.data<<endl;return 0;
}void init_queue(Queue &queue){queue.head.data=0;queue.head.next = NULL;queue.tail=  &queue.head;
}
void en_queue(Queue &queue,elemtype e){link_node p;p = new node;if(!p) exit(OVERFLOW);p->data = e;p->next = NULL;queue.tail->next= p;queue.tail = p;queue.head.data++;
}
void de_queue(Queue &queue,elemtype *e){if(queue.head.data == 0) return ;link_node p=queue.head.next;*e=p->data;queue.head.next = p->next;delete p;queue.head.data--;if(queue.head.data == 0) queue.tail = &queue.head ; // 注意点
}

传送门

if (!S.base)exit(OVERFLOW)是什么意思
深入掌握栈的三种类型初始化

学习笔记-数据结构与算法之栈与队列相关推荐

数据结构与算法--利用栈实现队列
利用栈实现队列上一节中说明了栈的特点后进先出,我们用数组的方式实现了栈的基本操作api,因此我们对栈的操作是不考虑排序的,每个api的操作基本都是O(1)的世界,因为不考虑顺序,所以找最大,最小值 ...
学习笔记 | 数据结构和算法知识点思维导图
程序 = 数据结构 + 算法一数据结构知识点 01 队列和栈,需要了解它们的特点. 队列是先进先出,栈是后进先出. 02 表表,包括很多种,有占用连续空间的数组.用指针链接的单向和双向链表,首尾 ...
数据结构与算法(2)——栈和队列
前言:题图无关,只是好看,接下来就来复习一下栈和队列的相关知识前序文章: 数据结构与算法(1)--数组与链表(https://www.jianshu.com/p/7b93b3570875) 栈什么 ...
【数据结构与算法】栈与队列
栈一.什么是栈? 1.后进者先出,先进者后出,这就是典型的"栈"结构. 2.从栈的操作特性来看,是一种"操作受限"的线性表,只允许在端插入和删除数据. 二.为 ...
数据结构与算法之栈与队列：java实现
闻理似悟,遇境则迷!!! 栈与队列来说也算是一种特殊的线性表,栈的特点是后进先出,队列的特点是先进先出. 栈栈的特点是后进先出,栈的操作只有出栈和入栈(也叫压栈),除此之外,还包含栈顶与栈底的指向以 ...
【数据结构与算法】栈与队列【C语言版】
目录 3.1 栈和队列的定义和特点 3.2 栈.队列与一般线性表的区别 3.3 栈的表示和操作的实现顺序栈与顺序表 ================= 顺序栈的表示顺序栈初始化判断顺序栈是否为空 ...
用JS描述的数据结构及算法表示——栈和队列（基础版）
前言:找了上课时数据结构的教程来看,但是用的语言是c++,所以具体实现在网上搜大神的博客来看,我看到的大神们的博客都写得特别好,不止讲了最基本的思想和算法实现,更多的是侧重于实例运用,一边看一边在心里 ...
数据结构与算法(二) 栈与队列（代码示例）
数据结构与算法栈与队列 1. 数组和链表实现栈 2. 用O(1)的时间复杂度求栈中的最小元素 3. 链表和数组实现队列 4. 用两个栈模拟队列操作 1. 数组和链表实现栈链表的方式: /*** 描 ...
数据结构与算法 | 用栈实现队列
之前的几章我讲解了栈和队列的基本特性和一些基本的操作方法,那么如何能利用栈来实现队列呢? 下面我来讲解下具体思路,栈的特性先进后出,队列是先进先出,如果要模拟队列的这个特性,我们就必须用到两个栈. 一 ...

学习笔记-数据结构与算法之栈与队列

目录

栈 LIFO

顺序存储

初始化

入栈

出栈

整体代码

链式存储

入栈

出栈

整体代码

队列 FIFO

顺序结构 – 循环队列（解决假溢出）

初始化

入队

出队

整体代码

链式存储

初始化

入队

出队

整体代码

传送门

学习笔记-数据结构与算法之栈与队列相关推荐

最新文章

热门文章