The stack has three implementation methods. The implementation methods are: 1. Static array stack, which requires a fixed length of the structure, and the length must be determined at compile time; 2. Dynamic array stack, the length can be determined at runtime. Determine and change the length of the original array; 3. Chain structure stack, no length online, apply for allocation of memory space when needed.
There are 3 ways to implement the stack. The implementation methods are:
1. Static array stack
In a static array stack, STACK_SIZE represents the maximum value of the elements that the stack can store, and top_element is used as the array subscript to represent the elements in the stack. , when top_element == -1, it means the stack is empty; when top_element == STACK_SIZE - 1, it means the stack is full. When pushing, top_element increases by 1. When top_element == 0, it represents the first stack element; when popping, top_element decreases by 1.
a_stack.c source code is as follows:
[cpp] view plain copy
/*
**
** 静态数组实现堆栈程序 a_stack.c ，数组长度由#define确定
*/
#include"stack.h"
#include<assert.h>
#include<stdio.h>
#define STACK_SIZE 100 /* 堆栈最大容纳元素数量 */
/*
** 存储堆栈中的数组和一个指向堆栈顶部元素的指针
*/
static STACK_TYPE stack[STACK_SIZE];
static int top_element = -1;
/* push */
void push(STACK_TYPE value)
{
assert(!is_full()); /* 压入堆栈之前先判断是否堆栈已满*/
top_element += 1;
stack[top_element] = value;
}
/* pop */
void pop(void)
{
assert(!is_empty()); /* 弹出堆栈之前先判断是否堆栈已空 */
top_element -= 1;
}
/* top */
STACK_TYPE top(void)
{
assert(!is_empty());
return stack[top_element];
}
/* is_empty */
int is_empty(void)
{
return top_element == -1;
}
/* is_full */
int is_full(void)
{
return top_element == STACK_SIZE - 1;
}
/*
** 定义一个print函数，用来打印堆栈里面的元素。
*/
void print(void)
{
int i;
i = top_element;
printf("打印出静态数组堆栈里面的值: ");
if(i == -1)
printf("这是个空堆栈\n");
while(i!= -1)
printf("%d ",stack[i--]);
printf("\n");
}
int main(void)
{
print();
push(10); push(9); push(7); push(6); push(5);
push(4); push(3); push(2); push(1); push(0);
printf("push压入数值后：\n");
print();
printf("\n");
pop();
pop();
printf("经过pop弹出几个元素后的堆栈元素:\n");
print();
printf("\n");
printf("top()调用出来的值: %d\n",top());
return 1;
}The result is as shown below:
## 2. Dynamic array stack
The header file still usesstack.h. There are not many changes. The stack_size variable is added instead of STACK_SIZE to save the length of the stack. The array is replaced by a pointer, which defaults to 0 under global variables.
create_stackThe function first checks whether the stack has been created, then allocates the required amount of memory and checks whether the allocation is successful. destroy_stackThe function first checks whether the stack exists, and resets the length and pointer variables to zero after the memory has been released. An assertion has been added to the is_empty and is_full functions to prevent any stack function from being called before the stack is created.
d_stack.cThe source code is as follows:
[cpp] view plain copy
/*
** 动态分配数组实现的堆栈程序 d_stack.c
** 堆栈的长度在创建堆栈的函数被调用时候给出，该函数必须在任何其他操作堆栈的函数被调用之前条用。
*/
#include"stack.h"
#include<stdio.h>
#include<malloc.h>
#include<assert.h>
/*
** 用于存储堆栈元素的数组和指向堆栈顶部元素的指针
*/
static STACK_TYPE *stack;
static int stack_size;
static int top_element = -1;
/* create_stack */
void create_stack(size_t size)
{
assert(stack_size == 0);
stack_size = size;
stack = (STACK_TYPE *)malloc(stack_size * sizeof(STACK_TYPE));
if(stack == NULL)
perror("malloc分配失败");
}
/* destroy */
void destroy_stack(void)
{
assert(stack_size > 0);
stack_size = 0;
free(stack);
stack = NULL;
}
/* push */
void push(STACK_TYPE value)
{
assert(!is_full());
top_element += 1;
stack[top_element] = value;
}
/* pop */
void pop(void)
{
assert(!is_empty());
top_element -= 1;
}
/* top */
STACK_TYPE top(void)
{
assert(!is_empty());
return stack[top_element];
}
/* is_empty */
int is_empty(void)
{
assert(stack_size > 0);
return top_element == -1;
}
/* is_full */
int is_full(void)
{
assert(stack_size > 0);
return top_element == stack_size - 1;
}
/*
** 定义一个print函数，用来打印堆栈里面的元素。
*/
void print(void)
{
int i;
i = top_element;
printf("打印出动态数组堆栈里面的值: ");
if(i == -1)
printf("这是个空堆栈\n");
while(i!= -1)
printf("%d ",stack[i--]);
printf("\n");
}
int main(void)
{
create_stack(50);
print();
push(10); push(9); push(7); push(6); push(5);
push(4); push(3); push(2); push(1); push(0);
printf("push压入数值后：\n");
print();
printf("\n");
pop();
pop();
printf("经过pop弹出几个元素后的堆栈元素:\n");
print();
printf("\n");
printf("top()调用出来的值: %d\n",top());
destroy_stack();
return 1;
}
3. Chain Type stack
Since only the top element of the stack can be accessed, a linked stack can be implemented well using a singly linked list, and there is no length limit. Pushing an element onto the stack is accomplished by adding an element to the head of the linked list. Popping an element is achieved by deleting the first element at the head of the linked list. Since there is no length limit, there is no need for thecreate_stack function, and destroy_stack is needed to release the memory to avoid memory leaks.
stack.h remains unchanged, l_stack.c source code is as follows:
[cpp] view plain copy
/*
** 单链表实现堆栈，没有长度限制
*/
#include"stack.h"
#include<stdio.h>
#include<malloc.h>
#include<assert.h>
#define FALSE 0
/*
** 定义一个结构以存储堆栈元素。
*/
typedef struct STACK_NODE
{
STACK_TYPE value;
struct STACK_NODE *next;
} StackNode;
/* 指向堆栈中第一个节点的指针 */
static StackNode *stack;
/* create_stack */
void create_stack(size_t size)
{}
/* destroy_stack */
void destroy_stack(void)
{
while(!is_empty())
pop(); /* 逐个弹出元素，逐个释放节点内存 */
}
/* push */
void push(STACK_TYPE value)
{
StackNode *new_node;
new_node = (StackNode *)malloc(sizeof(StackNode));
if(new_node == NULL)
perror("malloc fail");
new_node->value = value;
new_node->next = stack; /* 新元素插入链表头部 */
stack = new_node; /* stack 重新指向链表头部 */
}
/* pop */
void pop(void)
{
StackNode *first_node;
assert(!is_empty());
first_node = stack;
stack = first_node->next;
free(first_node);
}
/* top */
STACK_TYPE top(void)
{
assert(!is_empty());
return stack->value;
}
/* is_empty */
int is_empty(void)
{
return stack == NULL;
}
/* is_full */
int is_full(void)
{
return FALSE;
}
/*
** 定义一个print函数，用来打印堆栈里面的元素。
*/
void print(void)
{
StackNode *p_node;
p_node = stack;
printf("打印出链式堆栈里面的值: ");
if(p_node == NULL)
printf("堆栈为空\n");
while(p_node != NULL)
{
printf("%d ", p_node->value);
p_node = p_node->next;
}
printf("\n");
}
int main(void)
{
print();
push(10); push(9); push(7); push(6); push(5);
push(4); push(3); push(2); push(1); push(0);
printf("push压入数值后：\n");
print();
printf("\n");
pop();
pop();
printf("经过pop弹出几个元素后的堆栈元素:\n");
print();
printf("\n");
printf("top()调用出来的值: %d\n",top());
destroy_stack();
return 1;
}
java video tutorial"
The above is the detailed content of How many ways can a stack be implemented?. For more information, please follow other related articles on the PHP Chinese website!
![[Web front-end] Node.js quick start](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
