1、顺序存储：线性表/栈/队列：理论+C语言实现--详细

GUET_一路向前

已于 2022-07-26 15:26:33 修改

阅读量739

点赞数 1

分类专栏：数据结构与算法文章标签： c语言数据结构顺序表栈队列

于 2022-07-22 21:17:39 首次发布

本文链接：https://blog.csdn.net/qq_45986997/article/details/125940031

版权

数据结构与算法专栏收录该内容

7 篇文章 1 订阅

订阅专栏

Data_Structure

绪论

1、逻辑结构

1.集合结构

集合结构中的数据元素除了同属于一个集合外没有其他关系，各个元素平等。

2. 线性结构

线性结构中的元素之间是一对一的关系。

3.树形结构

树形结构中的数据元素之间存在一对多的层次关系。

4.图形结构

图形结构是多对多的关系
将每一个元素看做一个节点，用画圈表示
元素之间的逻辑关系用结点之间的连线表示，如果这个关系有方向则用带箭头的连线表示。

2、物理结构

1.顺序存储结构

顺序存储结构就是把数据元素存放在地址连续的存储单元里，其数据间的逻辑关系和物理关系是一致的。就类似于你去饭堂打饭排队。

2.链式存储结构

链式存储结构：是把数据元素存放在存储单元里，这组存储可以是连续的也可以是不连续的。

存储关系不能反映逻辑关系，需要通过指针进行指向它的地址。

1 线性表的顺序存储

1.1 线性表

线性表是一个线性结构，有n≥0个结点的有限序列。

第一个结点没有前继
中间结点既有前继又有后继
最后一个结点没有后继

线性表优缺点

优点	缺点
1.节约存储空间：无须为表示元素间的逻辑关系而增加额外空间	插入和删除操作需要移动大量的元素
2.可以快速存取表中任一位置的元素	当线性表的长度变化较大时，难以确定存储空间的容量
	造成存储空间的”碎片“

1.2 顺序表

1.2.1 理论知识

1、线性表采用顺序存储的方式进行存储称为顺序表，占用计算机内存中一段连续的存储单元。

location（Ki）= location(K1) + (i-1) len----------len指每一个结点占用的存储单元

2、重要操作

插入：将插入元素的位置后面的所有元素，从最后一个元素开始依次向后挪一个存储单元。
删除：删除操作与插入操作更好相反，将要删除元素的位置后面的所有元素依次往前挪一个存储单元。

顺序表类型的描述：

ADT sequence_list:

数据集合K：K= {k1,k2,k3,k4…Kn},其中n≥0，K中的元素是datatype类型

数据关系R：R={<ki,ki+1>| i=1,2…n}

操作集合如下：

函数	作用
1、void init(sequence_list *list)	顺序表初始化—置空表
2、void append(sequence_list *slt, datatype x)	在顺序表后面插入值为x的结点
3、void display(sequence_list list)	打印顺序表的各个结点值
4、int empty(sequence_list slt)	判断顺序表是否为空
5、int find(sequence_list slt, datatype x)	查找顺序表中值为x的结点位置
6、int get(sequence_list slt, int i)	取顺序表中第i个结点的值
7、void insert(sequence_list *slt , int position ,datatype x)	在顺序表的position位置插入值为x的结点
8、void dele(sequence_list *list ,int position )	删除表中第position位置的结点

1.2.2 编程实战

1、头文件：sequence_list.h

#ifndef __SEQUENCE_LIST_H
#define  __SEQUENCE_LIST_H


#define MAXSIZE 100
typedef int datatype;

//定义一个顺序表结构体
typedef struct {
	datatype a[MAXSIZE];
	int size;
}sequence_list;

