数据结构（二）DLUT 栈

最新推荐文章于 2022-04-11 20:25:14 发布

残夜.寒

最新推荐文章于 2022-04-11 20:25:14 发布

阅读量505

点赞数 1

文章标签：数据结构 c++

本文链接：https://blog.csdn.net/weixin_51568657/article/details/121062467

版权

文章目录

数据结构（二）DLUT 栈

数据结构（二）DLUT 栈

顺序栈实现

#include<iostream>
using namespace std;
#define MAXSIZE 100
typedef int SElemType;
typedef struct SqStack{
	SElemType data[MAXSIZE];
	int top;//指向栈顶元素 
}SqStack;

void InitStack(SqStack &S){
	S.top=0;
}//初始化空栈

bool IsEmpty(SqStack S){
	if(S.top==0){
		cout<<"空栈"<<endl;
		return true;
	}else{
		return false;
	} 
}//判空 

bool IsFull(SqStack S){
	if(S.top==MAXSIZE){
		return true;
	}else{
		return false;
	}
}//判满

int GetSize(SqStack S){
	return S.top;
}//返回栈的实际长度 

void GetTop(SqStack S,SElemType &e){
	if(!IsEmpty(S)){
		e=S.data[S.top-1];
	}else{
		cout<<"栈空，无法取出"<<endl;
	}
}//取栈顶元素

void Push(SqStack &S,SElemType e){
	if(IsFull(S)){
		cout<<"栈满，入栈失败"<<endl; 
	}else{
		S.data[S.top++]=e;
	} 
}//入栈

void Pop(SqStack &S){
	if(IsEmpty(S)){
		cout<<"栈空，出栈失败"<<endl;
	}else{
		cout<<"出栈元素为:"<<S.data[S.top-1]<<endl;
		S.top--; 
	}
}//出栈

void CreateStack(SqStack &S,int n){
	cout<<"依次输入放入栈内的元素："<<endl;
	for(int i=0;i<n;i++){
		SElemType e;
		cin>>e;
		Push(S,e);
	}
	cout<<endl;
}//创建一个初始栈

void PrintStack(SqStack S){
	cout<<"打印栈："<<endl;
	for(int i=S.top-1;i>=0;i--){
		cout<<S.data[i]<<"\t"; 
	}
	cout<<endl;
}//打印栈

void ClearStack(SqStack &S){
	S.top=-1;
}//清空栈
//注：顺序栈栈底栈顶实现见D盘code中
int main(){
	SqStack S;
	InitStack(S);
	
	CreateStack(S,5);
	PrintStack(S);
	
	cout<<"输入入栈元素:"<<endl;
	SElemType e;
	cin>>e;
	Push(S,e);
	PrintStack(S);
	
	Pop(S);
	PrintStack(S);
	
	GetTop(S,e);
	cout<<"栈顶元素为:"<<e<<endl;
	cout<<"栈长为:"<<GetSize(S)<<endl;
	
	return 0; 
}

链栈实现

#include<iostream>
using namespace std;

typedef struct StackNode{
	int data;
	StackNode *next;
}StackNode,*LinkStack;

void InitStack(LinkStack &S){
	S=new StackNode;
	S->next=NULL;
}//链栈初始化

bool IsEmpty(LinkStack S){
	if(!S){
		return true;
	}
	return false;
}//判空

void Push(LinkStack &S,int data){
	StackNode *p;
	p=new StackNode;
	p->data=data;
	p->next=S;
	S=p;
}//入栈

void Pop(LinkStack &S){
	StackNode *p;
	if(IsEmpty(S)){
		cout<<"空栈，操作失败"<<endl;
		return;
	}
	p=S;
	cout<<p->data<<"出栈"<<endl;
	S=S->next;
	delete p; 
}//出栈

int GetTop(LinkStack S){
	if(IsEmpty(S)){
		cout<<"栈空，无法取得"<<endl;
		return 0;
	}
	return S->data;
}//获取栈顶元素

void PrintStack(LinkStack S){
	while(S->next){
		cout<<S->data<<"\t";
		S=S->next;
	}
}//打印

