数据结构-链栈

目录

一、main

二、function

三、com

---

一、main

#include <bits/stdc++.h>
#include "com.h"
using namespace std ; 

/* run this program using the console pauser or add your own getch, system("pause") or input loop */
void conversion() ;  // 8.十进制转十六进制
bool Compare() ; //9.括号的匹配
void SequenceOperation() ; //10.整数序列特殊操作
int EvaluateExpression() ; // 11.表达式求值
bool In(char ch) ; // 判断是否是运算符 
int Operation(int A , char theta , int B) ; // 运算 
char Precede(char c1 , char c2) ; //判断是否应该运算 
int Change(char c) ; 
void Hanoi(int n , char A , char B , char C) ;
void move(char x , int n , char z) ;
void Palindrome() ; 
int c = 0;
int main(int argc, char** argv) 
{
	LinkStack S ;
	SElemType e ;
	int choice , n , i , number , length = 0 , len = 0;
	char A = 'A' , B = 'B' , C = 'C' ;
	do
	{
		printf("\t\t\t==================================================\n");
		printf("\t\t\t|                                                |\n");
		printf("\t\t\t|                   链栈基本操作                 |\n");
		printf("\t\t\t|                                                |\n");
		printf("\t\t\t|================================================|\n");
		printf("\t\t\t|                 请选择要操作的命令             |\n");
		printf("\t\t\t|------------------------------------------------|\n");
		printf("\t\t\t|                                                |\n");
		printf("\t\t\t|    0.退出整个系统          1.初始化栈          |\n");
		printf("\t\t\t|    2.初始输入元素          3.栈是否为空        |\n");
		printf("\t\t\t|    4.查看栈的长度          5.取栈顶元素        |\n");
		printf("\t\t\t|    6.入栈                  7.出栈              |\n");
		printf("\t\t\t|    8.遍历链栈              9.汉诺塔问题        |\n");
		printf("\t\t\t|    10.进制转换             11.括号的匹配       |\n");
		printf("\t\t\t|    12.整数序列特殊操作     13.表达式求值       |\n");
		printf("\t\t\t|    14.回文判断                                 |\n");
		printf("\t\t\t|                                                |\n");
		printf("\t\t\t==================================================\n");
		printf("选择（0---13):\t");
		cin >> choice ; 
		switch(choice)
		{
			case 0 : //0.退出整个系统 
				cout << "退出成功" ;
				exit(0) ;
			case 1 ://  1.初始化栈 
				InitStack(S) ;
				cout << "初始化栈成功" ;
				cout << endl ; 
				break ;
			case 2 :  //2.初始输入元素 
				cout << "请输入需要入栈的数据个数:" ;
				cin >> n ;
				cout << "请输入需要入栈的"<<n<<"个数据,用空格隔开:"<<endl ;
				for(i = 1 ; i <= n ; i ++)
				{
					cin >> number ;
					Push(S , number) ;
				}
				cout << endl ;
				break ;
			case 3 :  // 3.栈是否为空 
				if(StackEmpty(S))  cout << "该栈是空栈" ;
				else  cout << "该栈不是空栈" ;
				cout << endl ;
				break ;
			case 4 : // 4.查看栈的长度 
				if(StackLength(S , length) == ERROR)  cout << "该栈为空栈" ;
				else  cout << "栈的长度为：" << length ;
				cout << endl ;
				break ;
			case 5 : //5.取栈顶元素  
				cout << "栈中元素为：" ; 
				if(StackTraverse(S) == ERROR)  cout << "空栈" ; 
				cout << endl ;
				cout << "栈顶元素为 " << GetTop(S) ;  //"该栈为空，操作失败"
				cout << endl ;
				break ;
			case 6 : // 6.入栈
				cout << "请输入入栈元素：" ;
				cin >> number ;
				if(Push(S , number) == ERROR)  cout << "栈已满，入栈失败" ;
				else  cout << "入栈成功" ;
				cout << endl ;
				cout << "栈中元素为：" ; 
				if(StackTraverse(S) == ERROR)  cout << "空栈" ; 
				cout << endl ;
				break ;
			case 7 : // 7. 出栈
				if(Pop(S , e) == ERROR)  cout << "该栈为空，操作失败" ;
				else  cout << "栈顶元素 " << e << " 已出栈" ;
				cout << endl ; 
				cout << "栈中元素为：" ; 
				if(StackTraverse(S) == ERROR)  cout << "空栈" ; 
				cout << endl ;
				break ;
			case 8 :  //8.遍历链栈
				cout << "栈中元素为：" ; 
				if(StackTraverse(S) == ERROR)  cout << "空栈" ; 
				cout << endl ;
				break ;
			case 9 :   // 9.汉诺塔问题 
				cout << "请输入圆盘数:" ;
				cin >> n ;
				Hanoi(n , A , B , C) ;
				cout << endl ;
				break ; 
			case 10 : //10.十进制转十六进制
				conversion() ;
				cout << endl ;
				break ; 
			case 11 : // 11.括号的匹配 
				cout << "请输入括号：" << endl ;
				if(Compare())   cout << "匹配成功" ;
				else   cout << "匹配失败" ; 
				cout << endl ;
				break ;
			case 12 :  //12.整数序列特殊操作     
				SequenceOperation() ;
				cout << endl ;
				break ;
			case 13 : // 13.表达式求值
				cout << "请输入表达式："; 
				cout << EvaluateExpression(); 
				cout << endl ;
				break ;
			case 14 : // 回文判断
	            cout << "请输入字符串：" ;
				Palindrome() ;
        		cout << endl;
            	break;
			default :
				cout << "输入不合法，请重新输入" ;
				cout << endl ;	 
		}
	}while(choice != 0) ;
	
	return 0;
}