void init(sequence_list* list);		//顺序表初始化-- - 置空表
void append(sequence_list* slt, datatype x);//在顺序表后面插入值为x的结点
void display(sequence_list list);	  //打印顺序表的各个结点值
int empty(sequence_list slt);			  //判断顺序表是否为空
int find(sequence_list slt, datatype x);//查找顺序表中值为x的结点位置
int  get(sequence_list slt, int i);          //取顺序表中第i个结点的值
void insert(sequence_list *slt, int position, datatype x);//在顺序表的position位置插入值为x的结点
void dele(sequence_list * list, int position);//删除表中第position位置的结点

#endif //__SEQUENCE_LIST_H

2、函数定义：sequence_list.c

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

//完成顺序表初始化，置空表
void init(sequence_list* list) {
    list->size = 0; 
}

void append(sequence_list* slt, datatype x)//在顺序表后面插入值为x的结点
{
    //如果顺序表已满则提示退出，否则继续插入
    if (slt->size == MAXSIZE)
    {
        printf("顺序表已满，不能再插入\n");
        exit(1);    
    }
    slt->a[slt->size] = x;
    slt->size++;
}

void display(sequence_list list)	  //打印顺序表的各个结点值
{
    int i;
    if (! list.size)
    {
        printf("顺序表为空\n");
    }
    else
        for ( i = 0; i < list.size; i++)
        {
            printf("%5d", list.a[i]);
        }
    printf("\n");
}
/*
函数功能：判断顺序表是否为空
函数参数：sequence_list 型变量slt
函数返回参数：int 类型；1表示空；0表示非空
文件名：sequence_list.c ,函数名：empty()
*/
int empty(sequence_list slt)  //判断顺序表是否为空
{
    //方法1
    if (!slt.size)
    {
        printf("顺序表为空\n");
        return 1;
    }
    else
    {
        printf("顺序表非空\n");
        return 0;
    }

    //方法2
  //  return (slt.size == 0?1:0);
}

int find(sequence_list slt, datatype x)//查找顺序表中值为x的结点位置
{
    //方法1
    //for (int i = 0; i < slt.size; i++)
    //{
    //    if (x == slt.a[i])
    //        return i;
    //}
    //方法2
    int i = 0;
    while ((i < slt.size) && (slt.a[i] != x))
    {
        i++;
    }
    return i < slt.size ? i : -1;
}

int  get(sequence_list slt, int i)          //取顺序表中第i个结点的值，0≤i≤size
{
    if (i<0 || i>slt.size)
    {
        printf("指定位置不存在\n");
        exit(1);
    }
    else
    {
        return slt.a[i];
    }
   // return i < slt.size ?slt. a[i + 1] : -1;
}

void insert(sequence_list  *slt, int position, datatype x)//在顺序表的position位置插入值为x的结点
{
    if (slt->size == MAXSIZE)
    {
        printf("顺序表已满无法插入\n");
        exit(1);
    }
    if (position < 0 || position >slt->size)
    {
        printf("插入位置不在0~size范围内,请重新插入\n");
        exit(1);
    }
    for (int i = slt->size; i > position ; i--)
    {
        slt->a[i] = slt->a[i-1];
    }
    slt->a[position] = x;
    slt->size++;
}

void dele(sequence_list* list, int position)//删除表中第position位置的结点
{
    if (list->size == 0)
    {
        printf("该顺序表为空，无法删除\n");
        exit(1);
    }
    if (position < 0 || position > list->size)
    {
        printf("删除的位置不在0~size，范围内，请重新输入\n");
        exit(1);
    }
    for (int i = position; i < list->size-1; i++)
    {
        list->a[i] = list->a[i + 1];
        
    }
    list->size--;
}

3、主函数：main.c

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

sequence_list list;

void main()
{
	init(&list);
	empty(list);
	append(&list,10);
	display(list); 
	empty(list);
	append(&list, 6);
	printf("6的位置是%d\n", find(list, 6));
	insert(&list,1,8);
	display(list);
	dele(&list,1);
	printf("第1个结点值为%3d\n",get(list,1));
	display(list);
}

4、运行结果

1.3 栈

1.3.1 栈的基本概念及描述

1、基本概念

