2. 程式人生 > >c++順序棧和鏈式棧的實現

c++順序棧和鏈式棧的實現

阿新 • • 發佈：2019-02-05
基本定義：

棧（Stack）是n個元素a1,a2,…an,組成的有限序列，記作S =(a1,a2,…,an)，並且只能在一端插入和刪除元素，n=0時稱為空棧。

棧的特徵：

由於棧只能從一端插入和刪除元素，故棧具有後進先出（Last in,first out,LIFO）的特性。稱插入和刪除的一端為棧頂(top)，另一端為棧底(bottom)。稱插入元素為入棧或壓棧(push)，刪除元素為出棧或彈棧(pop)。

棧的基本運算定義：

棧初始化：Init_Stack()  初始條件：棧不存在  操作結果：構造了一個空棧 判斷空： Empty_Stack()  若棧空，則返回為1，否則返回0 
入棧：   Push_Stack(S,x)    初始條件：棧S已經存在  操作結果：在棧S的頂部插入一個元素x，這樣x就、成為新的棧頂元素。 
出棧：   Pop_Stack(S,&x)   初始條件：棧S存在且不為空  操作結果：棧S的頂部元素從棧頂刪除，儲存在變數x中 
取棧頂元素： GetTop_Stack(S)  初始條件：棧s存在且不為空  操作結果：返回棧S的棧頂元素，且原棧的結構不會變化 
銷燬棧：     Destory_Stack(S) 初始條件：棧S已經存在  操作結果： 銷燬一個已經存在的棧 
棧的儲存方式：
（1）順序儲存 （2）鏈式儲存 


下面分別實現這兩種棧的儲存方式：


1、鏈式儲存


// 棧.cpp : 定義控制檯應用程式的入口點。
//實現棧的建立，增、刪、查、改


#include "stdafx.h"
#include<iostream>
#include<ctype.h>
using namespace std;


typedef struct node
{
	int data;
	struct node *next;
}Dnode;


//初始化棧
void InitStack(Dnode *&S)
{
	Dnode *top;
	top = (Dnode*)malloc(sizeof(Dnode));
	if (top == NULL)
	{
		cout << "記憶體分配失敗！" << endl;
		exit(0);
	}
	top->next = NULL;
	S = top;
}


//向棧中新增資料，輸入非數字結束
void InitData(Dnode *S)
{
	Dnode *top=S,*p;
	
	int e;
	int i = 1;
	cout << "請輸入第"<<i++<<"個數據：" ;
	cin >> e;
	cout << endl;
	while (e!=-1)
	{
		p = (Dnode*)malloc(sizeof(Dnode));
		if (p == NULL)
		{
			cout << "記憶體分配失敗！" << endl;
			exit(0);
		}
		p->data = e;
		p->next = top->next;
		top->next = p;
		cout << "請輸入第" << i++ << "個數據：";
		cin >> e;
		cout << endl;
	}
}
//壓棧
void PushToStack(Dnode *S) {
	Dnode *top=S,*p;
	int e;
	cout << "請輸入壓棧資料：";
	cin >> e;
	cout << endl;
	p = (Dnode*)malloc(sizeof(Dnode));
	if (p == NULL)
	{
		cout << "記憶體分配失敗！" << endl;
		exit(0);
	}
	else {
		p->data = e;
		p->next = top->next;
		top->next = p;
	}
}


//出棧,並釋放分配的記憶體
void PopStack(Dnode *S, int &e)
{
	Dnode *top = S->next;
	if (top!=NULL)
	{
		Dnode *delete_ptr=top;
		e=top->data;
		S->next = top->next;
		free(delete_ptr);
	}
}
//銷燬棧，釋放所有分配的記憶體
void destoryStack(Dnode *S)
{
	Dnode *delete_ptr;
	while (S->next!=NULL)
	{
		delete_ptr = S->next;
		S ->next= S->next->next;
		free(delete_ptr);
	}
	//free(S);
}


//判斷棧是否為空
bool isEmpty(Dnode *S)
{
	Dnode *top=S;
	if (top->next != NULL) {
		return false;
	}
	else {
		return true;
	}
}


