程序员在旅途

用这生命中的每一秒，给自己一个不后悔的未来！

0%

以数制转换问题讲解栈数据结构的基本概念及其在计算机中的应用

发表于 更新于 分类于 Valine：
本文字数： 9.2k 阅读时长 ≈ 8 分钟

一、栈的概念介绍

　　在我们的生活中，总有这么一些例子，①食堂在堆放餐盘的时候，总是从下往上，在取餐盘的时候，又是从上往下；②最先放入厢式货车的货物，最后才能取出；③普通手枪的子弹夹，先装进弹夹的子弹，最后才会被打出来。类似于这样的场景还有很多，这样的存取顺序，我们称之为先进后出（LIFO）。这种存取方式在解决某些计算机问题的时候非常高效，因此，在计算机科学中抽象出了一种数据结构，专门用于解决后进先出这类科学问题，在计算机中，这种后进先出的数据结构，我们称之为 栈。栈这种数据结构被抽想出来以后，就被广泛的应用于计算机软硬件系统中，在编译系统、操作系统等系统软件和各类应用软件中经常使用栈来高效的完成特定的算法设计。在许多程序语言设计中，函数的调用，就会使用栈来保存形参以及函数的返回值。在硬件层面，有专门的栈寄存器来配合栈数据结构的高效访问。
　　栈的逻辑结构是一种线性结构，和线性表相同，元素之间是一对一的关系，由于需要保证元素的后进先出规则，因此需要对线性表的运算操作进行一定的限制，即只允许在线性表的一端进行插入和删除来满足栈的要求。因此可以认为栈是限制在表的一端进行插入和删除的线性表。在线性表中允许插入、删除的这一端称为栈顶，栈顶的位置是动态变化的；不允许操作的这一端称为栈底，栈底是固定不变的。当表中没有元素时称为空栈。
　　对于栈而言，常用的操作有：①栈的初始化； ②判断栈是否为空；③入栈；④出栈；⑤取栈顶元素；⑥销毁栈。这些基本的操作是组成复杂程序的基础。栈的示意图如下：栈示意图
　　栈的物理实现有两种方式，分别为顺序存储方式 和 链式存储方式。采用顺序存储的栈我们称之为顺序栈，采用链式存储结构的栈称之为链式栈。

二、顺序栈的操作实现

　　和顺序表的定义实现一样，顺序栈的实现，要分配一块连续的存储空间存放栈中的内容，可以用一维数组来实现，同时定义一个top变量指明当前栈顶的位置。类型描述如下：

#define MAXSIZE 50
typedef struct{
　　ElementType　data[MAXSIZE];
　　int　top;
}SeqStack,*PSeqStack;

　　定义一个指向栈的指针：

1
PSeqStack　p　=　(PSeqStack)malloc(sizeof(SeqStack));

　　由于顺序栈的数据域是静态分配的存储空间，而栈的操作又是一个动态的过程，因此，在入栈的时候，可能出现栈中元素的个数超过栈的最大空间大小，这时候就产生栈的溢出现象，这称之为上溢。在出栈的时候，可能全部元素都出去了，再也没有元素可以出栈了，这也是栈的溢出现象，称之为下溢。在栈的操作实现过程中，要注意溢出的检测。

2.1初始化顺序栈

　　顺序栈的初始化，就是构造一个空栈，然后返回一个指向顺序表的指针。做法是使用malloc()分配栈这种结构体的存储空间，然后，将栈中top置为-1，标识空栈。代码如下：

PSeqStack init_seqstack(){
　　//给栈分配内存空间
　　PSeqStack  p = (PSeqStack)malloc(sizeof(SeqStack));
　　if(p){
　　　　p->top = -1; //top=-1代表空栈；
　　}
　　return p;
}

2.2判断栈是否为空

　　判断栈中是否有元素，只要判断top是否等于-1即可。（要注意判断p是为非NULL）

int empty_seqstack(PSeqStack p){
　　if(p){
　　　　if(p->top == -1){
　　　　　　return 1; //1代表空栈
　　　　}else{
　　　　　　return 0; //0代表非空栈
　　　　}
　　}else{
　　　　return 1; //1代表空栈
　　}
}

2.3入栈

　　入栈是在栈的顶部插入元素，由于是逐渐递加的，因此，不需要移动元素。首先判断栈是否已满，若满了，则退出；由于栈的top指向栈顶，只要将入栈元素赋到top+1的位置。同时执行top++即可。