定义：栈是一种特殊的线性表，规定它的插入和删除只能从同一端进行
栈顶和栈底：进行插入和删除的同一端，另一端称为栈底
生活例子：进栈（插入）与洗碗相同，把碗从下一个个堆积起来，出栈（删除）与拿碗相似，拿碗是从上往下一个个拿出来。

2、描述

栈类型的描述：

数据集合K：K= {k1,k2,k3,k4…Kn},其中n≥0，K中的元素是datatype类型

数据关系R：R={r}, r={<ki,ki+1>| i=1,2…n}

操作集合如下：

函数	作用
1、void init(sequence_stack *stack)	栈初始化—置空栈
2、void push(sequence_stack *stack, datatype x)	进栈
3、void pop(sequence_stack *stack,datatype x)	出栈
4、datatype read(sequence_stack stack)	读取栈顶结点的值
5、int empty(sequence_stack stack)	判断栈是否为空
6、int display(sequence_stack stack)	将栈中的元素从头到尾打印出来

1.3.2 栈编程实战

1、头文件：sequence_stack.h

#pragma once

#ifndef SEQUENCE_STACK_H
#define SEQUENCE_STACK_H

#define MAXSIZE  100
typedef int datatype;
typedef struct
{
	datatype b[MAXSIZE];
	int top;
}sequence_stack;

void init(sequence_stack* stack);  //栈初始化---置空栈
void push(sequence_stack* stack, datatype x);//进栈
void pop(sequence_stack* stack);//出栈
datatype read(sequence_stack stack); //读取栈顶元素
int empty(sequence_stack stack);//判断栈是否为空
void  display(sequence_stack stack);//将栈中的元素从头到尾打印出来

#endif // !SEQUENCE_STACK_H

2、函数定义：sequence_stack.c

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

void init(sequence_stack* stack)  //栈初始化---置空栈
{
	 stack->top = 0;
}

void push(sequence_stack *stack, datatype x)//进栈
{
	if (stack->top == MAXSIZE)
	{
		//printf("栈已满，无法进栈\n");
		printf("\n The sequence stack is full");
		exit(1);
	}
	stack->b[stack->top] = x;
	stack->top++;

}
void pop(sequence_stack* stack)//出栈
{
	if (stack->top == 0)
	{
		printf("\n The sequence is empty! \n");
		exit(1);
	}
	printf("pop the data is %5d \n",stack->b[stack->top-1]);
	stack->top--;
}
datatype read(sequence_stack stack) //读取栈顶元素
{
	if (!stack.top)
	{
		printf("栈没有元素\n");
		exit(1);
	}
	return stack.b[stack.top-1];
}
int empty(sequence_stack stack)//判断栈是否为空
{
	return (stack.top  ? 0:1);
}
void  display(sequence_stack stack)//将栈中的元素从头到尾打印出来
{
	if (stack.top ==0)
	{
		printf("\n The sequence is empty! \n");
		exit(1);
	}
	for (int  i = stack.top - 1; i >=0; i--)
	{
		printf("%3d",stack.b[i]);
	}
	printf("\n");
}

3、主函数：main.c

#include<stdio.h>
#include<stdlib.h>
#include"sequence_stack.h"
sequence_stack stack;
void main()
{
	int n;
	datatype data;
	int command;
	init(&stack);
	printf("input you want to push n number of data  \n");
	scanf_s("%d",&n);
	for (int i = 0; i < n; i++)
	{
		printf("please enter  the %2d data \n",i);
		scanf_s("%d",&data);
		push(&stack,data);
	}
	display(stack);
	while (1)
	{
		printf("input the openration that you want:\n0--init;\n1--push;\n2--pop;\n3--read;\n4--empty;\n5--display\n");
		scanf_s("%d", &command);
		switch (command)
		{
			case 0: init(&stack); break;
			case 1: {
				printf("input the data\n");
				scanf_s("%d", &data);
				push(&stack, data);
				break;
			}
			case 2: {
				pop(&stack);
				break;
			}
			case 3: n = read(stack); printf("The top-data of stack is %d\n ",n); break;
			case 4:n = empty(stack);printf("empty is %d \n",n); break;
			case 5:display(stack); break;
			default:printf("input error, the program ends automatically \n"); exit(1);
			}
	}
	
}

