顺序表和基于顺序表的栈和队列的实现（c思想实现）

最新推荐文章于 2020-12-18 22:16:46 发布
最新推荐文章于 2020-12-18 22:16:46 发布
阅读量725 收藏 1
点赞数 1
分类专栏： 数据结构C 文章标签： 数据结构顺序表C
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WSTONECH/article/details/80890123
版权

数据结构主要分为线性结构和非线性结构

 

目录

关于void*和NULL

顺序表

头文件(具体功能划分)

dm_02_seqlist.cpp（实现每一个顺序表的基本操作）

测试程序 main()

测试结果：

基于顺序表的栈：

栈的头文件：

栈的实现文件：

栈的测试文件：

栈的测试结果：

基于顺序表的队列：

队列的头文件：

队列的实现文件：

队列的测试文件：

队列的测试结果：

关于void*和NULL

 

NULL  #define NULL   ((void *)0) 

空指针有指向，但是它指向的地址是特殊的（0），在内存分配方面，较小的地址是不用来存放数据的，也不允许程序访问的,所以空指针不能操作该地址里的东西，我们就理解为“指针指向了空，无法操作了”。

void * 类型指针

这个类型指针指向了实实在在的存放数据的地址，但是该地址存放的数据的数据类型我们暂时不知道。所以先弄成void* 类型，后期一般要强制转换的（如指针++ -- 等操作，void*没有类型，步长不知道，必须强转，如(char*)）。

顺序表

头文件(具体功能划分)

 dm_02_seqlist.h

#pragma once
#include"iostream"

using namespace std;

typedef void Seqlist;
typedef void SeqlistNode;

Seqlist* SeqlistCreat(int capacity);//创建固定大小的线性表
void SeqlistDestory(Seqlist*list);//销毁线性表
void SeqlistClear(Seqlist*list);//清空
int SeqlistLength(Seqlist*list);//返回长度
int SeqlistCapacity(Seqlist*list);//返回容量
int SeqlistInsert(Seqlist*list, SeqlistNode*node,int pos);//指定位置插入节点
SeqlistNode* SeqlistGet(Seqlist*list, int pos);//获取指定位置节点
SeqlistNode*SeqlistDelete(Seqlist*list, int pos);//删除指定位置节点

dm_02_seqlist.cpp（实现每一个顺序表的基本操作）

#include"dm_02_seqlist.h"

struct TSeqlist
{
	int len;//定义数组长度
	int capacity;
	unsigned int **node;//定义数组的首地址，二级指针 动态分配内存空间 或指针数组 每个元素均是一个指针 int *node[n];
	                    //二级内存结构
};

//底层业务节点只是操作上层传入的指针，节点的内存由上层业务分配
//由于未知上层业务节点类型，故定义unsigneg int**指针类型，可以指向任何业务节点

Seqlist* SeqlistCreat(int capacity)
{
	TSeqlist *tmp;
	int ret = 0;
	tmp = (TSeqlist*)malloc(sizeof(TSeqlist));//创建顺序表句柄
	if (tmp == NULL)
	{
		ret = -1;
		cout << "func SeqlistCreat malloc err" << ret << endl;
		return NULL;
	}
	memset(tmp, 0, sizeof(TSeqlist));//初始化内存空间0

	tmp->node = (unsigned int **)malloc(sizeof(unsigned int *)*capacity);
	if (tmp->node == NULL)
	{
		ret = -2;
		cout << "func SeqlistCreat malloc err" << ret << endl;
		return NULL;
	}
	tmp->capacity = capacity;
	tmp->len = 0;
	return tmp;//Seqlist* 为void*型 
}
//释放内存销毁链表
void SeqlistDestory(Seqlist*list)
{
	TSeqlist*tlist = NULL;//自己知道数据类型
	if (list == NULL)
	{
		cout << "传入为空指针" << endl;
		return;
	}
	tlist = (TSeqlist*)list;
	if (tlist->node != NULL)
	{
		free(tlist->node);
	}
	free(tlist);
}
//清空链表
void SeqlistClear(Seqlist*list)
{
	TSeqlist*tlist = NULL;//自己知道数据类型
	if (list == NULL)
	{
		cout << "传入为空指针" << endl;
		return;
	}
	tlist->len = 0;//清空链表即回到初始化状态，len=0

}
//返回链表长度
int SeqlistLength(Seqlist*list)
{
	if (list == NULL)
	{
		cout << "传入为空指针" << endl;
		return -1;
	}
	TSeqlist*tlist = (TSeqlist*)list;
	return tlist->len;
}

