隊列與棧源碼

『壹』 求數據結構中棧，隊列，雙向鏈表的具體實例（要源碼及解釋）！！！

學習數據結構實際上並不是去讓你編寫一個程序的，而是讓你學習一個計算機中的數據存儲與操作的思想的，如果你得到了別人給的好幾個程序，但是你不懂得所謂的演算法，你只能一知半解，但是懂得了演算法，那就是不管用什麼語言了，你都可以得心應手的。
看過很多提問要程序的，你也許只能要到程序，但是你卻從程序中看不到思想，或者你根本就看不懂他的思想。

『貳』 棧和隊列的作用是什麼它們主要可以應用在哪些方面

棧和隊列都屬於一位鏈表，棧是後進先出，進和出都是在同一端進行，就好像一筒羽毛球，只有把上面拿出來，下面的才能拿出來；隊列是先進先出的，進和出分別在不同的端進行，比如排隊的人，排在前面的人先到櫃台辦理業務，後面來的人後得到服務。

棧作為一種數據結構，是一種只能在一端進行插入和刪除操作的特殊線性表。它按照先進後出的原則存儲數據，先進入的數據被壓入棧底。

最後的數據在棧頂，需要讀數據的時候從棧頂開始彈出數據（最後一個數據被第一個讀出來）。棧具有記憶作用，對棧的插入與刪除操作中，不需要改變棧底指針。

(2)隊列與棧源碼擴展閱讀：

在計算機系統中，棧則是一個具有以上屬性的動態內存區域。程序可以將數據壓入棧中，也可以將數據從棧頂彈出。在i386機器中，棧頂由稱為esp的寄存器進行定位。壓棧的操作使得棧頂的地址減小，彈出的操作使得棧頂的地址增大。

棧在程序的運行中有著舉足輕重的作用。最重要的是棧保存了一個函數調用時所需要的維護信息，這常常稱之為堆棧幀或者活動記錄。

『叄』 棧和隊列的區別

棧與隊列的區別
推薦內容
棧與隊列的區別
精選

最佳答案
1、隊列先進先出，棧先進後出。
2、對插入和刪除操作的"限定"不同。
棧是限定只能在表的一端進行插入和刪除操作的線性表。
隊列是限定只能在表的一端進行插入和在另一端進行刪除操作的線性表。
3、遍歷數據速度不同。
棧只能從頭部取數據，也就最先放入的需要遍歷整個棧最後才能取出來，而且在遍歷數據的時候還得為數據開辟臨時空間，保持數據在遍歷前的一致性。
隊列則不同，它基於地址指針進行遍歷，而且可以從頭或尾部開始遍歷，但不能同時遍歷，無需開辟臨時空間，因為在遍歷的過程中不影像數據結構，速度要快的多

棧（stack）又名堆棧，它是一種運算受限的線性表。其限制是僅允許在表的一端進行插入和刪除運算。這一端被稱為棧頂，相對地，把另一端稱為棧底。
向一個棧插入新元素又稱作進棧、入棧或壓棧，它是把新元素放到棧頂元素的上面，使之成為新的棧頂元素；從一個棧刪除元素又稱作出棧或退棧，它是把棧頂元素刪除掉，使其相鄰的元素成為新的棧頂元素。
隊列是一種特殊的線性表，特殊之處在於它只允許在表的前端（front）進行刪除操作，而在表的後端（rear）進行插入操作，和棧一樣，隊列是一種操作受限制的線性表。進行插入操作的端稱為隊尾，進行刪除操作的端稱為隊頭。隊列中沒有元素時，稱為空隊列。
隊列的數據元素又稱為隊列元素。在隊列中插入一個隊列元素稱為入隊，從隊列中刪除一個隊列元素稱為出隊。因為隊列只允許在一端插入，在另一端刪除，所以只有最早進入隊列的元素才能最先從隊列中刪除，故隊列又稱為先進先出（FIFO—first in first out）線性表。

『肆』 棧和隊列的主要區別在於

隊列（Queue）：是限定只能在表的一端進行插入和在另一端進行刪除操作的線性表；
棧（Stack）：是限定只能在表的一端進行插入和刪除操作的線性表。
區別如下：
一、規則不同
1. 隊列：先進先出（First In First Out）FIFO
2. 棧：先進後出（First In Last Out ）FILO
二、對插入和刪除操作的限定不同
1. 隊列：只能在表的一端進行插入，並在表的另一端進行刪除；
2. 棧：只能在表的一端插入和刪除。
三、遍歷數據速度不同
1. 隊列：基於地址指針進行遍歷，而且可以從頭部或者尾部進行遍歷，但不能同時遍歷，無需開辟空間，因為在遍歷的過程中不影響數據結構，所以遍歷速度要快；
2. 棧：只能從頂部取數據，也就是說最先進入棧底的，需要遍歷整個棧才能取出來，而且在遍歷數據的同時需要為數據開辟臨時空間，保持數據在遍歷前的一致性。