int push_seqstack(PSeqStack p, ElementType x){
　　//栈满则退出
　　if(p->top == MAXSIZE - 1){
　　　　return 0
　　}else{
　　　　//给栈顶元素赋值
　　　　p->top ++;
　　　　p->data[p->top] = x;
　　　　return 1;
　　}
}

2.4出栈

　　出栈也是在栈的顶部进行元素的删除操作，也是无需移动元素，只要改变top的指向即可，然后把出栈的那个元素返回。思路是：首先判断栈是否为空，若空则退出；否则由于栈的top指向栈顶，只要修改top为top-1即可。

int pop_seqstack(PSeqStack p, ElementType *x){//传进来的是一个指针变量，这个起到保存出栈的数据的目的。
　　if(empty_seqstack(p)){  //栈为空，则无法出栈
　　　　return 0;
　　}
　　*x = p->data[p->top]; //将栈顶元素赋给*x；
　　p->top –;
　　return 1;
}

2.5取栈顶元素

　　取栈顶元素就是取栈的top变量指向的元素。思路是：首先判断栈是否为空，若空则退出；否则由于栈的top指向栈顶，返回top所指单元的值即可，栈本身不发生变化。

int getTop_seqstack(PSeqStack p, ElementType *x){
　　if(empty_seqstack(p)){  //栈为空，则无法取值
　　　　return 0;
　　}
　　*x = p->data[p->top];
　　return 1;
}

2.6销毁栈

　　栈被初始化之后就在内存中分配了一块连续的存储空间，因此，如果在使用完之后，必须要将其销毁，释放其占用的空间。

void destory_seqstack(PSeqStack *p){ //注意，这里传入的是*p；是为了释放p指向的地址空间。
　　if(*p){
　　　　free(*p);
　　}
　　*p = NULL;
　　return ;
}

三、链式栈的操作实现

　　栈的链式存储结构一般用单链表表示，节点结构与单链表的结构相同，由于栈只是栈顶在做插入和删除操作，所以栈顶应该放在单链表的头部。由于不需要为了各个节点的统一操作增加一个头节点，所以栈使用的链表是没有头结点的。链表的节点结构如下：

typedef struct node{
　　ElementType  data;
　　struct node  *next;
}StackNode,*PStackNode;

　　放了方便操作，同时强调栈顶是栈的一个属性，我们可以定义如下的栈的结构：

typedef struct{
　　PStackNode top;
}LinkStack,*PLinkStack;

　　定义一个指向栈的指针：

1
PLinkStack p = (PLinkStack)malloc(sizeof(LinkStack));

　　要注意的是：对于链栈来说，基本不存在栈满的情况，除非内存已经没有使用空间了。对于空栈来说，链表原来的定义是头指针指向空，那么链栈的空其实就是top＝NULL。

3.1初始化空栈

　　栈在使用之前，要进行初始化，申请栈顶节点需要的内存空间。注意，这里申请的是栈结构LinkStack需要的内存空间，而不是节点结构StackNode的节点空间。入栈的时候，申请的是StackNode节点空间。top的值类型是StackNode。

PLinkStack init_linkstack(){
　　PLinkStack p = (PLinkStack)malloc(sizeof(LinkStack));  //初始化链栈，申请top节点的内存空间
　　if(p){
　　　　p->top = NULL;
　　}
　　return p;
}

3.2判断空栈

　　在出栈，取栈顶元素之前，首先得要判断栈是否为空，如为空，则不取。

//判断空栈;1表示空栈，0表示非空栈
int empty_linkstack(PLinkStack p){
　　if(p){
　　　　return (p->top ==  NULL);
　　}
　　return 1;
}

3.3入栈

　　和顺序栈一样，入栈的概念都是在栈顶插入元素。申请StackNode节点空间，赋给top。

//入栈。1入栈成功，0入栈失败
int push_linkstack(PLinkStack p, ElementType x){
　　PStackNode temp_stacknode = (PStackNode)malloc(sizeof(StackNode));
　　if(temp_stacknode){
　　　　//这里是入栈的核心操作，将最新申请的节点赋给top。
　　　　temp_stacknode->data = x;
　　　　temp_stacknode->next = p->top;
　　　　p->top = temp_stacknode;
　　　　return 1;
　　}else{
　　　　printf(“内存空间不足，申请失败\n”);
　　　　return 0;
　　}
}

3.4出栈

　　出栈就是弹出栈顶元素，然后修改top的值。

//出栈。0出栈失败1出栈成功
int pop_linkstack(PLinkStack p, ElementType *x){
　　if(empty_linkstack(p)){
　　　　printf(“栈空，不能出栈”);
　　　　return 0;
　　}{
　　　　//取栈顶元素，然后将这个top指向的节点free掉。
　　　　*x = p->top->data;
　　　　PStackNode x = p->top;
　　　　p->top = p->top->next;
　　　　free(x);
　　　　return 1;
　　}
}