int SeqlistCapacity(Seqlist*list)
{
	if (list == NULL)
	{
		cout << "传入为空指针" << endl;
		return -1;
	}
	TSeqlist*tlist = (TSeqlist*)list;
	return tlist->capacity;
}


//顺序表插入元素
int SeqlistInsert(Seqlist*list, SeqlistNode*node, int pos)
{
	int ret = 0;
	TSeqlist*tlist = (TSeqlist*)list;

	//输入不合法
	if (list == NULL || node == NULL || pos < 0)
	{
		ret = -1;
		cout << "输入不合法 list == NULL || node == NULL || pos < 0 " << ret << endl;
		return ret;
	}
	//顺序表已经满了
	if (tlist->len == tlist->capacity)
	{
		ret = -2;
		cout << "顺序表已经满了 tlist->len == tlist->capacity " << ret << endl;
		return ret;
	}
	//顺序表没有满 插入位置大于len 即1到4 插到6、位置5空了
	if (pos >= tlist->len)
	{
		 pos = tlist->len;
	}
	//移动后面元素
	for (int i = tlist->len; i > pos; i--)
	{
		tlist->node[i] = tlist->node[i-1];
	}
	//插入元素
	tlist->node[pos] = (unsigned int*)node;//指针赋给指针
	//若node为一级指针 则（unsigned int）将指针node转换为unsigned int型变量
	tlist->len++;
	return ret;
}

//读取节点
SeqlistNode* SeqlistGet(Seqlist*list, int pos)
{
	SeqlistNode* ret = NULL;
	TSeqlist*tlist = (TSeqlist*)list;

	//输入不合法
	if (list == NULL ||pos < 0 )
	{
		cout << "输入不合法 list == NULL || node == NULL || pos < 0" << ret << endl;
		return ret;
	}
	 ret = (SeqlistNode*)( tlist->node[pos]);
	 return ret;
}

//删除节点
SeqlistNode*SeqlistDelete(Seqlist*list, int pos)
{
	SeqlistNode* ret = NULL;
	TSeqlist*tlist = (TSeqlist*)list;

	//输入不合法
	if (list == NULL || pos < 0)
	{
		cout << "输入不合法 list == NULL || node == NULL || pos < 0 " << ret << endl;
		return ret;
	}
	//移动后面元素
	ret = (SeqlistNode*)(tlist->node[pos]);
	for (int i = pos+1; i <tlist->len; i++)
	{
		tlist->node[i-1] = tlist->node[i];
	}
	tlist->len--;
	return (SeqlistNode*)ret;
}

测试程序 main()

#include"dm_02_seqlist.h"
#include"iostream"
#define _CRT_SECURE_NO_WARNINGS

using namespace std;
//SeqlistNode 为 void根本不不关心节点长啥样
//实际应用时(Teacher*) (SeqlistNode*)进行类型转换 顺序表和业务分离
struct Teacher {
	int age;
	char name[32];
};

