本文目录一览:
- 1、(50分 高手进)汉诺塔问题的堆栈算法(c语言))
- 2、c语言,我想学习堆栈,先进后出的规则我懂,我想知道具体过程,可以举个例子最好,谢谢
- 3、谁能帮我说下C语言中的堆栈
- 4、C程序中如何使用堆栈
- 5、C语言问题,利用堆栈实现四则运算,谢谢高手帮我编写出来
(50分 高手进)汉诺塔问题的堆栈算法(c语言))
汉诺塔问题的非递归非堆栈算法(一)
#i nclude iostream.h
#i nclude math.h
#define maxno 10000
int step_d,step_s,no;//定义将要行进的步数
void main()
{
cout"请输入数字(1-64):";
cinno;//获取实际的塔片数
//初始化
int **p=new int*[3];
p[0]=new int[no+1];
p[1]=new int[no+1];
p[2]=new int[no+1];
p[0][0]=maxno;p[1][0]=maxno;p[2][0]=maxno;
for(int count=1;count=no;count++)
{
p[0][count]=no-count+1;
p[1][count]=0;
p[2][count]=0;
}
//初始化完毕
if(fmod(no,2)){step_s=2;step_d=1;}else {step_s=1;step_d=2;}//判断奇数盘的步数和偶数盘的步数
int from,to;
from=0;
to=step_s+from;
p[0]=p[0][no];
while(*(p[0]) != *(p[1]))
{
cout"从柱:"from+1" 到柱: "to+1endl;
*(++p[to])=*(p[from]);
*(p[from]--)=0;
//以下求得下一步将要From移动的柱子
switch(to)
{
case 2:
if(*(p[0]) *(p[1]))from=0;else from=1;
break;
case 1:
if(*(p[0]) *(p[2]))from=0;else from=2;
break;
case 0:
if(*(p[2]) *(p[1]))from=2;else from=1;
break;
}
//以下一行求得下一步将要移动到的柱子
if(fmod(*(p[from]),2))to=fmod(from+step_s,3);else to=fmod(from+step_d,3);
}
char c;
cinc;
}
汉诺塔问题的非递归非堆栈算法(二)
前一种方法的/*原理:
如果把三个柱子围成一个环,盘子总数为N,其移动的规律是:
如果N为偶数:奇数号盘每次2步;偶数号盘每次1步;
如果N为奇数:奇数号盘每次1步;偶数号盘每次2步;
至于下一步该移动哪个柱子上的盘子,通过大小和顺序即可判断。
以上可以通过数学证明,不赘述!
*/
以下是第二种算法:
#i nclude iostream.h
#i nclude math.h
void main(){
int tt = 1,ff=1,fff=1,t;
cout"请输入(1-64):";
cin t;
cout"F:表示盘子的起始柱子既From的意思"endl;
cout"T:表示盘子的目标柱子既To的意思"endl;
cout"o:表示在这一步中没有用到的柱子"endlendl;
for(int i1=1;i1=t;i1++,ff*=2 );
char **hand;
hand=new char*[ff + 1];
for(int i2=0;i2ff+1;i2++) hand[i2] = new char[4];
//char **hand=new char[ff + 1][ 4];
hand[0][1] = ''O'';
hand[0][2] = ''O'';
hand[0][3] = ''O'';
hand[1][1] = ''F'';
hand[1][2] = ''o'';
hand[1][3] = ''T'';
for(int i = 2;i= t;i++){
tt ++;
if(fmod(i,2) == 0){
hand[tt][ 1] = ''F'';
hand[tt][ 2] = ''T'';
hand[tt][ 3] = ''o'';
}
else{
hand[tt][ 1] = ''F'';
hand[tt][ 3] = ''T'';
hand[tt][ 2] = ''o'';
}
fff=1;
for(int h=1;h=i-1;h++,fff*=2);
for(int ii = 1;ii= fff - 1;ii++)
{tt ++;
if(fmod(i, 2)== 0){
hand[tt][ 1] = hand[ii][ 2];
hand[tt][ 2] = hand[ii][ 3];
hand[tt][ 3] = hand[ii][ 1];}
else{
hand[tt][ 1] = hand[ii][ 3];
hand[tt][ 2] = hand[ii][ 1];
hand[tt][ 3] = hand[ii][ 2];
}
}
}
if(fmod(t, 2) == 0){//调换位置
for(int i = 1;i=tt;i++){
hand[i][ 0] = hand[i][ 2];
hand[i][ 2] = hand[i][ 3];
hand[i][ 3] = hand[i][ 0];}
}
for(int u=1;uff;u++ )
coutu": "hand[u][1]" "hand[u][2]" "hand[u][3]" "endl;
cinfff;
}
}
c语言,我想学习堆栈,先进后出的规则我懂,我想知道具体过程,可以举个例子最好,谢谢
下面是一个栈的例子:
#include stdio.h
#define STACK_SIZE 100
class Stack {
private:
int *buf;
int top;
public:
Stack(){
buf = new int[STACK_SIZE];
top = 0;
}
void push(int val) {
buf[top++] = val;
}
bool isEmpty() {
return top == 0;
}
int pop() {
if(!isEmpty() ) {
top --;
return buf[top];
}
printf("The STACK is empty now...");
return -1;
}
~Stack() {
delete buf;
}
};
int main()
{
Stack stack;
int a[5] = {2, 4, 5, 1, 7};
for(int i=0; i5; i++)
stack.push(a[i]);
while(! stack.isEmpty() ) {
printf("%d ", stack.pop());
}
printf("\n");
}
谁能帮我说下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:";
cine;
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:";
cinn;
for(int i=0; in; i++)
{
Push(S);
}
cout"How many times do you want to Pop:";
cinn;
for(i=0; in; 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)-elementendl;
(*pst) = NULL;
free(S);
return (*pst);
}
else
{
cout"Out:"(*pst)-elementendl;
(*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:";
cinn;
for(int i=0; in; i++)
{
Push(pS);
}
pStack S;
S = Pop(pS);
}
C程序中如何使用堆栈
先从大家比较熟悉的栈说起,它是一种具有后进先出性质的数据结构,也就是说后存放的先取,先存放的后取。这就如同要取出放在箱子里面底下的东西(放入的比较早的物体),首先要移开压在它上面的物体(放入的比较晚的物体)。而堆就不同了,堆是一种经过排序的树形数据结构,每个结点都有一个值。通常所说的堆的数据结构,是指二叉堆。堆的特点是根结点的值最小(或最大),且根结点的两个子树也是一个堆。由于堆的这个特性,常用来实现优先队列,堆的存取是随意,这就如同在图书馆的书架上取书,虽然书的摆放是有顺序的,但是想取任意一本时不必像栈一样,先取出前面所有的书,书架这种机制不同于箱子,可以直接取出想要的书。
下面就说说C语言程序内存分配中的堆和栈,这里有必要把内存分配也提一下,一般情况下程序存放在Rom或Flash中,运行时需要拷到内存中执行,内存会分别存储不同的信息。
内存中的栈区处于相对较高的地址以地址的增长方向为上的话,栈地址是向下增长的,栈中分配局部变量空间,堆区是向上增长的用于分配程序员申请的内存空间。另外还有静态区是分配静态变量,全局变量空间的;只读区是分配常量和程序代码空间的;以及其他一些分区。来看一个网上很流行的经典例子:
main.cpp
int a = 0; 全局初始化区
char *p1; 全局未初始化区
main()
{
int b; 栈
char s[] = "abc"; 栈
char *p2; 栈
char *p3 = "123456"; 123456\0在常量区,p3在栈上。
static int c =0; 全局(静态)初始化区
p1 = (char *)malloc(10); 堆
p2 = (char *)malloc(20); 堆
}
堆和栈的第一个区别就是申请方式不同:栈(英文名称是stack)是系统自动分配空间的,例如定义一个 char a;系统会自动在栈上为其开辟空间。而堆(英文名称是heap)则是程序员根据需要自己申请的空间,例如malloc(10);开辟十个字节的空间。由于栈上的空间是自动分配自动回收的,所以栈上的数据的生存周期只是在函数的运行过程中,运行后就释放掉,不可以再访问。而堆上的数据只要程序员不释放空间,就一直可以访问到,不过缺点是一旦忘记释放会造成内存泄露。
C语言问题,利用堆栈实现四则运算,谢谢高手帮我编写出来
我就喜欢害人:)
#includestdio.h
#includeconio.h
#includestdlib.h
#defineERR-1
#defineMAX100/*定义堆栈的大小*/
intstack[MAX];/*用一维数组定义堆栈*/
inttop=0;/*定义堆栈指示*/
intpush(inti)/*存储运算数,入栈操作*/
{
if(topMAX)
{
stack[++top]=i;/*堆栈仍有空间,栈顶指示上移一个位置*/
return0;
}
else
{
printf("Thestackisfull");
returnERR;
}
}
intpop()/*取出运算数,出栈操作*/
{
intvar;/*定义待返回的栈顶元素*/
if(top!=NULL)/*堆栈中仍有元素*/
{
var=stack[top--];/*堆栈指示下移一个位置*/
returnvar;/*返回栈顶元素*/
}
else
printf("Thestackisempty!\n");
returnERR;
}
voidmain()
{
intm,n;
charl;
inta,b,c;
intk;
do{
printf("\tAriothmaticOperatesimulator\n");/*给出提示信息*/
printf("\n\tPleaseinputfirstnumber:");/*输入第一个运算数*/
scanf("%d",m);
push(m);/*第一个运算数入栈*/
printf("\n\tPleaseinputsecondnumber:");/*输入第二个运算数*/
scanf("%d",n);
push(n);/*第二个运算数入栈*/
printf("\n\tChooseoperator(+/-/*//):");
l=getche();/*输入运算符*/
switch(l)/*判断运算符,转而执行相应代码*/
{
case'+':
b=pop();
a=pop();
c=a+b;
printf("\n\n\tTheresultis%d\n",c);
printf("\n");
break;
case'-':
b=pop();
a=pop();
c=a-b;
printf("\n\n\tTheresultis%d\n",c);
printf("\n");
break;
case'*':
b=pop();
a=pop();
c=a*b;
printf("\n\n\tTheresultis%d\n",c);
printf("\n");
break;
case'/':
b=pop();
a=pop();
c=a/b;
printf("\n\n\tTheresultis%d\n",c);
printf("\n");
break;
}
printf("\tContinue?(y/n):");/*提示用户是否结束程序*/
l=getche();
if(l=='n')
exit(0);
}while(1);
}