4、运行结果

1.3.3 栈的应用之一：括号匹配

题目：一个表达式中包含3种括号：小、中、大括号。如“{【（）】}”，设计程序判断括号是否匹配，也就是说，看由3种括号组成的表达式是否关于中心对称。

算法思路：用一个字符数组将要检测的括号存起来，从左向右扫描，扫描过的括号压入栈中，并且在每次扫描过程中将扫描到的括号与栈顶中的括号进行对比，如果匹配则消去该括号，否则把扫描到的压入栈中，继续向右扫描。扫描完后，如果栈是空的，则说明表达式中的括号是匹配的，否则不匹配。

1、算法编程实现:stack_match_kuohao.c

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

int match_kuohao(char c[])
{
	int i = 0;
	sequence_stack st;
	init(&st);
	while (c[i]!='#')
	{
		switch (c[i])
		{
		case '(':
		case '[':
		case '{':push(&st, c[i]); break;
		case  ')':if ((!empty(st)) && (read(st) == '('))
						{
							pop(&st); break;
						}
						 else return 0;
		case ']':if ((!empty(st)) && (read(st) == '[' )) 
						{
							pop(&st); break;
						}
						else return 0;
		case '}':if ((!empty(st)) && (read(st) == '}' ) )
						{
							pop(&st); break;
						}
						else return 0;


		}
		i++;
	}
	return (empty(st));  //返回0为不匹配，否则匹配
}

2、主函数：main.c

void main()
{
	char c[] = "{[)]}";  //单个字符用单引号，多个字符即字符串用双引号
	if (match_kuohao(&c))
		printf("括号匹配\n");
	else
		printf("括号不匹配\n");
}

3、运行结果

输入：“{[()]}” 输出：不匹配

输入：“{[([])]}” 输出：匹配

1.3.4 栈的应用之二算术表达式求值

中缀表达式	后缀表达式
3-5*2	3 5 2*-
2+3-4/2	2 3 4 2/±

1、后缀表达式计算

计算机处理后缀表达式比较方便。

算法思想：

将遇到的操作数暂存与一个操作数栈中，凡是遇到操作符，便从栈中弹出2个操作数执行操作符对应的操作，并将结果存与操作数栈中，后缀表达式中最后一个操作符处理完，最后压入栈中的数就是后缀表达式的计算机结果。

相关函数定义

/*
函数功能：将数字字符串转变为相应的数
函数参数：char 类型数组，指向int类型变量的指针 i
函数返回值：double类型，返回数字字符串对应的数
函数名：readnumber，文件名：calculator_expression.c
*/
double readnumber(char f[], int* i)
{
	double x = 0.0;
	int k = 0;
	while (f[*i]>='0'&&f[*i]<='9') //处理整数部分
	{
		x = x * 10 + (f[*i] - '0');
		(*i)++;
	}
	if (f[*i]=='.') //处理小数部分
	{
		(*i)++;
		while (f[*i]>='0' && f[*i]<='9')
		{
			x = x * 10 + (f[*i] - '0');
			(*i)++;
			k++;

		}
	}
	while (k!=0)
	{
		x = x / 10.0;
		k = k - 1;
	}
	return x;
}