void main02()
{ 
	int size = 20;
	int ret = 0;
	Seqlist*list = NULL;
	Teacher t1, t2, t3, t4;
	strcpy(t1.name, "zhangsan22");
	strcpy(t2.name, "lisi22");
	strcpy(t3.name, "wangwu22");
	strcpy(t4.name, "maliu22");
	t1.age = 20;
	t2.age = 22;
	t3.age = 24;
	t4.age = 26;
	//建立链表
	list = SeqlistCreat(10);
	if (list == NULL)
	{
		ret = -1;
		cout << "func SeqlistCreat err" << ret << endl;
		return;//跳出main()函数
	}

	//头插
	ret = SeqlistInsert(list,( SeqlistNode*)&t1, 0);//链表不关心具体的节点是啥(void)，用到具体类型进行强制类型转换
	ret = SeqlistInsert(list, (SeqlistNode*)&t2, 0);
	ret = SeqlistInsert(list, (SeqlistNode*)&t3, 0);
	ret = SeqlistInsert(list, (SeqlistNode*)&t4, 0);
	if (list == NULL)
	{
		ret = -1;
		cout << "func SeqlistInsert err" << ret << endl;
		return;
	}

	//遍历
	for (int i = 0; i < SeqlistLength(list); i++)
	{
		Teacher *tmp = (Teacher*)SeqlistGet(list, i);//上层应用知道自己传的是Teacher,别人不知道什么类型，
		if (tmp == NULL)
		{
			ret = -2;
			cout << "func SeqlistGet err" << ret << endl;
			return;
		}
		cout<<tmp->name<< tmp->age << endl;
	}
	//删除
	while (SeqlistLength(list)>0)
	{ 
		Teacher*tmp = NULL;
		tmp = (Teacher*)SeqlistDelete(list, 0);//删0位置 即头
		if (tmp == NULL)
		{
			ret = -3;
			cout << "func SeqlistDelete err" << ret << endl;
			return;
		}
		cout << tmp->name << '\t' << tmp->age << endl;
	}

         //检验是否删除完毕
	for (int i = 0; i < SeqlistLength(list); i++)
	{
		Teacher *tmp = (Teacher*)SeqlistGet(list, i);//上层应用知道自己传的是Teacher,别人不知道什么类型，
		if (tmp == NULL)
		{
			ret = -2;
			cout << "func SeqlistGet err" << ret << endl;
			return;
		}
		cout << tmp->name << tmp->age << endl;
	}


}

测试结果：

基于顺序表的栈：


栈的头文件：

#pragma once
#ifndef  __MY_SEQSTACK_H__ 
#define  __MY_SEQSTACK_H__

typedef void SeqStack;
typedef void SeqNode;

SeqStack* SeqStack_Create(int capacity);
void SeqStack_Destroy(SeqStack * stack);
void SeqStack_Clear(SeqStack * stack);
void SeqStack_Push(SeqStack * stack, SeqNode*item);
SeqNode* SeqStack_Pop(SeqStack * stack);
SeqNode* SeqStack_Top(SeqStack * stack);
int SeqStack_Size(SeqStack * stack);
int SeqStack_Capacity(SeqStack * stack);
#endif  //__MY_SEQLIST_H__


栈的实现文件：

#include"iostream"
#include"dm_06_seqStack.h"

using namespace std;
struct TseqStack {
	int len;
	int capacity;
	unsigned int **node;
};

//栈是特殊的线性表 创建栈相当于创建线性表
SeqStack* SeqStack_Create(int capacity)
{
	if (capacity <= 0)
	{
		cout << "SeqStack_Create err capacity <= 0 " << endl;
		return NULL;
	}
	TseqStack *tseqStack = (TseqStack *)malloc(sizeof(TseqStack));
	memset(tseqStack, 0, sizeof(tseqStack));
	tseqStack->node = (unsigned int **)(malloc(sizeof(unsigned int *)*capacity));
	tseqStack->capacity = capacity;
	tseqStack->len = 0;
	return tseqStack;
}
//销毁栈
void SeqStack_Destroy(SeqStack * stack)
{
	if (stack == NULL)
	{
		cout << "SeqStack_Destroy err stack == NULL " << endl;
	}
	else
	{
		TseqStack *tseqStack = (TseqStack *)(stack);
		tseqStack->capacity = 0;
		tseqStack->len = 0;
		if (tseqStack != NULL)
		{
			free(tseqStack);
		}
	}
}
//清空栈 等价于清空线性表
void SeqStack_Clear(SeqStack * stack)
{
	if (stack == NULL)
	{
		cout << "SeqStack_Clear err stack == NULL " << endl;
	}
	else
	{
		TseqStack *tseqStack = (TseqStack *)(stack);
		tseqStack->capacity = 0;
		tseqStack->len = 0;
		tseqStack = NULL;
	}
}
//压栈 相当于线性表尾插法
void SeqStack_Push(SeqStack * stack, SeqNode*item)
{
	if (stack == NULL|| item == NULL)
	{
		cout << "SeqStack_Push err stack == NULL|| item == NULL" << endl;
	}
	else
	{
		TseqStack *tseqStack = (TseqStack *)(stack);
		if (tseqStack->len >= tseqStack->capacity)
		{
			cout << "SeqStack_Push err tseqStack->len >= tseqStack->capacity" << endl;
		}
		else
		{
			tseqStack->len++;//必须先加1 否则len为0则下一步无法读
			tseqStack->node[tseqStack->len-1] = (unsigned int*)item;//下标从0开始，所以len-1
			
		}
	}
}