//遍歷棧
void PrintStack(Dnode *S)
{
	Dnode *top = S->next;
	while (top != NULL)
	{
		cout << top->data << "  ";
		top = top->next;
	}
	cout << endl;
}

void main()
{
	Dnode *S = NULL;
	int i;
	while (true)
	{
		
		cout << endl;
		cout << "    ***********************************************************" << endl;
		cout << "    *                                                         *" << endl;
		cout << "    *     1、初始化棧                                         *" << endl;
		cout << "    *     2、向棧中新增多個值，以非數字結束                   *" << endl;
		cout << "    *     3、遍歷棧                                           *" << endl;
		cout << "    *     4、判斷棧是否為空                                   *" << endl;
		cout << "    *     5、壓棧                                             *" << endl;
		cout << "    *     6、出棧                                             *" << endl;
		cout << "    *     7、銷燬棧                                           *" << endl;
		cout << "    *                                                         *" << endl;
		cout << "    ***********************************************************" << endl;
		cout << "請輸入選單序號,執行相應操作：";




		cin >> i;
		cout << endl;
		if (S == NULL&&i != 1)
		{
			cout << "棧尚初始化，請先建立棧，再進行其他初始化操作" << endl;
			i = 1;
		}
		switch (i)
		{
		case 1://初始化棧
			InitStack(S);
			cout << "初始化完成"<<endl;
			break;
		case 2://初始化棧中資料
			InitData(S);
			PrintStack(S);
			break;
		
		case 3://遍歷棧
			PrintStack(S);
			break;
		
		case 5://壓棧
			PushToStack(S);
			PrintStack(S);
			break;
		case 6://出棧
			int e;
			PopStack(S, e);
			cout << "出棧元素為" <<e<< endl;
			cout << "出棧後的棧中資料：";
			PrintStack(S);
			break;
		case 7://銷燬棧
			destoryStack(S);
			cout << "棧已銷燬！";
			break;
		case 4://判斷棧是否為空
			bool flag = isEmpty(S);
			if (flag) { cout << "棧為空！" << endl; }
			else {
				cout << "棧不為空！" << endl;
			}
			break;
		}


	}
	system("pause");
}


2順序棧的實現

#include "stdafx.h"
#include <iostream>
#define STACK_INIT_SIZE  5
#define STACK_INCREMENT  3
using namespace std;




typedef struct stack
{
	int *top;//棧頂指標
	int *base;//棧底指標
	int size;//棧當前容量
}sqStack;


//初始化棧
void InitStack(sqStack *&S)
{
	//構造一個空棧
	S = (sqStack*)malloc(sizeof(sqStack));
	S->base = S->top = NULL;
	S->size = 0;
	S->base = (int *)malloc(sizeof(int)*STACK_INIT_SIZE);
	if (!S->base)
	{
		cout << "記憶體分配失敗！"<<endl;
		exit(OVERFLOW);
	}
	else {
		S->top = S->base;
		S->size = STACK_INIT_SIZE;
		cout << "構造空棧完成！" << endl;


	}
}


//判斷棧是否為空
bool isEmptyStack(sqStack *S)
{
	if (S->base == S->top)
	{
		return true;
	}
	else
	{
		return false;
	}
}


//遍歷棧
void PrintStack(sqStack *S) {
	if (!isEmptyStack(S)) {
		int *p,*top=S->top;
		
		p = S->top;
		cout << "遍歷結果為：";
		while (S->top != S->base)
		{
			cout << *(--p) << "  ";
			S->top = p;
		}
		S->top = top;
	}
	else
	{
		cout << "棧為空！" << endl;
	}
}


//壓棧
void pushStack(sqStack *S){
	if (S->top - S->base >= S->size)
	{
		S->base = (int *)realloc(S->base,sizeof(int)*(S->size + STACK_INCREMENT));
		if (!S->base)
		{
			exit(OVERFLOW);
		}
	}
	int *p=S->top;
	int e;
	cout << "請輸入壓棧元素：" ;
	cin >> e;
	*p++ = e;
	S->top = p;


}


//出棧
bool popStack(sqStack *S, int &e)
{
	int *p = S->top;
	if (p != S->base)
	{
		e = *--p;
		S->top = p;
		return true;
	}
	else
	{
		cout << "棧為空！"<<endl;
		return false;
	}
}


