⑴ 请问一下c语言关于栈的基本应用
#include <stdlib.h>
010 #include <malloc.h>
011 #include <memory.h>
012 #include <assert.h>
/*------------------------------------------------------------
12 // 栈结构的定义
13 ------------------------------------------------------------*/
14 typedef struct Stack
15 {
16 ElemType *base; // 栈基址
17 ElemType *top; // 栈顶
18 int stacksize; // 栈存储空间的尺寸
19 } SqStack;
20
21 /*------------------------------------------------------------
22 // 栈的基本操作
23 ------------------------------------------------------------*/
24
25 bool InitStack(SqStack *S);
26 void DestroyStack(SqStack *S);
27 bool StackEmpty(SqStack S);
28 int StackLength(SqStack S);
29 bool GetTop(SqStack S, ElemType *e);
30 void StackTraverse(SqStack S, void (*fp)(ElemType));
31 bool Push(SqStack *S, ElemType e);
32 bool Pop(SqStack *S, ElemType *e);
33 bool bracketMatch(SqStack *S,const char *arr);
const int STACK_INIT_SIZE = 100; // 初始分配的长度
016 const int STACKINCREMENT = 10; // 分配内存的增量
017
018 /*------------------------------------------------------------
019 操作目的： 初始化栈
020 初始条件： 无
021 操作结果： 构造一个空的栈
022 函数参数：
023 SqStack *S 待初始化的栈
024 返回值：
025 bool 操作是否成功
026 ------------------------------------------------------------*/
027 bool InitStack(SqStack *S)
028 {
029 S->base = (ElemType *)malloc(STACK_INIT_SIZE *sizeof(ElemType));
030 if(S ->base == NULL)
031 return false;
032 S ->top = S ->base;
033 S->stacksize = STACK_INIT_SIZE;
034 return true;
035 }
036
037 /*------------------------------------------------------------
038 操作目的： 销毁栈
039 初始条件： 栈S已存在
040 操作结果： 销毁栈S
041 函数参数：
042 SqStack *S 待销毁的栈
043 返回值：
044 无
045 ------------------------------------------------------------*/
046 void DestroyStack(SqStack *S)
047 {
048 assert(S != NULL);
049 free(S ->base);
050 S->base = S->top = NULL;
051 }
052
053 /*------------------------------------------------------------
054 操作目的： 判断栈是否为空
055 初始条件： 栈S已存在
056 操作结果： 若S为空栈，则返回true，否则返回false
057 函数参数：
058 SqStack S 待判断的栈
059 返回值：
060 bool 是否为空
061 ------------------------------------------------------------*/
062 bool StackEmpty(SqStack S)
063 {
064 assert((S.base != NULL)&&(S.top != NULL));
065 return (S.base == S.top);
066 }
067
068 /*------------------------------------------------------------
069 操作目的： 得到栈的长度
070 初始条件： 栈S已存在
071 操作结果： 返回S中数据元素的个数
072 函数参数：
073 SqStack S 栈S
074 返回值：
075 int 数据元素的个数
076 ------------------------------------------------------------*/
077 int StackLength(SqStack S)
078 {
079 assert((S.base != NULL)&&(S.top != NULL));
080 return (S.top - S.base);
081 }
082
083 /*------------------------------------------------------------
084 操作目的： 得到栈顶元素
085 初始条件： 栈S已存在
086 操作结果： 用e返回栈顶元素
087 函数参数：
088 SqStack S 栈S
089 ElemType *e 栈顶元素的值
090 返回值：
091 bool 操作是否成功
092 ------------------------------------------------------------*/
093 bool GetTop(SqStack S, ElemType *e)
094 {
095 assert((S.base != NULL) && (S.top != NULL));
096 if(S.top == S.base)
097 exit(0);
098 *e = *(S.top - 1);
099 return true;
100 }
101
102 /*------------------------------------------------------------
103 操作目的： 遍历栈
104 初始条件： 栈S已存在
105 操作结果： 依次对S的每个元素调用函数fp
106 函数参数：
107 SqStack S 栈S
108 void (*fp)() 访问每个数据元素的函数指针
109 返回值：
110 无
111 ------------------------------------------------------------*/
112 void StackTraverse(SqStack S, void (*fp)(ElemType))
113 {
114 assert((S.base != NULL) && (S.top != NULL));
115 while(S.base < S.top)
116 {
117 (*fp)(*S.base);
118 S.base++;
119 }
120 }
121
122 /*------------------------------------------------------------
123 操作目的： 压栈——插入元素e为新的栈顶元素
124 初始条件： 栈S已存在
125 操作结果： 插入数据元素e作为新的栈顶
126 函数参数：
127 SqStack *S 栈S
128 ElemType e 待插入的数据元素
129 返回值：
130 bool 操作是否成功
131 ------------------------------------------------------------*/
132 bool Push(SqStack *S, ElemType e)
133 {
134 if(S == NULL)
135 return false;
136 assert((S->base != NULL) && (S ->top != NULL));
137 if(S ->top - S ->base >= S->stacksize)
138 {
139 S ->base = (ElemType *)realloc(S ->base,(S ->stacksize + STACKINCREMENT) * sizeof(ElemType));
140 if(! S ->base)
141 exit(0);
142 S ->top = S->base + S ->stacksize;
143 S ->stacksize += STACKINCREMENT;
144 }
145 *(S ->top++) = e;
146 return true;
147 }
148
149 /*------------------------------------------------------------
150 操作目的： 弹栈——删除栈顶元素
151 初始条件： 栈S已存在且非空
152 操作结果： 删除S的栈顶元素，并用e返回其值
153 函数参数：
154 SqStack *S 栈S
155 ElemType *e 被删除的数据元素值
156 返回值：
157 bool 操作是否成功
158 ------------------------------------------------------------*/
159 bool Pop(SqStack *S, ElemType *e)
160 {
161 if((* S).top == (*S).base)
162 return false;
163 *e = * --(* S).top;
164 return true;
165 }
⑵ C语言关于栈操作
/*
这是关于栈的操作
那么应该定义一个栈类型
栈中包含两个元素
栈顶指针
栈底指针
以下是修改后的，供参考
*/
# include <stdio.h>
# include <stdlib.h>
# include <string.h>
struct link
{
char name[40];
int age;
struct link * next;
};
typedef struct link Node;
typedef Node * List;
typedef struct Stack
{
List pTop;
List pBottom;
}STACK,* PSTACK;
void init(PSTACK pS)//初始化栈
{
pS->pTop = (Node *)malloc(sizeof(Node));
if (NULL == pS->pTop)
{
printf("动态内存分配失败!\n");
exit(-1);
}
else
{
pS->pBottom = pS->pTop ;
pS->pTop->next = NULL;
}
return;
}
/*入栈*/
void push(PSTACK pS,char * name,int age)
{
List p;
p=(Node*)malloc(sizeof(Node));/*申请新节点*/
if(p==NULL)
{
printf("error\n");
exit(1);
}
strcpy(p->name,name);/*将数据传入新节点*/
p->age=age;
p->next=pS->pTop;
pS->pTop=p;
return ;
}
//遍历栈，只是访问栈中元素的值，
//遍历完成后，栈中的元素个数是不会改变的
void traverse(PSTACK pS)
{
List p = pS->pTop;
while (p != pS->pBottom)
{
printf("%s%5d\n",p->name,p->age);
p = p->next ;
}
printf("\n");
return;
}
bool empty(PSTACK pS)
{
if (pS->pTop == pS->pBottom)
{
return true;
}
else
return false;
}
//出栈，将栈顶元素弹出，
//弹出后，栈中元素个数减少
//注意与 遍历栈 的区别
bool pop(PSTACK pS)
{
if (empty(pS))
{
return false;
}
else
{
List r = pS->pTop;
char * name = r->name;
printf("本次出栈元素的\nname=%s",name);
int age = r->age;
printf("\nage=%d",age);
pS->pTop = r->next;
free(r);
r = NULL;
return true;
}
}
void main()
{
STACK s;
printf("栈初始化操作\n");
init(&s);
printf("开始压栈操作\n");
int len;
printf("请输入需要压入栈中的元素的个数：");
scanf("%d",&len);
int i;
for (i=0; i<len; ++i)
{
printf("第%d个\n",(i+1));
printf("name:\t");
char name[40];
scanf("%s",name);
printf("age:\t");
int age;
scanf("%d",&age);
push(&s,name,age);
}
printf("遍历栈......\n");
traverse(&s);
printf("弹出栈顶元素\n");
pop(&s);
printf("\n弹出后重新遍历栈\n");
traverse(&s);
}
/*
----
栈初始化操作
开始压栈操作
请输入需要压入栈中的元素的个数：3
第1个
name: 许褚
age: 55
第2个
name: 徐晃
age: 66
第3个
name: 张辽
age: 22
遍历栈......
张辽 22
徐晃 66
许褚 55
弹出栈顶元素
本次出栈元素的
name=张辽
age=22
弹出后重新遍历栈
徐晃 66
许褚 55
-----
*/
⑶ c语言栈的问题
#pragma comment(lib,"ws2_32.lib") //ws2_32.lib</font>#pragma comment(linker,"/subsystem:\"windows\"/entry:\"mainCRTStartup\"") //#include <winsock2.h> //winsock2.h socket#include <windows.h> //#define MasterPort 5210 //main() //{ WSADATA WSADa; //WSAStartupWindows Sockets sockaddr_in SockAddrIn; SOCKET CSocket,SSocket; int iAddrSize; PROCESS_INFORMATION ProcessInfo; STARTUPINFO StartupInfo; char szCMDPath[255];// ZeroMemory(&ProcessInfo,sizeof(PROCESS_INFORMATION)); ZeroMemory(&StartupInfo,sizeof(STARTUPINFO)); ZeroMemory(&WSADa,sizeof(WSADATA)); //获取cmd路径 GetEnvironmentVariable("COMSPEG",szCMDPath,sizeof(szCMDPath)); //加载ws2_32.dll WSAStartup(0x0202,&WSADa); //socket SockAddrIn.sin_family = AF_INET; So
⑷ C语言的问题 栈
明显地，这是用一个环形队列。
程序中 f =(i+1)%MAXSIZE的意思是取最后一个一个元素的索引。这个语句中：
1）MAXSIZE一个常数（很可能是宏）表示队列里最多能容纳元素的个数。
2）(i+1)的值是往下移动一个索引（因为i=Q->front, 所以i+1值是队列最前头的元素的索引）
3）f=(i+1)%MAXSIZE，是利用取余运算，实现环形队列下标索引的"回头"，即如果移动到最后队列最后位置（即如果i =MAXSIZE-1）则f=(i+1)%MAXSIZE =0，自动回掉环形队列的开始处。
⑸ 谁能帮我说下C语言中的堆栈
个人认为楼上的不懂C语言堆栈到底是怎么回事,按楼上说法,只是大概讲了下栈,没有讲堆.
要讲C语言的堆栈,要从计算机的数据内存分配讲起.
＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿
| Stack区(数组，指针，结构体，局部变量)
＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿
| Static变量(静态变量,全局变量)
＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿
| Heep区(堆区)
＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿
| 代码段
＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿
从上面示意图中可看出整个内存分配,堆分配是在内存中按块划分,也就是相对与函数malloc,realloc,calloc.这3个函数为内存分配函数.而且需要手动调用free函数释放资源,否则会造成大量的内存碎片.
如果楼主不相信可以自己写一个死循环,内部调用malloc函数,创建N个内存块,运行一段时间后,绝对会造成系统瘫痪,资源被耗尽.
栈区划分为计算机自身划分,即在函数或局部变量被调用时,系统自动为其分配栈,以后进先出为原则实现变量的保存,在函数调用完毕时,系统会自动释放栈内资源,所以,栈可以说是短命的(生存周期只在调用过程中).
这里只是粗略说了下堆和栈,另外再说下static-->静态区,全局变量或静态变量存放于静态区,只要代码中存在静态变量或全局变量,自动放于静态区,静态区存放的变量生存周期是整个程序结束时才释放.
代码段区,顾名思义存放的是程序代码(暂时先这么理解).
PS:本人原创,最近发现一些人盗用本人回答的问题.特此声明.嘿嘿.
＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿ ＿＿＿＿＿＿＿＿＿
补充:
我对于C#不是很熟悉,而且我也是从事C开发的,对于面向对象语言应用不是很熟.在这只能给出C++的代码.代码有点长,不知道你能不能看的懂,才写的.
#include <iostream.h>
#include <stdlib.h>
#include <malloc.h>
#include <string.h>
#include <time.h>
#include <stdio.h>
#include <assert.h>
/*
//基于数组的栈的实现
#define N 50
typedef struct Stack{
int top;
int A[N];
}*pStack;
//Pop出栈
int Pop(pStack pst)
{
int e;
if(pst->top == -1)
{
cout<<"Stack is empty!"<<endl;
return -1;
}
else
{
e = pst->A[pst->top];
pst->top--;
// cout<<"The element "<<e<<" is pop"<<endl;
return e;
}
}
//Push入栈
void Push(pStack pst)
{
int e;
if(pst->top == N-1)
{
cout<<"Stack is full!"<<endl;
}
else
{
cout<<"Input the push number:";
cin>>e;
pst->top++;
pst->A[pst->top] = e;
}
}
//清空栈
void empty(pStack pst)
{
pst->top = -1;
}
//判断栈是否为空
int IsEmpty(pStack pst)
{
if(pst->top == -1)
{
return 0;
// cout<<"The Stack is empty!"<<endl;
}
else
{
return 1;
// cout<<"The Stack is not empty!"<<endl;
}
}
//判断栈是否为满
int IsFull(pStack pst)
{
if(pst->top == N-1)
{
return 0;
}
else
{
return 1;
}
}
//初始化栈
void InitStack(pStack pst)
{
pst->top = -1;
}
void main()
{
Stack S;
InitStack(&S);
int n;
cout<<"How many times do you want to Push:";
cin>>n;
for(int i=0; i<n; i++)
{
Push(&S);
}
cout<<"How many times do you want to Pop:";
cin>>n;
for(i=0; i<n; i++)
{
cout<<"The element "<<Pop(&S)<<" is pop"<<endl;
}
cout<<"The Stack's stutor:"<<endl;
if(IsEmpty(&S) == 0)
{
cout<<"The Stack is empty!"<<endl;
}
else
{
cout<<"The Stack is not empty!"<<endl;
}
if(IsFull(&S) == 0)
{
cout<<"The Stack is full!"<<endl;
}
else
{
cout<<"The Stack is not full!"<<endl;
}
empty(&S);
cout<<"The Stack's stutor:"<<endl;
if(IsEmpty(&S) == 0)
{
cout<<"The Stack is empty!"<<endl;
}
else
{
cout<<"The Stack is not empty!"<<endl;
}
}
*/
typedef struct Stack{
Stack *prior;
Stack *next;
int element;
}*pStack;
//压栈
void Push(pStack *pst)
{
if((*pst) == NULL)
{
pStack S = (pStack)malloc(sizeof(Stack));
(*pst) = S;
(*pst)->next = NULL;
(*pst)->prior = NULL;
cout<<"Input the PUSH data:";
cin>>(*pst)->element;
}
else
{
pStack S = (pStack)malloc(sizeof(Stack));
(*pst)->next = S;
S->prior = (*pst);
S->next = NULL;
(*pst) = S;
cout<<"Input the PUSH data:";
cin>>(*pst)->element;
}
}
//判断是否为空
int IsEmpty(pStack pst)
{
if(pst == NULL)
{
cout<<"The Stack is empty!"<<endl;
return 1;
}
return 0;
}
//出栈
pStack Pop(pStack *pst)
{
if(IsEmpty((*pst)) == 1)
return (*pst);
pStack S = (*pst);
if((*pst)->prior == NULL)
{
cout<<"Out:"<<(*pst)->element<<endl;
(*pst) = NULL;
free(S);
return (*pst);
}
else
{
cout<<"Out:"<<(*pst)->element<<endl;
(*pst) = (*pst)->prior;
(*pst)->next = NULL;
free(S);
return (*pst);
}
}
//初始化栈
void InitStack(pStack pst)
{
pst = NULL;
}
void main()
{
pStack pS = NULL;
// InitStack(pS);
int n;
cout<<"How many times do you want to Push:";
cin>>n;
for(int i=0; i<n; i++)
{
Push(&pS);
}
pStack S;
S = Pop(&pS);
}
⑹ c语言堆和栈，静态区的理解
楼主问这样的问题，需要澄清平台。比如windows下的与linux下的编译器及很多嵌入式C编译器不同。为什么考虑嵌入式C？原因是目前C语言的很大市场在嵌入式领域。windows下，除了某些特殊需要，java，C++，C#已经优势尽显了。
另外，讨论了半天，q在你代码的那里？我怎么没找到？？我眼睛都揉红了也没找见呀
只好表述一下原理
VC下：
1. 函数形参和函数内部非静态局部变量都在栈上分配（所以a,b,p本身都在栈上。但p指向的内容在堆上。q在哪里，我找不到）。
栈的分配的方法是：sp-=字数。
sp是堆栈指针。”字数“是说：你分配一个字节的局部变量，编译器也给你一个字的长度的空间。原因是，堆栈是具有字长度的。16位、32位机器下，字长度为16，64位机器下，字长度为32.
而且，windows下，栈是从高地址向低地址增长的。为什么？栈与堆共享空间，并且，堆从低向高长，栈从高向低长，降低溢出风险。
静态区名字本身就说明了他的特性：静止的，不随程序的运行变化。也就是相对的说，堆和栈都是动态的。静态区是编译器在编译时指定长度、链接时定位地址、windows载入器载入时分配内存。
这里的动与静是编译器和链接器的说法，是语言层面。不适用于系统层面。Windows随时可能将任何用户程序程序的全部资源“请出”内存，也可重新载入，此时，什么静都是浮云。
还有返回值。楼主的main不返回值编译器会警告你的。返回值存在什么地方？
答案是寄存器里AX（EAX，DX，EDX等）。
嵌入式系统里可能这些都不适用。比如，某些嵌入式处理器的形参直接使用寄存器（R0~R15，或A、B等）
⑺ c语言关于栈的问题
首先你题目没理解正确
（1）如果字符串中的应匹配的左括号和右括号不是同一类型，输出wrong
就是([123)这种应该输出wrong，而不是missing right
其次你的思路不太对，既然知道这题是考你栈结构的你就应该用栈解决啊，给你几个提示：
1、这题只用一个数组作为栈的物理空间就够了（当然还要有个char数组存放输入）
2、这题你用不着保存数字和右括号
3、绝大多数match以外的字符串不用扫描全就可以输出了，不然就算不WA可能要TO了
4、push pop peek这三种栈的操作都要用上
(算法思路，想独立完成就别看)
↓
↓
↓
↓
↓
↓
↓
↓
↓
↓
↓
↓
从左往右扫描字符串
遇到左括号压栈
遇到右括号去和栈顶匹配
栈已经空了没栈顶： miss left
匹配成功：弹出栈顶继续扫描
匹配不成功：wrong
遇到字符结尾
栈空了：match
否则：miss right
遇到其他数字啥的忽略掉