/*
函数功能：求一个后缀表达式的值
函数参数：char 类型数组f
函数返回值：double类型，返回后缀表达式的值
函数名：evalpost()，文件名：calculator_expression.c
*/
double evalpost(char f[])
{
	double obst[100]; //操作数栈
	int top = 0;
	int i = 0;
	double x1,x2;
	while (f[i]!='\0')
	{
		if (f[i]>='0' && f[i]<='9')
		{
			obst[top] = readnumber(f,&i);
			top++;
		}
		else if (f[i]==' ')
		{
			i++;
		}
		else if (f[i] == '+')
		{
			x2 = obst[--top];
			x1 = obst[--top];
			obst[top] = x1 + x2;
			top++;
			i++;
		}
		else if (f[i] == '-')
		{
			x2 = obst[--top];
			x1 = obst[--top];
			obst[top] = x1 - x2;
			top++;
			i++;
		}
		else if (f[i] == '*')
		{
			x2 = obst[--top];
			x1 = obst[--top];
			obst[top] = x1 * x2;
			top++;
			i++;
		}
		else if (f[i] == '/')
		{
			x2 = obst[--top];
			x1 = obst[--top];
			obst[top] = x1 /x2;
			top++;
			i++;
		}
	}
	return obst[0];
}

main.c

main()
{
			//后缀表达式求值
	char f[] = "3.5 2.5 2.0*+";
	double result;
	result = evalpost(&f);
	printf("The result is %f",result);

}

运行结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-c1piz8Se-1658649862914)(C:\Users\dfghkl\AppData\Roaming\Typora\typora-user-images\image-20220723114742282.png)]

1.4 队列

1.4.1 队列的基本概念及描述

1、基本概念

定义：队列是一种特殊的线性表，规定它的删除只能从队首进行，而插入只能在队尾进行。
栈顶和栈底：进行插入的一端称为队尾，进行删除一端称为队首。
生活例子：去火车站排队买票，去食堂打饭排队等。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cBsEbRHP-1658649862919)(C:\Users\dfghkl\AppData\Roaming\Typora\typora-user-images\image-20220724102441866.png)]

2、描述

栈类型的描述：

数据集合K：K= {k1,k2,k3,k4…Kn},其中n≥0，K中的元素是datatype类型

数据关系R：R={r}, r={<ki,ki+1>| i=1,2…n-1}

操作集合如下：

函数	作用
void init(sequence_queue *sq)	队列（顺序存储）初始化
int empty(sequence_queue sq)	判断队列是否为空
void display(sequence_queue sq)	打印队列中的结点信息
datatype get (sequence_queue sq, int num)	取得队列中队首或队尾结点的值
void insert (sequence_queue *sq ,datatype x)	队列的插入操作
void delet(sequence_queue *sq)	队列的删除操作

1.4.2 队列编程实战

在C语言中，队列的顺序存储可以用一维数组表示。为了标识队首和队尾，分别用两个指针front和rear分别指向队首和队尾。

1、头文件：sequence_queue.h

#ifndef __SEQUENCE_QUEUE_H
#define __SEQUENCE_QUEUE_H

//定义队列的结构体
#define MAXSIZE 100
typedef int datatype;

typedef struct {
	datatype d[MAXSIZE];
	int front;
	int rear;
}sequence_queue;

void init(sequence_queue* sq);  //队列初始化
int empty(sequence_queue sq);// 判断队列是否为空
void display(sequence_queue sq);//打印队列中的结点信息
datatype  get(sequence_queue sq,int num); //取得队列中队首和队尾结点的值
void insert(sequence_queue* sq, datatype x); //队列的插入操作
void delet(sequence_queue* sq); //队列的删除操作

#endif // __SEQUENCE_QUEUE_H

2、函数定义：sequence_queue.c

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

void init(sequence_queue* sq)//队列初始化
{
	sq->front = sq->rear = 0;
}
int empty(sequence_queue sq)// 判断队列是否为空
{
	return (sq.front==sq.rear ? 1:0);
}