void main()
{
	sqStack *S=NULL;
	int i;
	while (true)
	{
		cout << endl;
		cout << "    ***********************************************************" << endl;
		cout << "    *                                                         *" << endl;
		cout << "    *     1、初始化棧                                         *" << endl;
		cout << "    *     2、遍歷棧                                           *" << endl;
		cout << "    *     3、判斷棧是否為空                                   *" << endl;
		cout << "    *     4、壓棧                                             *" << endl;
		cout << "    *     5、出棧                                             *" << endl;
		cout << "    *                                                         *" << endl;
		cout << "    ***********************************************************" << endl;
		cout << "請輸入選單序號,執行相應操作：";


		cin >> i;
		if (S == NULL&&i != 1)
		{
			cout << "請先初始化棧，再進行其它操作：" << endl;
			i = 1;
		}
		else
		{
			cout << endl;
		}


		


		switch (i)
		{
		case 1://初始化棧         
			InitStack(S);
				
			break;
		case 2://遍歷棧
			PrintStack(S);
			break;


		case 3://判斷棧是否為空   
			if (isEmptyStack(S))
			{
				cout << "棧為空！" << endl;
			}
			
			break;


		case 4://壓棧  
			pushStack(S);
			PrintStack(S);
			break;


		case 5://出棧
			int e;
			if (popStack(S, e))
			{
				cout << "出棧元素為：" << e << endl;
			}
			cout << "出棧後為：";
			PrintStack(S);
			cout << endl;
			break;


		default:
			cout << "請輸入正確的選單序號！"<<endl;
			break;
		}


	}
	system("pause");
}






相關推薦

資料結構筆記之用C++實現順序棧和鏈式棧

這裡介紹兩種實現棧的方式：“順序棧”和“鏈式棧”，各有各的優缺點。 不管是“順序棧”還是“鏈式棧”，我們可以先定義一個棧的ADT（抽象資料型別），如下面的“stack.h” #ifndef STACK_H #define STACK_H const int

c++順序棧和鏈式棧的實現

基本定義： 棧（Stack）是n個元素a1,a2,…an,組成的有限序列，記作S =(a1,a2,…,an)，並且只能在一端插入和刪除元素，n=0時稱為空棧。棧的特徵： 由於棧只能從一端插入和刪除元素，故棧具有後進先出（Last in,first out,LIFO）的特性。

Java程式碼實現順序棧和鏈式棧

Java程式碼實現順序棧和鏈式棧 棧(stack)又名堆疊，它是一種運算受限的線性表。其限制是僅允許在表的一端進行插入或者刪除運算。後進先出（Last In First Out）。 棧中的資料操作主要有push(壓入)和pop(彈出)操作。 實際上，棧就可以用陣列來實現，也可

Java的順序棧和鏈式棧

urn implement public 可能 object 指定大小 常數 額外 異常 棧的定義 棧是限制在表的一段進行插入和刪除的運算的線性表，通常能夠將插入、刪除的一端為棧頂，例外一端稱為棧底，當表中沒有任何元素的時候稱為空棧。 通常刪除（又稱“退棧”）叫做彈出pop

資料結構——線性表：順序棧，鏈式棧（C++）

內容概要： 棧的基本概念及注意事項 順序棧、鏈式棧的C++模板類的實現 棧的基本概念及注意事項： 棧（stack）是限定僅在一端進行插入或刪除操作的線性表。 與順序表和連結串列一樣，棧分為順序棧和鏈式棧。 棧頂（top）元素、入棧（push）、出棧（

C#——實現泛型順序佇列和鏈式佇列

順序佇列，使用List為儲存器 /// 順序佇列 class MyQueue<T> { List<T> list; public MyQueue() {

線性表、棧、佇列的的順序儲存和鏈式儲存

先概括一下線性表順序儲存和鏈式儲存。 線性表的順序儲存是用一組地址連續的儲存單元依次儲存線性表的資料元素。 線性表的鏈式儲存是用指標將儲存線性表中的資料元素的那些單元依次串聯在一起。 接下來圖片說明。

順序棧與鏈式棧的實現