//弹栈 相当于从线性表尾部删除
SeqNode* SeqStack_Pop(SeqStack * stack)
{
	TseqStack *tseqStack = (TseqStack *)(stack);
	SeqNode* ret = NULL;
	if (tseqStack == NULL)
	{
		cout << "SeqStack_Pop err stack == NULL" << endl;
		return ret;
	}
	else
	{
		ret = (SeqNode*)tseqStack->node[tseqStack->len - 1];
		tseqStack->len--;
		return ret;
	}
}
//获取站顶元素 相当于从线性表尾部读取
SeqNode* SeqStack_Top(SeqStack * stack)
{
	TseqStack *tseqStack = (TseqStack *)(stack);
	SeqNode* ret = NULL;
	if (tseqStack == NULL)
	{
		cout << "SeqStack_Top err stack == NULL" << endl;
		return ret;
	}
	else
	{
		ret = (SeqNode*)tseqStack->node[tseqStack->len - 1];
		return ret;
	}
}
int SeqStack_Size(SeqStack * stack)
{
	int ret = 0;
	TseqStack *tseqStack = (TseqStack *)(stack);
	if (tseqStack == NULL)
	{
		cout << "SeqStack_Size err stack == NULL" << endl;
		return ret;
	}
	else
	{
		ret = tseqStack->len;
		return ret;
	}
}
int SeqStack_Capacity(SeqStack * stack)
{
	int ret = 0;
	TseqStack *tseqStack = (TseqStack *)(stack);
	if (tseqStack == NULL)
	{
		cout << "SeqStack_Size err stack == NULL" << endl;
		return ret;
	}
	else
	{
		ret = tseqStack->capacity;
		return ret;
	}
}


栈的测试文件：

#include"dm_06_seqStack.h"
#include"iostream"

using namespace std;

struct Teacher_06 {
	int age;
	char name[32];
};

void main()
{
	SeqStack*stack;
	Teacher_06 t1, t2, t3, t4;
	strcpy(t1.name, "zhangsan66");
	strcpy(t2.name, "lisi66");
	strcpy(t3.name, "wangwu66");
	strcpy(t4.name, "maliu66");
	t1.age = 20;
	t2.age = 22;
	t3.age = 24;
	t4.age = 26;

	stack = SeqStack_Create(10);
	SeqStack_Push(stack, (SeqNode*)(&t1));
	SeqStack_Push(stack, (SeqNode*)(&t2));
	SeqStack_Push(stack, (SeqNode*)(&t3));
	SeqStack_Push(stack, (SeqNode*)(&t4));

	cout<<"stack_size"<<SeqStack_Size(stack)<<endl;
	cout << "stack_capicity" << SeqStack_Capacity(stack) << endl;
	Teacher_06 * tmp = (Teacher_06 *)SeqStack_Top(stack);
	cout<<"stackTop"<< tmp->name<<" "<<tmp->age<<endl;


	//弹栈 遍历
	int len =  SeqStack_Size(stack);
	for (int i = 0; i<len ; i++)
	{
		tmp = (Teacher_06 *)SeqStack_Pop(stack);
		cout << tmp->name << " " << tmp->age << endl;
	}

	system("pause");
}