void display(sequence_queue sq)//打印队列中的结点信息
{
	if (empty(sq))
	{
		printf("The team is listed as empty\n");
		exit(1);
	}
	for (int  i = sq.front; i < sq.rear; i++)
	{
		printf("%5d", sq.d[i]);
	}
	printf("\n");
}
datatype  get(sequence_queue sq, int num) //取得队列中队首和队尾结点的值
{
	if (empty(sq))
	{
		printf("The team is listed as empty\n");
		exit(1);
	}
	else
	{
		if (num == 0)
		{
			return sq.d[sq.front];
		}
		else
		{
			return sq.d[sq.rear-1];
		}
	}
}
void insert(sequence_queue* sq, datatype x) //队列的插入操作
{
	if (sq->rear == MAXSIZE)
	{
		printf("The queue is full\n");
		exit(1);
	}
	else
	{
		sq->d[sq->rear] = x;
		sq->rear++;
		printf("The insert data succeed\n");
	}
}
void delet(sequence_queue* sq) //队列的删除操作
{
	if (sq->rear == sq->front)
	{
		printf("The team is listed as empty and unble to delete\n");
		exit(1);
	}
	else
	{
		printf("The delete data id %5d\n",sq->d[sq->front]);
		sq->front++;
	}
}

3、主函数：main.c

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

sequence_queue queue;
void main()
{

	int n;
	datatype data;
	int command;
	init(&queue);
	printf("input you want to insert n number of data  \n");
	scanf_s("%d", &n);
	for (int i = 0; i < n; i++)
	{
		printf("please enter  the %2d data \n", i);
		scanf_s("%d", &data);
		insert(&queue, data);
	}
	display(queue);
	while (1)
	{
		printf("input the openration that you want:\n0--init;\n1--insert;\n2--display;\n3--get ;\n4--empty\n5--delet\n");
		scanf_s("%d", &command);
		switch (command)
		{
		case 0: init(&queue); break;
		case 1: {
			printf("input the data\n");
			scanf_s("%d", &data);
			insert(&queue, data);
			break;
		}
		case 2:display(queue); break;
		case 3: printf("The top-data of queue is %d\n ",get(queue,0)); break;
		case 4:n = empty(queue); printf("empty is %d \n", n); break;
		case 5:delet(&queue); break;
		default:printf("input error, the program ends automatically \n"); break;
		}

	}

}

1.5 循环队列

1.5.1 循环队列理论知识

给定一个大小为MAXSIZE大小的数组存储一个队列，经过若干次插入和删除操作后，当尾指针rear = MAXSIZE时队列已满，但前面位置可能存在空闲的情况，因此我们引入了循环队列，解决这个问题，提高存储空间利用率。

把数组中的第一个元素和最后一个元素当成相邻的，将顺序存储的队列看成一个环状。但要分区rear = front是队列为空导致的还是队列满导致的如下图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-trI3n8Y2-1658649862929)(C:\Users\dfghkl\AppData\Roaming\Typora\typora-user-images\image-20220724131309459.png)]

解决办法：

1.方法一：

设置一个flag变量，当front == rear 且flag == 0时表示队列为空；当front == rear 且flag == 1时表示队列为满；

2.方法二：

牺牲一个数组存储单元，若数组大小是MAXSIZE，则该数组所表示的循环队列最多允许存储MAXSIZE个结点。

建议掌握第二种

1.5.2 循环队列编程实战（方法2）

头文件：

#ifndef __SEQUENCE_QUEUE_H
#define __SEQUENCE_QUEUE_H

//定义队列的结构体
#define MAXSIZE 5
typedef int datatype;

typedef struct {
	datatype d[MAXSIZE];
	int front;
	int rear;
}sequence_queue;

void init(sequence_queue* sq);  //队列初始化
int empty(sequence_queue sq);// 判断队列是否为空
void display(sequence_queue sq);//打印队列中的结点信息
datatype  get(sequence_queue sq,int num); //取得队列中队首和队尾结点的值
//循环队列的删除操作方法2
void delete_circulation_queue_2(sequence_queue* sq);
//循环队列的插入操作方法2
void insert_circulation_queue_2(sequence_queue* sq, datatype x);
#endif // __SEQUENCE_QUEUE_H

函数定义

