您的位置:

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);

}