棧的概念： 棧（stack）又名堆疊，它是一種運算受限的線性表。其限制是僅允許在表的一端進行插入和刪除運算。這一端被稱為棧頂，相對地，把另一端稱為棧底。向一個棧插入新元素又稱作進棧、入棧或壓棧，它是把新元素放到棧頂元素的上面，使之成為新的棧頂元素；從一個棧刪除

資料結構 棧（順序棧，鏈式棧，用棧實現計算器）

一、棧的概念 1. 棧是一個特殊的線性表，只能在一端操作：棧頂（top）：允許操作 的一端                                                                     棧底（bottom）：不允許操作的一端 2

順序棧與鏈式棧的圖解與實現

![](https://img2020.cnblogs.com/other/2024393/202012/2024393-20201209101308573-282865479.png)# 順序棧與鏈式棧的圖解與實現 - 棧是一種特殊的線性表，它與線性表的區別體現在增刪操作上 - 棧的特點是先進後出，後

順序棧與鏈式棧型別的定義

順序棧：#define StackSize 100/*假定預分配的棧的空間為100個元素*/typedef char DataType;/*假定棧元素的資料型別為字元*/typedef struct{    dataType data[StackSize];//定義棧陣列  

鏈式棧和鏈式佇列--簡單易懂

#include<iostream> #include<cstdlib> using namespace std; typedef int datatype; typedef struct link_node{     datatype info;

用棧（鏈式）實現十進位制到其他進位制的轉換：

用棧實現十進位制到其他進位制的轉換，此處最大進位制設為十六進位制，可以自行拓展。 主要方法：除商倒數取餘 #include <iostream> using namespace std; //棧節點，使用的是鏈棧結構 struct node { int d

棧（鏈式棧）----C語言

logs links htm mil 等於 sizeof 回顧 ont efi 鏈式棧：就是一種操作受限的單向鏈表，對單向鏈表還不了解的可先看一下之前的一篇關於單向鏈表的隨筆，鏈表（單向鏈表的建立、刪除、插入、打印），理解了單向鏈表後再來看鏈式棧就比較輕松了 鏈式棧的

線性表（順序表和鏈式表）

#include<iostream> #include<cstdio> #define LIST_INIT_SIZE 100 //初始數量 #define LISTINCREMENT 10 //增加量 #define LA_INITLEN 3

資料結構與演算法（二）-線性表之單鏈表順序儲存和鏈式儲存

前言：前面已經介紹過資料結構和演算法的基本概念，下面就開始總結一下資料結構中邏輯結構下的分支——線性結構線性表 一、簡介 1、線性表定義 　　線性表（List）：由零個或多個數據元素組成的有限序列； 　　這裡有需要注意的幾個關鍵地方： 　　　　1.首先他是一個序列，也就是說元素之間是有個先來後到的。

佇列的順序儲存和鏈式儲存

佇列的基本概念 1.定義：佇列是隻允許在一端進行插入操作，而在另一端進行刪除操作的線性表。 2.佇列是一種先進先出的線性表，簡稱FIFO。允許插入的一端稱為隊尾，允許刪除的一端稱為隊頭。front指標指向對頭元素，rear指標指向隊尾的下一個位置。當fron

資料結構：順序結構和鏈式結構的資料型別定義

順序結構： 標頭檔案宣告：sequenclist.h #ifndef _SEQUENCE_H_ #define _SEQUENCE_H_ #define MAXSIZE    10 #define FAILURE    1000000 #define SUCCESS    

線性表的順序儲存和鏈式儲存差異

線性表的順序儲存和鏈式儲存方式在存讀資料以及插入刪除資料時，時間複雜度不同。順序儲存的典型例子為陣列，鏈式儲存的典型例子為單鏈表。眾所周知，當讀取資料較為頻繁時，我們選擇順序儲存方式，當插入和刪除操作較為頻繁時，我們選擇鏈式儲存方式。接下來，我們將分析這樣做的原因：1.順序儲

資料結構 線性表中，順序儲存和鏈式儲存的優缺點

簡單對順序儲存和鏈式儲存結構做對比：   儲存分配方式; 順序儲存用一段連續的儲存單元一次儲存線性表的資料元素。                          鏈式儲存採用鏈式儲存結構，用一組任意的儲存單元存放線性表的元素。時間複雜度衡量;