void Palindrome()
{
	linkstack S ; 
	char ch[124] ;
	int len , i ;
	cin >> ch ;
	len = strlen(ch) ;
	for(i = 0 ; i < len/2 ; i ++) // 一半压入栈 
       	push(S , ch[i]);
    if(Judge(S , ch , len) == ERROR)
        cout << "不是回文字符串" << endl;
    else
        cout << "是回文字符串" << endl;
}

// 9.汉诺塔问题 
void move(char x , int n , char z)
{
	cout << ++c << ": " << n << "," << x << "," << z << endl ;
}

void Hanoi(int n , char A , char B , char C) 
{
	if(n == 1)  move(A , 1 , C) ;
	else
	{
		Hanoi(n-1 , A , C , B) ;
		move(A , n , C) ;
		Hanoi(n-1 , B , A , C) ;
	}
}


//10.进制转换 
void conversion() 
{
	cout << "请先输入一个十进制的数:"; 
	int number , num , c; 
	char A = 'A' ;
	SElemType e ;
	cin >> number ;
	cout << "请输入你想转成的进制：" ;
	cin >> c ;
	num = number ; 
	LinkStack S ;
	InitStack(S) ; //先初始化
	while(number)
	{
		Push(S , number % c) ;
		number /= c ;
	}
	cout << num << "的转换结果为：" ;
	while(!StackEmpty(S))
	{
		if(GetTop(S) < 10)  cout << GetTop(S) ;
		else  printf("%c" , 'A'+(GetTop(S)-10)) ;
		Pop(S , e) ;
	}
}


// 11.括号的匹配 
bool Compare()  //9.括号的匹配
{
	linkstack S ;
	initstack(S) ;
	char ch ; //输入的每一个字符
	bool flag = true ; //初始设为满足匹配条件 
	ElemType e ;
	cin >> ch ; 
	while(ch != '#' )  // #结尾 
	{
		switch(ch)
		{
			case '(' :  //这三种条件先压入栈 
			case '[' :
			case '{' :
				push(S , ch) ;
				break ; 
			case ')' :
//				1、Pop(S , e) == ERROR 说明栈已空，不存在元素与ch 配对 
//				2、e != '('  说明配对失败了     （以下同理） 
				if(pop(S , e) == ERROR || e != '(')  flag = false ;
				break ;
			case ']' :
				if(pop(S , e) == ERROR || e != '[')  flag = false ;
				break ;
			case '}' :
				if(pop(S , e) == ERROR || e != '{')  flag = false ;
				break ;
			default :  //这一步可有可无 
				flag = false ; 
		}
		cin >> ch ;
	} 
//	1、ch == '#'  说明已将所有元素遍历
//	2、flag == true  必备条件，不存在switch-case 里不合格的条件
//	3、StackEmpty(S) ， 最终栈为空 ，所有元素都配对成功 
	if(ch=='#' && flag && stackempty(S))  return true ;
	else   return false ;
}