『伍』 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程序設計有所幫助。

『陸』 棧與隊列的應用（c語言）求解

#include "stdio.h"
#include "malloc.h"
typedef struct node1{
int *data;
int top;
void init(void);
void del(void);
int pop(int&);
void push(int&);
}s;
void node1::init(){
data=(int*)malloc(sizeof(int)*100);
top=0;
}
void node1::del(){
free(data);
top=0;
}
int node1::pop(int &e){
if(top==0)return 0;
e=data[--top];
return 1;
}
void node1::push(int &e){
if(top==100)return;
data[top++]=e;
}
typedef struct node2{
int *data;
int top;
int bottom;
void init(void);
void del(void);
int pop(int&);
void push(int&);
void format(s&);
}q;
void node2::init(){
data=(int*)malloc(sizeof(int)*100);
top=bottom=0;
}
void node2::del(){
free(data);
top=bottom=0;
}
int node2::pop(int &e){
if(top==bottom)return 0;
e=data[top++];
return 1;
}
void node2::push(int &e){
if(bottom==100)return;
data[bottom++]=e;
}
void node2::format(s &e){
int a;
while(e.pop(a)){
push(a);
}
}
int main(){
s b;q c;
int a;
b.init();c.init();
printf("輸入棧中的數,以0結尾\n");
while(1){
scanf("%d",&a);
if(a==0)break;
b.push(a);
}
c.format(b);
while(c.pop(a)){
printf("%d\n",a);
}
b.del();
c.del();
return 0;
}//b為棧,c為隊列,c.format(b)為轉換函數

『柒』 棧與隊列的區別

1、隊列先進先出，棧先進後出。

2、對插入和刪除操作的"限定"不同。

棧是限定只能在表的一端進行插入和刪除操作的線性表。

隊列是限定只能在表的一端進行插入和在另一端進行刪除操作的線性表。

3、遍歷數據速度不同。

棧只能從頭部取數據，也就最先放入的需要遍歷整個棧最後才能取出來，而且在遍歷數據的時候還得為數據開辟臨時空間，保持數據在遍歷前的一致性。

隊列則不同，它基於地址指針進行遍歷，而且可以從頭或尾部開始遍歷，但不能同時遍歷，無需開辟臨時空間，因為在遍歷的過程中不影像數據結構，速度要快的多

(7)隊列與棧源碼擴展閱讀

棧（stack）又名堆棧，它是一種運算受限的線性表。其限制是僅允許在表的一端進行插入和刪除運算。這一端被稱為棧頂，相對地，把另一端稱為棧底。

向一個棧插入新元素又稱作進棧、入棧或壓棧，它是把新元素放到棧頂元素的上面，使之成為新的棧頂元素；從一個棧刪除元素又稱作出棧或退棧，它是把棧頂元素刪除掉，使其相鄰的元素成為新的棧頂元素。

隊列是一種特殊的線性表，特殊之處在於它只允許在表的前端（front）進行刪除操作，而在表的後端（rear）進行插入操作，和棧一樣，隊列是一種操作受限制的線性表。進行插入操作的端稱為隊尾，進行刪除操作的端稱為隊頭。隊列中沒有元素時，稱為空隊列。

隊列的數據元素又稱為隊列元素。在隊列中插入一個隊列元素稱為入隊，從隊列中刪除一個隊列元素稱為出隊。因為隊列只允許在一端插入，在另一端刪除，所以只有最早進入隊列的元素才能最先從隊列中刪除，故隊列又稱為先進先出（FIFO—first in first out）線性表。

參考資料來源：網路—隊列 （常用數據結構之一）

參考資料來源：網路—棧 （計算機術語）

『捌』 棧與隊列的實現(java)

import java.util.Stack;

public class Translate {
//程序入口
public static void main(String[]args){
int n = Translate.translate(3467,8);
System.out.println("結果是："+n);
}

public static int translate(int number, int base_num) {
//使用棧
Stack<Integer>stack = new Stack<Integer>();
while(number>0){
//壓棧
stack.push(number % base_num);
number /= base_num;
}
int n = stack.size();
int val=0;
//依次出棧並合成結果（用我們熟悉的十進製表示，所以乘以10）
for(int i=0;i<n;i++){
val=val*10+stack.pop();
}
return val;
}
}

『玖』 計算機c語言中 什麼是棧和隊列

地址就是~~~~
比如你申請一個變數int
a=1;
那麼它就自動在內存中申請了一個4位元組的地址給你使用~
你可以使用&a來查看地址~其實都是跟上面的一樣~不管怎麼樣申請了之後就需要釋放，但是c語言如果不是動態申請的~系統都會幫你自動優化哦~程序結束就會釋放~