python 語法 出棧進棧 全局變量的問題

我這里顯示的3，不知到你那是不是哪里出了問題。

創新互聯建站是一家以網絡技術公司，為中小企業提供網站維護、成都網站設計、成都做網站、網站備案、服務器租用、域名注冊、軟件開發、微信小程序開發等企業互聯網相關業務，是一家有著豐富的互聯網運營推廣經驗的科技公司，有著多年的網站建站經驗，致力于幫助中小企業在互聯網讓打出自已的品牌和口碑，讓企業在互聯網上打開一個面向全國乃至全球的業務窗口：建站歡迎咨詢：028-86922220

這個是作用域的關系，sBuf你是在全局作用域中調用的，所以不需要使用global聲明的。

你定義的方法沒有問題，不知道你說的正確是什么意思。

[0 for _ in xrange(10)]，再好的你說的使用標準庫方法吧，

map(lambda x, y: 0, range(10), [])

如果解決了您的問題請采納！

如果未解決請繼續追問

分別寫函數實現初始化棧、入棧、出棧、判斷棧空、判斷棧滿。例如入棧序列為1 2 3 4 5，出棧則為5 4 3 2 1

1、初始化棧

/*功能：初始化棧

*函數名：InitStack

*返回值：void

*/

void InitStack(stack *p)

{

p-top=-1;

}

2、判斷棧為滿

/*功能：判斷棧為滿

*函數名：IsFull

*返回值：為滿——真1，非滿——假0

*/

BOOL IsFull(stack *p)

{

if(MAXSIZE-1==p-top)

{

return TRUE;

}else

{

return FALSE;

}

}

3、判斷棧為空

/*功能：判斷棧為空

* 函數名：IsEmpty

*返回值：為空——真1，非空——假0

*/

BOOL IsEmpty(stack *p)

{

if(-1==p-top)

{

return TRUE;

}else

{

return FALSE;

}

}

4、進棧

/*功能：進棧

*函數名：push

*返回值：成功TRUN 失敗FALSE

*注：不能為滿，否則進棧失敗

*/

BOOL push(stack *p,StackType data)//p=s

{

//判斷棧是否為滿

if(TRUE==IsFull(p))//為滿

{

return FALSE;//返回失敗

}

p-buf[++p-top]=data;

return TRUE;//返回成功

}

5、出棧

/*功能：出棧

*函數名：pop

*返回值:出棧成功TRUE 失敗FALSE

*/

BOOL pop(stack *p,StackType *pd)

{

//判斷是否為空，為空出棧無意義

if(TRUE==IsEmpty(p))

{

return FALSE;//出棧失敗

}

*pd=p-buf[p-top--];//優先級-大于--

return TRUE;//出棧成功

}

擴展資料：

主函數：

void main()

{

//定義變量：類型 變量名

//struct st s;

struct st s;//分配空間

//初始化

InitStack(s);

int num=0;

printf("請輸入");

scanf("%d",num);

//求二進制

while(num!=0)

{

//將余數入棧

if(FALSE==push(s,num%2))

{

return;//結束

}

num/=2;

}

//將二進制結果取出來

char value=0;

while(FALSE!=pop(s,value))

{

printf("%d",value);

}

printf("\n");

}

python實現堆棧與隊列的方法

python實現堆棧與隊列的方法

本文實例講述了python實現堆棧與隊列的方法。分享給大家供大家參考。具體分析如下：

1、python實現堆棧，可先將Stack類寫入文件stack.py，在其它程序文件中使用from stack import Stack，然后就可以使用堆棧了。

stack.py的程序:

代碼如下:class Stack():

def __init__(self,size):

self.size=size;

self.stack=[];

self.top=-1;

def push(self,ele): #入棧之前檢查棧是否已滿

if self.isfull():

raise exception("out of range");

else:

self.stack.append(ele);

self.top=self.top+1;

def pop(self): # 出棧之前檢查棧是否為空

if self.isempty():

raise exception("stack is empty");

else:

self.top=self.top-1;

return self.stack.pop();

def isfull(self):

return self.top+1==self.size;

def isempty(self):

return self.top==-1;

再寫一個程序文件，stacktest.py,使用棧，內容如下:

代碼如下:#!/usr/bin/python

from stack import Stack

s=Stack(20);

for i in range(3):

s.push(i);

s.pop()

print s.isempty();

2、python 實現隊列:

復制代碼代碼如下:class Queue():

def __init__(self,size):

self.size=size;

self.front=-1;

self.rear=-1;

self.queue=[];

def enqueue(self,ele): #入隊操作

if self.isfull():

raise exception("queue is full");

else:

self.queue.append(ele);

self.rear=self.rear+1;

def dequeue(self): #出隊操作

if self.isempty():

raise exception("queue is empty");

else:

self.front=self.front+1;

return self.queue[self.front];

def isfull(self):

return self.rear-self.front+1==self.size;

def isempty(self):

return self.front==self.rear;

q=Queue(10);

for i in range(3):

q.enqueue(i);

print q.dequeue();

print q.isempty();

希望本文所述對大家的Python程序設計有所幫助。

python堆和棧的區別有哪些