栈的测试结果：


基于顺序表的队列：


队列的头文件：

#pragma once//包含一次 若被多个cpp文件包含则会导致在多个文件里重复编译出错
#include"iostream"
#include"dm_02_seqlist.h"


typedef void SeqQueue;

SeqQueue* SeqQueue_Create(int capacity);

void SeqQueue_Destroy(SeqQueue* queue);

void SeqQueue_Clear(SeqQueue* queue);

int SeqQueue_Append(SeqQueue* queue, void* item);

void* SeqQueue_Retrieve(SeqQueue* queue);

void* SeqQueue_Header(SeqQueue* queue);

int SeqQueue_Length(SeqQueue* queue);

int SeqQueue_Capacity(SeqQueue* queue);


队列的实现文件：

#include"iostream"
#include"dm_08_seqqueue.h"


Seqlist* SeqlistCreat(int capacity);
void SeqlistDestory(Seqlist*list);
void SeqlistClear(Seqlist*list);
int SeqlistLength(Seqlist*list);
int SeqlistCapacity(Seqlist*list);
int SeqlistInsert(Seqlist*list, SeqlistNode*node, int pos);
SeqlistNode* SeqlistGet(Seqlist*list, int pos);
SeqlistNode*SeqlistDelete(Seqlist*list, int pos);


SeqQueue* SeqQueue_Create(int capacity)
{
	return  SeqlistCreat( capacity);
}

void SeqQueue_Destroy(SeqQueue* queue)
{
	SeqlistDestory((Seqlist*)(queue));
}

void SeqQueue_Clear(SeqQueue* queue)
{
	SeqlistClear((Seqlist*)(queue));
}

int SeqQueue_Append(SeqQueue* queue, void* item)
{
	int ret = -1;
	ret = SeqlistInsert((Seqlist*)(queue), (SeqlistNode*)(item), SeqQueue_Length(queue));//len比下标大1 插入位置为尾部下标后的一个位置刚好是len
	if (ret != 0)
	{
		cout << "SeqQueue_Append err ret" << ret << endl;
	}
	return ret;
}
//出队列相当于从线性表中删除0号位置元素
void* SeqQueue_Retrieve(SeqQueue* queue)
{
	SeqlistNode*ret = SeqlistDelete((Seqlist*)(queue),0);
	if (ret == NULL)
	{
		cout << "SeqQueue_Retrieve err" << endl;
	}
	return (void*)ret;
}
//获取队列头部   相当于从线性表中获取0号元素
void* SeqQueue_Header(SeqQueue* queue)
{
	SeqlistNode*ret = SeqlistGet((Seqlist*)(queue), 0);
	if (ret == NULL)
	{
		cout << "SeqQueue_Header err" << endl;
	}
	return (void*)ret;
}
//相当于获取线性表长度
int SeqQueue_Length(SeqQueue* queue)
{
	return SeqlistLength((Seqlist*)(queue));
}

int SeqQueue_Capacity(SeqQueue* queue)
{
	return  SeqlistCapacity((Seqlist*)(queue));
}


队列的测试文件：

#include"iostream"
#include"dm_08_seqqueue.h"

using namespace std;
struct Teacher_08 {
	int age;
	char name[32];
};


void main()
{
	SeqQueue*seqqueue;
	Teacher_08 t1, t2, t3, t4;
	strcpy(t1.name, "zhangsan66");
	strcpy(t2.name, "lisi66");
	strcpy(t3.name, "wangwu66");
	strcpy(t4.name, "maliu66");
	t1.age = 20;
	t2.age = 22;
	t3.age = 24;
	t4.age = 26;

	seqqueue = SeqQueue_Create(4);

	SeqQueue_Append(seqqueue, (void*)(&t1));
	SeqQueue_Append(seqqueue, (void*)(&t2));
	SeqQueue_Append(seqqueue, (void*)(&t3));
	SeqQueue_Append(seqqueue, (void*)(&t4));

	//队列的属性
	cout << "seqqueue_capacity" << SeqQueue_Capacity(seqqueue) << endl;
	cout << "seqqueuesize" << SeqQueue_Length(seqqueue) << endl;
	Teacher_08 * tmp = (Teacher_08 *)SeqQueue_Header(seqqueue);
	cout << "seqqueue header" << tmp->name << " " << tmp->age << endl;


	//出队遍历
	int len = SeqQueue_Length(seqqueue);
	for (int i = 0; i<len; i++)
	{
		tmp = (Teacher_08 *)SeqQueue_Retrieve(seqqueue);
		cout << tmp->name << " " << tmp->age << endl;
	}
	system("pause");
}