3.5取栈顶元素

//取栈顶元素
int getTop_linkstack(PLinkStack p, ElementType *x){
　　if(empty_linkstack(p)){
　　　　printf(“栈空”);
　　　　return 0;
　　}{
　　　　//取栈顶元素，然后将这个top指向的节点free掉。
　　　　*x = p->top->data;
　　　　return 1;
　　}
}

3.6销毁栈

　　和顺序栈一样，栈结构使用完之后，都要进行销毁，以释放其占用的内存空间。

//销毁栈
void destory_linkstack(PLinkStack *p){
　　if(*p){
　　　　PStackNode x,s;
　　　　x = (*p)->top;
　　　　//遍历栈，然后将其每一个节点都给释放掉。
　　　　while(x){
　　　　　　s = x;
　　　　　　x = x->next;
　　　　　　free(s);
　　　　}
　　　　free(*p);
　　}
　　*p = NULL;
}

四、栈的典型应用实例 — 数制转换问题。

　　在学习计算机组成原理的时候，会经常的处理各种数制之间进行转换的问题，而辗转相除法就是我们最经常用的一种方法。辗转相除法即是欧几里得算法，主要用于计算两个正整数a，b的最大公约数，应用领域有数学和计算机两个方面，拓展应用领域很广泛，辗转相除法在处理数制转换问题上非常有效，算法效率也很高。
　　将十进制数N转换成r进制的数，采用辗转相除法示意图如下：以N= 1234，r=8为例进行转换 。
栈示意图
　　从上图看，余数由低位向高位依次产生，而八进制数则是从高位到低位输出，具备后进先出的特性，因此恰好可以使用栈来保存这个结果。思路就是将N%r的结果依次入栈，待到N/r=0的时候算法结束，依次出栈即可。程序如下：

4.1顺序栈算法

int numerical_conversition(int n, int r){
　　PSeqStack p;
　　ElementType x;
　　if(!r){
　　　　printf(“基数不能为0\n”);
　　　　return 0;
　　}
　　p = init_seqstack();
　　if(!p){
　　　　printf(“栈初始化失败\n”);
　　　　return 0;
　　}
　　while(n){
　　　　//余数依次入栈
　　　　push_seqstack(p,n%r);
　　　　n = n / r;
　　}
　　while(!empty_seqstack(p)){
　　　　//依次出栈
　　　　pop_seqstack(p,&x);
　　　　printf(“%d “,x);
　　}
　　printf(“\n”);
　　destory_seqstack(&p);
　　return 1;
} 

4.2 链式栈算法

int numerical_conversition(int n, int r){
　　PLinkStack p;
　　ElementType x;
　　if(!r){
　　　　printf(“基数不能为0\n”);
　　　　return 0;
　　}
　　p = init_linkstack();
　　if(!p){
　　　　printf(“栈初始化失败\n”);
　　　　return 0;
　　}
　　while(n){
　　　　//余数依次入栈
　　　　push_linkstack(p,n%r);
　　　　n = n / r;
　　}
　　while(!empty_linkstack(p)){
　　　　//依次出栈
　　　　pop_linkstack(p,&x);
　　　　printf(“%d “,x);
　　}
　　printf(“\n”);
　　destory_linkstack(&p);
　　return 1;
}

　　完整程序如下：
　　①链式栈

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
  #include<stdio.h>
#include<stdlib.h>
typedef int ElementType;
 
typedef struct node{
	ElementType  data;
    struct node  *next;
}StackNode,*PStackNode;
 
typedef struct{
	PStackNode top;
}LinkStack,*PLinkStack;
 
 
//初始化空栈
PLinkStack init_linkstack(){
 
	PLinkStack p = (PLinkStack)malloc(sizeof(LinkStack));  //初始化链栈，申请top节点的内存空间
	if(p){
 
		p->top = NULL;
	}
	return p;
}
 