int main(){
	StackNode *S;
	InitStack(S);
	Push(S,1); 
	Push(S,2); 
	Push(S,3); 
	Push(S,4); 
	PrintStack(S);
	Pop(S);
	cout<<GetTop(S)<<endl;
	PrintStack(S);
	return 0;
}

相关程序实现

括号匹配

#include <iostream>
#include <cstring>
#include <string>

using namespace std;
class stack {
private:
	int maxsize;
	int top;
	char* st;

public:
	stack(int size)
	{
		maxsize = size;
		top = -1;
		st = new char[maxsize];
	}

	void push(char item)
	{
		st[++top] = item;
	}

	char top1()
	{
		return st[top];
	}

	void pop()
	{
		top--;
	}

	bool empty()
	{
		return top == -1;
	}
};

void Bracketmatch(const char* c) //括号匹配
{
    stack s1(strlen(c));
    char temp;
    for(int i=0;i<strlen(c);i++){
        if(c[i]=='('||c[i]=='['||c[i]=='{'){
            s1.push(c[i]);
        }else if(c[i]>='0'&&c[i]<='9'||c[i]>='a'&&c[i]<='z'||c[i]=='+'||c[i]=='-'||c[i]=='*'||c[i]=='/'||c[i]=='^'||c[i]=='!'||c[i]=='%'||c[i]=='='||c[i]==' '){
        	continue;
		}else{
            if(s1.empty()){
                cout << c[i] << "  匹配错误" << endl;
                return;
            }else{
                temp=s1.top1();
                if(temp=='('&&c[i]==')'||temp=='['&&c[i]==']'||temp=='{'&&c[i]=='}'){
                    s1.pop();
                }else{
                    cout << c[i] << "  匹配错误" << endl;
                    return;
                }
            }
		}   
    }
    if(s1.empty()){
        cout << "匹配正确！" << endl;
    }else{
        cout << s1.top1() << "  匹配错误" << endl;
    }
}

int main()
{

	string s;
	getline(cin, s);
	Bracketmatch(s.c_str());
	return 0;
}

进制转换

//非递归
#include <iostream>
using namespace std;
class stack {
private:
    int maxsize;
    int top;
    int* st;

public:
    stack(int size)
    {
        maxsize = size;
        st = new int[maxsize];
        top = -1;
    }

    void push(int num)
    {
        st[++top] = num;
    }

    void pop()
    {
        int item;
        while (top != -1) {
            item = st[top--];
            cout << item;
        }
    }
};

void Binaryconv(int n, int m) //进制转换
{
    stack s(32);
    while(n!=0){
        s.push(n%m);
        n=n/m;
    }
    cout << "整数" << n << "转成" << m << "进制后的结果是:";
    s.pop();
}
int main()
{
    int n, m;
    cin >> n;
    cin >> m;
    Binaryconv(n, m);
    return 0;
}

//递归实现
#include<iostream>
using namespace std;

int returnb(int n){
	if(!n){
		return 0;
	}else{
		returnb(n/2);
		cout<<n%2;
	}
}

int main(){
	int n;
	cin>>n;
	returnb(n);
}//递归实现

表达式计算

#include<iostream>
using namespace std;
template<class T>
struct Node
{
	T data;
	Node<T>* link;
};
template<class T>
class LinkStack
{
private:
	Node<T>* top;    //栈顶指针 
public:
	LinkStack() { top = NULL; }   //初始化一个空栈  
	~LinkStack();
	LinkStack<T>& Push(T x);        //入栈操作
	LinkStack<T>& Pop(T& x);        //出栈操作
	bool IsEmpty() { if (top == NULL) return true; else return false; }   //   判空操作，判断链栈是否为空栈
	T Top()//取栈顶元素（并不删除）
	{
		if (!IsEmpty())
			return top->data;
		else
		{
			cout << "栈内为空" << endl;
			return -1;
		}
	}
	void print()//输出栈
	{
		if (IsEmpty())
			cout << "栈内为空" << endl;
		else
		{
			Node<T>* p = top;
			while (top)
			{
				cout << top->data << " ";
				top = top->link;
			}
			cout << endl;
			top = p;
		}
	}
};