//12.整数序列特殊操作 
void SequenceOperation()
{
	LinkStack S ;
	int n , number;
	SElemType e ;
	InitStack(S) ; //先初始化
//	cout << "请输入元素个数：" ;
//	cin >> n ;
//	cout << "请输入"<<n<<"个数据,用空格隔开:" << endl ;
	cout << "请输入(输入0本操作结束):" << endl ;
	do
	{
		cin >> number ;
		if(number == 0)  
		{
			cout << "操作结束" << endl ;
			break ;
		}
		if(number != -1)  Push(S , number) ;
		else  
		{
			if(Pop(S , e) == ERROR)  cout << "栈为空，无法出栈" ;
			else  cout << "栈顶元素为：" << e ;
			cout << endl ;
		}
	}while(number != 0) ;
}

// 13.表达式求值
bool In(char ch)  // 判断是否是运算符 
{
	if(ch >= '0' && ch <= '9')  return false ; // 不是运算符，是数字 
	else   return true ; // 是运算符
	
}
int Operation(int A , char theta , int B)  // 运算 
{
	switch(theta) 
	{
		case '+' :
			return (A + B) ;
		case '-' :
			return (A - B) ;
		case '*' :
			return (A * B) ;
		case '/' :
			return (A / B) ;
	}
}
char Precede(char c1 , char c2)  //判断是否应该运算 
{
	char a[7][7]={// +   -   *   /   (   )   = 
		             {'>','>','<','<','<','>','>'},  
                     {'>','>','<','<','<','>','>'},  
                     {'>','>','>','>','<','>','>'},  
                     {'>','>','>','>','<','>','>'},  
                     {'<','<','<','<','<','=','0'},  
                     {'>','>','>','>','0','>','>'},  
                     {'<','<','<','<','<','0','='}};
//	char a[10][10] = {'>><<<>>','>><<<>>','>>>><>>','>>>><>>','<<<<<=','>>>>>>','<<<<<='};
	int i = Change(c1);
	int j = Change(c2);
	return a[i][j] ;
}
int Change(char c)
{
	int i ;
	switch(c)
	{
		case '+' : i = 0 ; break ;
		case '-' : i = 1 ; break ;
		case '*' : i = 2 ; break ;
		case '/' : i = 3 ; break ;
		case '(' : i = 4 ; break ;
		case ')' : i = 5 ; break ;
		case '#' : i = 6 ; break ;
	}
	return i ;
}
int EvaluateExpression()
{
	LinkStack OPND ;  //数字 
	linkstack OPTR ;  // 运算符 
	InitStack(OPND) ;
	initstack(OPTR) ;
	push(OPTR , '#') ; // 先将起始符压入栈
	ElemType e , theta ;
	SElemType ee ; 
	int a , b , num , i = 0;
	char ch[124] ;
	cin >> ch ;
	while(ch[i] != '#' || gettop(OPTR) != '#')
	{
		if(In(ch[i]) == false)  
		{
			num = ch[i] - '0' ;
			Push(OPND , num) ; //数字直接压入数字栈
//			cin >> ch ;
			i ++ ;
		}
		else
		{
			switch(Precede(gettop(OPTR) , ch[i]))  //运算符栈顶和现运算符做比 
			{
				case '<' :  //压入运算符栈 
					push(OPTR , ch[i]) ;
//					cin >> ch ;
					i ++ ; 
					break ;
				case '>' :  //做运算
					pop(OPTR , theta) ;  //运算符 
					Pop(OPND , b) ; 
					Pop(OPND , a) ; // 两个操作数
					Push(OPND , Operation(a , theta , b)) ;
					break ;
				case '=' :
					pop(OPTR , e) ;
//					cin >> ch ;
					i ++ ;
					break ; 
			}
		} 
	} 
	return GetTop(OPND) ;
}

二、function

#include <stdlib.h>
#include "com.h"
#include <iostream>
using namespace std;

// 初始化
Status InitStack(LinkStack &S)
{
	S = NULL ;
	return OK ;
}

// 判断栈是否为空
Status StackEmpty(LinkStack S)
{
	if(S == NULL)  return 1 ; //空 
	else  return 0 ;  //非空 
} 