//判断空栈;1表示空栈，0表示非空栈
int empty_linkstack(PLinkStack p){
	if(p){
 
	     return (p->top ==  NULL);
	}
 
	return 1;
}
//入栈。1入站成功，0入栈失败
int push_linkstack(PLinkStack p, ElementType x){
	PStackNode temp_stacknode = (PStackNode)malloc(sizeof(StackNode));
 
	if(temp_stacknode){
		//这里是入栈的核心操作，将最新申请的节点赋给top。
		temp_stacknode->data = x;
		temp_stacknode->next = p->top;
		p->top = temp_stacknode;
		return 1;
 
	}else{
 
		printf("内存空间不足，申请失败\n");
		return 0;
	}
}
//出栈.0出栈失败1出栈成功
int pop_linkstack(PLinkStack p, ElementType *x){
	if(empty_linkstack(p)){
 
		printf("栈空，不能出栈");
		return 0;
	}{
		//取栈顶元素，然后将这个top指向的节点free掉。
		*x = p->top->data;
		PStackNode x = p->top;
		p->top = p->top->next;
		free(x);
 
		return 1;
	}
}
//取栈顶元素
int getTop_linkstack(PLinkStack p, ElementType *x){
	if(empty_linkstack(p)){
		printf("栈空");
		return 0;
	}{
		//取栈顶元素，然后将这个top指向的节点free掉。
		*x = p->top->data;
		return 1;
	}
}
//销毁栈
void destory_linkstack(PLinkStack *p){
	if(*p){
 
		PStackNode x,s;
		x = (*p)->top;
		//遍历栈，然后将其每一个节点都给释放掉。
		while(x){
			s = x;
			x = x->next;
			free(s);
		}
 
		free(*p);
	}
 
	*p = NULL;
}
 
int numerical_conversition(int n, int r){
 
	PLinkStack p;
	ElementType x;
 
	if(!r){
		printf("基数不能为0\n");
		return 0;
	}
 
	p = init_linkstack();
	if(!p){
		printf("栈初始化失败\n");
		return 0;
	}
 
	while(n){
		//余数依次入栈
		push_linkstack(p,n%r);
		n = n / r;
	}
 
	while(!empty_linkstack(p)){
		//依次出栈
		pop_linkstack(p,&x);
		printf("%d ",x);
	}
 
	printf("\n");
	destory_linkstack(&p);
 
	return 1;
}
 
int main(){
 
	numerical_conversition(1234,8);
 
	return 0;
}

　　②顺序栈
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
  #include<stdio.h>
#include<stdlib.h>
 
#define MAXSIZE 100
 
typedef int ElementType;
 
typedef struct{
 
      ElementType data[MAXSIZE];
      int top;
 
}SeqStack,*PSeqStack;
 
 
//初始化栈
PSeqStack init_seqstack(){
 
	//给栈分配内存空间
	PSeqStack  p = (PSeqStack)malloc(sizeof(SeqStack));
 
	if(p){
 
		p->top = -1;
	}
 
	return p;
}
 
int empty_seqstack(PSeqStack p){
	if(p){
 
			if(p->top == -1){
 
				return 1; //1代表空栈
			}else{
 
				return 0; //0代表非空栈
			}
	}else{
 
		return 1; //1代表空栈
	}
}
 
//入栈
int push_seqstack(PSeqStack p, ElementType x){
	//栈满则退出
	if(p->top == MAXSIZE - 1){
		
		return 0;
	}else{
 
		//给栈顶元素赋值
		p->top ++;
		p->data[p->top] = x;
		
		return 1;
	}
}
 
//弹出栈
int pop_seqstack(PSeqStack p, ElementType *x){//传进来的是一个指针变量，这个起到保存出栈的数据的目的。
 
	if(empty_seqstack(p)){  //栈为空，则无法出栈
		return 0;
	}
 
	*x = p->data[p->top]; //将栈顶元素赋给*x；
	p->top --;
 
	return 1;
}
 
//获取栈顶元素
int getTop_seqstack(PSeqStack p, ElementType *x){
	
	if(empty_seqstack(p)){  //栈为空，则无法取值
		return 0;
	}
 
	*x = p->data[p->top];
	return 1;
}
 
//销毁栈
void destory_seqstack(PSeqStack *p){ //注意，这里传入的是*p；是为了释放p指向的地址空间。
 
	if(*p){
		free(*p);
	}
 
	*p = NULL;
	return ;
}
 
int numerical_conversition(int n, int r){
	PSeqStack p;
	ElementType x;
	if(!r){
		printf("基数不能为0\n");
		return 0;
	}
	p = init_seqstack();
	if(!p){
		printf("栈初始化失败\n");
		return 0;
	}
	while(n){
		//余数依次入栈
		push_seqstack(p,n%r);
		n = n / r;
	}
	while(!empty_seqstack(p)){
		//依次出栈
		pop_seqstack(p,&x);
		printf("%d ",x);
	}
	printf("\n");
	destory_seqstack(&p);
	return 1;
}
 
int main(){
 
     numerical_conversition(1234,8);
 
	return 0;
 
}

相关文章推荐