template<class T>
LinkStack<T>::~LinkStack()
{
	Node<T>* next;
	while (top)
	{
		next = top->link;
		delete top;
		top = next;
	}
}

template<class T>
LinkStack<T>& LinkStack<T>::Push(T x)
{
	Node<T>* p = new Node<T>;
	p->data = x;
	p->link = top;
	top = p;
	return *this;
}

template<class T>
LinkStack<T>& LinkStack<T>::Pop(T& x)
{
	if (IsEmpty())
	{
		cout << "栈为空" << endl;
		return *this;
	}
	Node<T>* p = top;
	x = top->data;
	top = top->link;
	delete p;
	return *this;
}
LinkStack<double> numbers; //存储操作数
LinkStack<char> operations; //存储运算符
/* 设定运算符的优先级，其中以'#'作为operations的栈底元素（便于之后操作) */
int level(char operate)
{
    switch (operate)
    {
    case '#':case '\n':
        return 0;
    case '(':case ')': 
        return 1;
    case '+':case '-': 
        return 2;
    case '*':case '/': 
        return 3;
    }
}

void counter(char);

int main()
{
    cout << "输入代数表达式以计算或输入“e”以退出" << endl << endl;
    char command = cin.get();
    while (command != 'e') {
        counter(command);
        command = cin.get();
    }
    return 0;
}

void counter(char command)
{
    double num, leftnum, rightnum, result;
    double p;
    char q;
    switch (command)
    {
        /* 如果输入是数字，则将该double类型的数据存入栈中 */
    case '0':case'1':case '2':case'3':case '4':case'5':case '6':case'7':case '8':case'9':
        cin.putback(command);
        cin >> num;
        numbers.Push(num);
        break;

    case '(':case ')':case '+':case '-':case '*':case '/':case '\n':
        /* 初始化栈底元素为'#'*/
        if (operations.IsEmpty())
            operations.Push('#');

        /* 若现在输入的运算符优先级较高或是输入‘（’，则应该存储现在的操作符，不执行之前的运算符 */
        if (level(command) > level(operations.Top()) || command == '(')
            operations.Push(command);

        /* 若之前输入的运算符优先级较高，则之前的运算符应该被执行 */
        else {
            while (level(command) <= level(operations.Top()))
            {
                /* 当运算符完全实现后，露出栈底元素‘#’，输入“\n”则打印结果 */
                if (operations.Top() == '#' && command == '\n') 
                {
                    numbers.Pop(result);//result = numbers.Top();
                    cout << "= " << result << endl << endl;
                    operations.Pop(q);
                    break;
                }

                /* 当括号内运算符完全实现后，去除括号,读入下一个字符 */
                else if (operations.Top() == '(' && command == ')') 
                {
                    operations.Pop(q);
                    cin >> command;
                }

                /* 若非上述两种情况，则完成前一个运算符 */
                else
                {
                    //rightnum = numbers.Top();
                    numbers.Pop(rightnum);
                    if (numbers.IsEmpty())
                    {
                        leftnum = 0;
                    }
                    else
                    {
                        //leftnum = numbers.Top();
                        numbers.Pop(leftnum);
                    }
                    
                    operations.Pop(q);
                    switch (q)
                    {
                    case '+':
                        numbers.Push(leftnum + rightnum);
                        break;
                    case '-':
                        numbers.Push(leftnum - rightnum);
                        break;
                    case '*':
                        numbers.Push(leftnum * rightnum);
                        break;
                    case '/':
                        if (rightnum == 0)
                        {
                            cout << "出现分母为零情况(默认结果为0)" << endl;
                            numbers.Push(0);
                        }
                        else
                        {
                            numbers.Push(leftnum / rightnum);
                        }    
                        break;
                    }
                }
            }
            /* 完成前面高优先级的运算后，当前的运算符（除了‘\n’以外）变成最高优先级，所以应存储下来 */
            if (command != '\n')
                operations.Push(command);
        }
        break;
    }
}