队列的测试结果：

第一次写博客，Mark一下，督促记录自己学习吧。

 

进击ing小白
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
顺序表---栈
小程的博客
02-16 847
栈 ：只能在表尾进行插入(入栈)和删除(出栈)的数据结构(受到限制的线性表) 表尾比较特殊，我们一般把这个表尾叫做栈顶，另一端栈底，没有数据节点，则叫做空栈。 特点:后进先出 （LIFO），先进后出 顺序栈结构体设计: struct Stack { 第一个数据成员：base（指针类型，接收malloc从堆里 ...
使用顺序表和链表实现栈和队列
DengLange的博客
03-09 272
一、栈 一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出的原则。 压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。 出栈：栈的删除操作叫做出栈，出数据在栈顶。 栈的核心操作： 入栈：把元素放到栈里 出栈：把最后进来的元素删掉 取栈顶元素：获取到最后一个进来的元素的结果 使用顺序表实现栈： 使用尾插操作表示入栈；使用尾删操作表示出栈；使用根据下表获取元素的操作表示取栈顶元素 publi..
数据结构：顺序表、单链表、栈和队列的简单总结
热门推荐
Keep Fighting All The Time
06-02 1万+
首先，顺序表、链表、栈和队列都属于线性表，都可以采用两种基本的存储结构：顺序存储结构和链式存储结构来存储。结构中的元素之间存在一对一的线性关系。既然，顺序表、链表、栈和队列都属于线性表，那么有必要简单的谈一谈线性表。 线性结构是最常用、最简单的一种数据结构。而线性表是一种典型的线性结构。其基本特点是线性表中的数据元素是有序且是有限的。在这种结构中：① 存在一个唯一的被称为“第一个...
栈和队列的实现（利用顺序表）
好好的博客
03-20 222
栈的实现class Stack(object): """"栈""" def __init__(self): self.__list = [] def push(self,item): """添加一个新的元素item到栈顶""" self.__list.append(item) def pop(se
顺序表、栈与队列
weixin_34007879的博客
04-29 197
一、顺序表引入 1什么是线性表 1 在程序中，经常需要将一组数据元素作为整体管理和使用，需要创建这种元素组，用变量记录它们，传进传出函数等。 2 一组数据中包含的元素个数可能发生变化（增加或删除元素）。 3 对于这种需求，最简单的解决方案便是将这样一组元素看成一个序列，用元素在序列里的位置和顺序，表示实际应用中 的某种有意义的信息，或者表示数据之间的某种关系。 4 这样的一组序...
链表，顺序表，队列，栈的实现
09-19
本压缩包包含了一系列关于基本数据结构实现的程序，如顺序表、链表、栈和队列，这些都是编程中不可或缺的部分。 首先，顺序表是一种线性数据结构，其中元素在内存中按顺序排列。它的操作相对简单，例如插入和删除...
利用C++简单实现顺序表和单链表的示例代码
08-29
C++实现顺序表和单链表的示例代码 本文将为大家介绍如何使用C++语言实现顺序表和单链表，提供详细的示例代码供大家参考学习。 顺序表的实现 顺序表是一种常用的数据结构，使用数组来存储数据。下面是使用C++语言...
循环队列详解及队列的顺序表示和实现
08-31
在顺序队列中，当队首和队尾指针相遇时，如果数组未满，实际上还有空间，但在逻辑上却表现为队列已满，这称为假溢出。循环队列通过将队列的末尾与开头连接起来，形成一个逻辑上的环形空间，从而避免了这种现象。 ...
C语言实现静态顺序表的实例详解
08-29
C语言实现静态顺序表的实例详解 在计算机科学中，顺序表是一种基本的数据结构，它是由一系列元素组成的有序集合。静态顺序表是一种特殊的顺序表，它在内存中开辟了一段连续的存储空间，并给它一个名字进行标识。...
栈的顺序表的实现
黑桃K
12-18 167
栈的顺序表的实现 # 栈的顺序表的实现 #include<stdio.h> #include<stdio.h> typedef int STDataType; //顺序表结构实现 typedef struct stack { STDataType* _data; int _size; int _capacity; }stack; void stackInit(stack* st) { if (!st)return; st->_data = NULL; st->
顺序栈和顺序队列
Mormont的博客
11-27 1263
1.栈的定义： 栈是限定在表尾进行插入和删除操作的线性表； 把允许插入和删除的一端称为栈顶（top），  另一端称为栈底（bottom）， 不含任何数据元素的栈称为空栈。 栈又称为后进先出的线性表。 栈的插入操作，叫做进栈，也称为压栈，入栈。子弹入弹夹； 栈的删除操作，叫做出栈，也有的叫做弹栈。 （1）顺序栈的进栈操作： /*插入元素e为新的栈顶元素*/  Status Pu
数据结构：线性表（顺序存储）顺序栈类（实现创建，输出，入栈出栈，读栈顶元素功能）
蜗牛之旅
07-26 8503
下面给出顺序栈类代码和应用实例供参考： 顺序栈类：文件名 sq_Stack.h #include using namespace std; template class sq_Stack { private: int mm; //存储空间容量 int top; //栈顶指针 T *s; //顺序栈存储空间首地址 public: sq_Stack(int);
用顺序表实现栈
有没有兴趣和我一起去拯救地球啊
10-27 724
栈是一种有约束的顺式结构，他需要遵循先进后出，后进先出的基本规则，我们可以用顺序表和链表两种方式来实现 因为简单就意味着不容易出错，所以在这里我使用顺序表来实现栈 Stack.h #pragma once #include&lt;Windows.h&gt; #include&lt;assert.h&gt; //对于栈我们可以用顺序表和链表来实现，栈的代码并不难，在此处，为了省事，直接用顺序表来...
顺序表、顺序栈、顺序队列的基本概念
weixin_49307240的博客
09-16 1621
//自定义的数据内容 typedef struct { int a; float b; }DATA; 顺序表 typedef struct { DATA * base; int length; }sqlist; 顺序表创建只需用 base 去 new一个足够的空间 -> sqlist L; L.base = new DATA [MAXSIZE]; 并设初始长度 L.length=0; 顺序表可以随机访问 -> L.base[i
数据结构之顺序表栈
liuyingshudian的博客
09-28 183
好像有点小问题 #include &lt;stdio.h&gt;  #include &lt;malloc.h&gt;     typedef int SElemType;  typedef int Status;  #define INIT_SIZE 100  #define STACKINCREMENT 10  #define Ok 1  #define Error 0  #define T...
顺序表栈C语言实现
weixin_30244681的博客
08-09 116
/* * SeqStack.h * * Created on: 2019年8月1日 * Author: Administrator */ #ifndef SEQSTACK_H_ #define SEQSTACK_H_ //数组去模拟栈的顺序存储， 有数组的后面模拟栈顶 ，避免数据频繁移动 #define MAX_SIZE 1024 #define SEQ_S...
归并排序、用优先队列实现排序
追殇 | Blog
04-16 226
//P1177 【模板】快速排序 归并排序 //在线测评地址https://www.luogu.org/problemnew/lists?name=1177 // #include <stdio.h> #define maxn 100100 int n,a[maxn],b[maxn]; void memory_sort(int left,int mid,int right){//...
顺序表实现栈操作
LuckyFYL的博客
03-25 175

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值