#include<stdio.h>
#include<stdlib.h>
#include"sequence_queue.h"
int flat;
void init(sequence_queue* sq)//队列初始化
{
	sq->front = sq->rear = 0;
}
int empty(sequence_queue sq)// 判断队列是否为空
{
	return (sq.front==sq.rear ? 1:0);
}

void display(sequence_queue sq)//打印队列中的结点信息
{
	if (empty(sq)&&(flat==0))
	{
		printf("The team is listed as empty\n");
		exit(1);
	}
	if (sq.front<sq.rear)
	{
		for (int i = sq.front; i < sq.rear; i++)
		{
			printf("%5d", sq.d[i]);
		}
	}
	else
	{
		for (int i = sq.front; i < MAXSIZE; i++)
		{
			printf("%5d", sq.d[i]);
		}
		for ( int i = 0;  i < sq.rear;  i++)
		{
			printf("%5d", sq.d[i]);
		}
	}

	printf("\n");
}
datatype  get(sequence_queue sq, int num) //取得队列中队首和队尾结点的值
{
	if (empty(sq))
	{
		printf("The team is listed as empty\n");
		exit(1);
	}
	else
	{
		if (num == 0)
		{
			return sq.d[sq.front];
		}
		else
		{
			return sq.d[sq.rear-1];
		}
	}
}

//循环队列的插入操作方法2
void insert_circulation_queue_2(sequence_queue* sq, datatype x)
{
	if (((sq->rear+1 )== sq->front)|| ((sq->rear + 1)%MAXSIZE == sq->front))
	{
		printf("The queue is full and can not insert\n");
		exit(1);
	}
	sq->d[sq->rear] = x;
	sq->rear = (sq->rear + 1) % MAXSIZE;  //从队尾回到队头
}

//循环队列的删除操作方法2
void delete_circulation_queue_2(sequence_queue* sq)
{
	if (sq->front == sq->rear)
	{
		printf("The team is listed as empty and unble to delete\n");
		exit(1);
	}
	sq->front = (sq->front+1)%MAXSIZE;
}

main.c

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

sequence_queue queue;
void main()
{

	int n;
	datatype data;
	int command;
	init(&queue);
	printf("input you want to insert n number of data  \n");
	scanf_s("%d", &n);
	for (int i = 0; i < n; i++)
	{
		printf("please enter  the %2d data \n", i);
		scanf_s("%d", &data);
		insert_circulation_queue_2(&queue, data);
	}
	display(queue);
	while (1)
	{
		printf("input the openration that you want:\n0--init;\n1--insert;\n2--display;\n3--get ;\n4--empty\n5--delet\n");
		scanf_s("%d", &command);
		switch (command)
		{
		case 0: init(&queue); break;
		case 1: {
					printf("input the data\n");
					scanf_s("%d", &data);
					insert_circulation_queue_2(&queue, data);
					break;
					}
		case 2:display(queue); break;
		case 3: printf("The top-data of queue is %d\n ",get(queue,0)); break;
		case 4:n = empty(queue); printf("empty is %d \n", n); break;
		case 5:delete_circulation_queue_2(&queue); break;
		default:printf("input error, the program ends automatically \n"); break;
		}

	}

}

在这里插入图片描述

GUET_一路向前

关注

1
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
1、顺序存储：线性表/栈/队列：理论+C语言实现--详细

算法思路用一个字符数组将要检测的括号存起来，从左向右扫描，扫描过的括号压入栈中，并且在每次扫描过程中将扫描到的括号与栈顶中的括号进行对比，如果匹配则消去该括号，否则把扫描到的压入栈中，继续向右扫描。扫描完后，如果栈是空的，则说明表达式中的括号是匹配的，否则不匹配。顺序存储结构就是把数据元素存放在地址连续的存储单元里，其数据间的逻辑关系和物理关系是一致的。链式存储结构是把数据元素存放在存储单元里，这组存储可以是连续的也可以是不连续的。数据关系RR={r},r={|i=1,2…...............
复制链接

扫一扫