堆（Heap）與棧（Stack）是開發人員必須面對的兩個概念，在理解這兩個概念時，需要放到具體的場景下，因為不同場景下，堆與棧代表不同的含義。一般情況下，有兩層含義：

（1）程序內存布局場景下，堆與棧表示的是兩種內存管理方式；

（2）數據結構場景下，堆與棧表示兩種常用的數據結構。

相關推薦：《Python教程》

堆與棧實際上是操作系統對進程占用的內存空間的兩種管理方式，主要有如下幾種區別：

（1）管理方式不同。棧由操作系統自動分配釋放，無需我們手動控制；堆的申請和釋放工作由程序員控制，容易產生內存泄漏；

（2）空間大小不同。每個進程擁有的棧的大小要遠遠小于堆的大小。理論上，程序員可申請的堆大小為虛擬內存的大小，進程棧的大小 64bits 的 Windows 默認 1MB，64bits 的 Linux 默認 10MB；

（3）生長方向不同。堆的生長方向向上，內存地址由低到高；棧的生長方向向下，內存地址由高到低。

（4）分配方式不同。堆都是動態分配的，沒有靜態分配的堆。棧有2種分配方式：靜態分配和動態分配。靜態分配是由操作系統完成的，比如局部變量的分配。動態分配由alloca函數進行分配，但是棧的動態分配和堆是不同的，他的動態分配是由操作系統進行釋放，無需我們手工實現。

（5）分配效率不同。棧由操作系統自動分配，會在硬件層級對棧提供支持：分配專門的寄存器存放棧的地址，壓棧出棧都有專門的指令執行，這就決定了棧的效率比較高。堆則是由C/C++提供的庫函數或運算符來完成申請與管理，實現機制較為復雜，頻繁的內存申請容易產生內存碎片。顯然，堆的效率比棧要低得多。

（6）存放內容不同。棧存放的內容，函數返回地址、相關參數、局部變量和寄存器內容等。當主函數調用另外一個函數的時候，要對當前函數執行斷點進行保存，需要使用棧來實現，首先入棧的是主函數下一條語句的地址，即擴展指針寄存器的內容（EIP），然后是當前棧幀的底部地址，即擴展基址指針寄存器內容（EBP），再然后是被調函數的實參等，一般情況下是按照從右向左的順序入棧，之后是被調函數的局部變量，注意靜態變量是存放在數據段或者BSS段，是不入棧的。出棧的順序正好相反，最終棧頂指向主函數下一條語句的地址，主程序又從該地址開始執行。堆，一般情況堆頂使用一個字節的空間來存放堆的大小，而堆中具體存放內容是由程序員來填充的。

從以上可以看到，堆和棧相比，由于大量malloc()/free()或new/delete的使用，容易造成大量的內存碎片，并且可能引發用戶態和核心態的切換，效率較低。棧相比于堆，在程序中應用較為廣泛，最常見的是函數的調用過程由棧來實現，函數返回地址、EBP、實參和局部變量都采用棧的方式存放。雖然棧有眾多的好處，但是由于和堆相比不是那么靈活，有時候分配大量的內存空間，主要還是用堆。

無論是堆還是棧，在內存使用時都要防止非法越界，越界導致的非法內存訪問可能會摧毀程序的堆、棧數據，輕則導致程序運行處于不確定狀態，獲取不到預期結果，重則導致程序異常崩潰，這些都是我們編程時與內存打交道時應該注意的問題。

python答疑：關于隊列出棧和入棧的，報錯是why?

沒有問題啊 你的代碼縮進有問題吧:

class?MyStack(object):

def?__init__(self,?max):

self.head?=?-1

self.stack?=?list()

self.max?=?max

for?i?in?range(self.max):

self.stack.append(0)

def?put(self,?item):

if?self.head?=?self.max:??????????????????????

return?'Put?Error:?The?Stack?is?Overflow!'??

else:

self.head?+=?1?????????????????????????????

self.stack[self.head]?=?item

print?'Put?%s?Success'?%?item

def?get(self):

if?self.head??0:?????????????????????????????

return?'Get?Error:?The?Stack?is?Empty!'?????

else:

self.head?-=?1?????????????????????????????

return?self.stack[self.head+1]

def?isEmpty(self):

if?self.head??-1:

return?True

return?False

if?__name__?==?"__main__":

mystack?=?MyStack(100)

mystack.put('a')

mystack.put('b')

print?mystack.get()

mystack.put('c')

print?mystack.get()

print?mystack.get()

print?mystack.get()

出棧和入棧的實現 上機題

#include"stdio.h"

#include"malloc.h"

#include"iostream"

using namespace std;

typedef int selemtype;

typedef struct

{

selemtype *base;

selemtype *top;

int size;

}sqstack;

void initstack(sqstack s)

{

s.top = (selemtype*)malloc(10*sizeof(selemtype));

s.base = s.top;

s.size = 10;

}

void push(sqstack s,selemtype e)

{

s.top ;

*s.top = e;

}

void pop(sqstack s)

{

cout(*s.top);

s.top--;

}

int main()

{

sqstack s;

selemtype x;

initstack(s);

cout"input the data"endl;

cinx;

while(x)

{

push(s,x%2);

x = x/2;

}

cout"output the data"endl;

while(s.base != s.top)

{

out(s);

}

coutendl;

system("pause");

return 0;

}