// 遍历链栈
Status StackTraverse(LinkStack S)
{
	if(S == NULL)  return ERROR ;
	else
	{
		LinkStack p = S ;
		while(p)
		{
			cout << p->data << " " ;
			p = p->next ;
		}
	}
	return OK ;
}
 
// 4.查看栈的长度
Status StackLength(LinkStack S , int &length)
{
	length = 0 ;
	if(S == NULL)  return ERROR ;
	else
	{
		LinkStack p = S ;
		while(p)
		{
			length ++ ;
			p = p->next ;
		}
	}
	return OK ;
} 
 
// 取栈顶
// 方案一  自己想的
//Status GetTop(LinkStack S , SElemType &e)
//{
//	if(S == NULL)  return ERROR ; // 无元素可取
//	e = S->data ; // 用e传回到main
//	return OK ; //取栈顶成功 
//} 
 方案二  书上的
SElemType GetTop(LinkStack S)
{
	if(S != NULL)
		return S->data ; //直接返回栈顶元素 
} 

// 入栈
Status Push(LinkStack &S , SElemType e)
{
	LinkStack p ;
	p = new StackNode ;//新建p存放插入元素 
	p->data = e , p->next = S ;
	S = p ;
	return OK ;	
} 

// 出栈
Status Pop(LinkStack &S , SElemType &e)
{
	if(S == NULL)  return ERROR ; //没有栈顶可删 
	LinkStack p = S ; //p临时保存栈顶，准备删除  
	e = S->data ; // 删除元素保存在e中 
	S = S->next ;
	delete p ; //释放空间 
	return OK ;
} 

// 回文判断
Status Judge(linkstack S , char ch[] , int len)
{
    int i , num;
    char e;
    num = len/2;
    if(len % 2 == 1)
        num ++;
    for(i = num ; i < len ; i ++)
    {
        pop(S , e);
        if(e != ch[i])
            return ERROR;
    }
    return OK;
} 




// 
// 初始化
Status initstack(linkstack &S)
{
	S = NULL ;
	return OK ;
}
// 入栈
Status push(linkstack &S , ElemType e)
{
	linkstack p ;
	p = new stacknode ;//新建p存放插入元素 
	p->data = e , p->next = S ;
	S = p ;
	return OK ;	
} 
// 出栈
Status pop(linkstack &S , ElemType &e)
{
	if(S == NULL)  return ERROR ; //没有栈顶可删 
	linkstack p = S ; //p临时保存栈顶，准备删除  
	e = S->data ; // 删除元素保存在e中 
	S = S->next ;
	delete p ; //释放空间 
	return OK ;
}  
// 判断栈是否为空
ElemType gettop(linkstack S)
{
	if(S != NULL)
		return S->data ; //直接返回栈顶元素 
} 
// 判断栈是否为空
Status stackempty(linkstack S)
{
	if(S == NULL)  return 1 ; //空 
	else  return 0 ;  //非空 
} 

三、com

#ifndef _FUNC_H
#define _FUNC_H

#define OK 0
#define ERROR -1
#define OVERFLOW -2

typedef int Status ;
typedef int SElemType ;
typedef char ElemType ;  


// 数字 
typedef struct StackNode{
	SElemType data ;
	struct StackNode *next ;
}StackNode , *LinkStack;

// 字符 
typedef struct stacknode{
	ElemType data ;
	struct stacknode *next ;
}stacknode , *linkstack;

extern Status InitStack(LinkStack &S) ; //初始化
extern Status StackEmpty(LinkStack S) ;// 判断栈是否为空
extern Status StackLength(LinkStack S , int &length) ; // 4.查看栈的长度
extern Status StackTraverse(LinkStack S) ; // 遍历 
extern SElemType GetTop(LinkStack S) ; // 取栈顶
extern Status Push(LinkStack &S , SElemType e) ; // 入栈
extern Status Pop(LinkStack &S , SElemType &e) ; // 出栈

extern Status initstack(linkstack &S) ;
extern Status push(linkstack &S , ElemType e) ;
extern Status pop(linkstack &S , ElemType &e) ;
extern ElemType gettop(linkstack S) ;
extern Status stackempty(linkstack S) ;
extern Status Judge(linkstack S , char ch[] , int len) ; // 回文 
#endif