数据结构与算法--

#include <string.h>
#include <iostream>
#include <iomanip>
using namespace std;

//typedef int elementType
typedef char elementType;    //定义elementType类型
typedef struct snode
{
elementType data[MAXLEN];  //存放栈元素
int top;  //栈顶指示器
}Stack;       //定义顺序栈

//初始化栈
void initstack(Stack & s)
{
s.top = -1; //用-1来表示栈满
}
//判断栈满
bool stackFull(Stack &s)
{
if(s.top==MAXLEN-1)
return true;
else
return false;
}

//元素入栈
void push(Stack &s, elementType &x)
{
if(stackFull(s))
return;
else
{
s.top++;
s.data[s.top] = x;
return;
}
}
//判断栈是否为空
bool stackEmpty(Stack &s)
{
if(s.top==-1)
return true;
else
return false;
}
//出栈
bool pop(Stack & s, elementType &x)
{
if(stackEmpty(s))
return false;
else
{
x = s.data[s.top];
s.top--;
return true;
}
}

//取栈顶元素
char top(Stack &s)
{
elementType x;
if(stackEmpty(s))
return ' ';
else
{
x = s.data[s.top];
return x;
}
}
//<1>利用顺序栈实现将10进制数转换为16进制数。
void DeConversion(int n, int mod)
{
Stack S;
char rem, x;   //rem为余数， x为后面的临时变量
initstack(S);
while(n!=0)
{
rem = n % mod + '0'; //记录余数
push(S, rem); //将余数入栈
n = n / mod;
}
while(!stackEmpty(S))  //当栈非空出栈
{
pop(S, x);
if(x-'0'>=10) //当X大于等于10时将其转化为相应的字母形式
{
char c = 'A'+x-'9'-1;
cout<<c;
}
else cout<<x;
}
}
//<2>对以字符串形式读入的表达式S，判断其中的各括号是否是匹配的
bool BracketMatch(string str)
{
Stack s;
initstack(s);
int len;
int i = 0; //string下标
char x;    //保存栈顶元素
bool tag = true, result = false;
len = str.length();
while(i<len && tag == true)
{
switch(str[i])
{ //当读取到左括号则入栈
case '(':
case '[':
case '{':
push(s,str[i]);
break;
case ')':
if(stackEmpty(s))
{
tag = false;
result = false;
break;
}
top(s);  //取当前栈顶

if(x == '(')  //匹配成功则出栈
{
pop(s, x);
break;
}
else   //当前栈顶元素与扫描的括号不配对,则次序搭配错误
{
tag = false;
result = false;
break;
}
case ']':

if(stackEmpty(s))
{
tag = false;
result = false;
break;
}
if(top(s) == '[')  //匹配成功则出栈
{
pop(s, x);
break;
}
else   //当前栈顶元素与扫描的括号不配对,则次序搭配错误
{
tag = false;
result = false;
break;
}
case '}':
if(stackEmpty(s))
{
tag = false;
result = false;
break;
}
if(top(s) == '{')  //匹配成功则出栈
{
pop(s, x);
break;
}
else   //当前栈顶元素与扫描的括号不配对,则次序搭配错误
{
tag = false;
result = false;
break;
}
default:
break;
}
i++;
}
if(stackEmpty(s) && tag == true)
result= true;
else
result = false;
return result;
}

//<1>假设栈的输入序列为1、2、3、...、n，设计算法实现对给定的一个序列，判定其是否是此栈合法的输出序列。
bool IsPopOrder( string &s, string &d)
{
//判断是否无效比对

if (s.size()==0 || d.size() == 0||s.size()!=d.size())
return false;
int i = 0;
int j = 0; //j表示出栈元素个数
char x;
Stack sta;
initstack(sta);
int len = d.size();
while(j<len) //弹出元素个数小于栈中元素个数，继续执行
{
while ( stackEmpty(sta) || top(sta) != d[j])
{
if (i == len)//入栈元素全部入栈，但是没有出栈中的某一个元素
return false;
push(sta, s[i]);
//cout<<top(sta)<<endl;
i++;
}//当前栈非空，而且元素匹配
pop(sta, x);
j++;
}
return true;
}

void print(Stack &s, const int N)
{
for(int i=0; i<N; i++)
cout<<setw(3)<<s.data[i];
cout<<endl;
}
void GetAllSequence(char* input, int i, const int N, Stack &stk, Stack &seq)
{
char x;
if (i == N)
{
// 输入序列全部入栈完毕，只能出栈。将栈中的元素添加到seq 的后面, 保存 seq
if (!stackEmpty(stk))
{
char Top = top(stk);
push(seq, Top);
pop(stk,x);
GetAllSequence(input, i, N, stk, seq); // 保持 i == N，递归地将 stk 元素复制到 seq
push(stk, Top); //回溯
pop(seq, x);
}
else
print(seq, N);
}
else if(i<N)
{
// 对于一个输入元素，可以入栈；可以不入，弹出栈中已有元素
// 入栈
push(stk, input[i]);
GetAllSequence(input, i+1, N, stk, seq); // 向 i+1 递归
pop(stk, x); // 回溯，恢复栈之前的状态
// 出栈
if (!stackEmpty(stk))
{
char Top = top(stk); //记录
pop(stk, x);
push(seq, Top);
GetAllSequence(input, i, N, stk, seq); // 保持 i 不变
pop(seq,x); // 回溯，恢复栈和序列之前的状态
push(stk,Top);
}
}
}

链栈

#include <iostream>
using namespace std;

//typedef int elemenType
typedef char elementType;
typedef struct node
{
elementType data;
struct node * next;
}seqstack, *linkedstack;   //定义带头节点的链栈

//初始化栈
void initstack(seqstack *& top)
{
top->next = NULL;      //将栈顶置为空
}

//入栈
void pushstack(seqstack *& top, elementType &x)
{
seqstack *s = new seqstack; //申请新节点
s->data = x;
s->next = top->next;    //将结点插入第一个数据结点
top->next = s;
}

//判断栈是否为空
bool stackEmpty(seqstack *top)
{
if(top->next == NULL)    //判断第一个节点是否为空
return true;
else
return false;
}
//出栈
bool popstack(seqstack *& top, elementType &x)
{
seqstack *u;
if(top->next == NULL) //判断栈空
return false;
else
{
x = top->next->data; //取栈头元素
u = top->next;       //记录结点
top->next = u->next; //后移栈头指针
delete u;
return true;
}
}

//取栈顶元素
elementType stackTop(seqstack * top, elementType &x)
{
if(stackEmpty(top))
return -1;
else
{
x = top->next->data;
return x;
}
}
//<1>利用顺序栈实现将10进制数转换为16进制数。
void deConversion(int n, int mod)
{
seqstack *S;
S = new seqstack;
elementType  rem, x;   //rem为余数， x为后面的临时变量
initstack(S);
while(n!=0)
{
rem = n % mod + '0'; //记录余数
pushstack(S, rem); //将余数入栈
n = n / mod;
}
while(!stackEmpty(S))  //当栈非空出栈
{
popstack(S, x);
if(x-'0'>=10) //当X大于等于10时将其转化为相应的字母形式
{
char c = 'A'+x-'9'-1;
cout<<c;
}
else cout<<x;
}
}
//<2>对以字符串形式读入的表达式S，判断其中的各括号是否是匹配的。
bool bracketMatch(string str)
{
seqstack *s = new seqstack;
initstack(s);
int len;
int i = 0;//string下标
char x;  //保存栈顶元素
bool tag = true, result = false;
len = str.length();
while(i<len && tag == true)
{
switch(str[i])
{ //当读取到左括号则入栈
case '(':
case '[':
case '{':
pushstack(s,str[i]);
break;
case ')':
if(stackEmpty(s))
{
tag = false;
result = false;
break;
}
stackTop(s, x);  //取当前栈顶

if(x == '(')  //匹配成功则出栈
{
popstack(s, x);
break;
}
else   //当前栈顶元素与扫描的括号不配对,则次序搭配错误
{
tag = false;
result = false;
break;
}
case ']':

if(stackEmpty(s))
{
tag = false;
result = false;
break;
}
stackTop(s, x);  //取当前栈顶
if(x == '[')  //匹配成功则出栈
{
popstack(s, x);
break;
}
else   //当前栈顶元素与扫描的括号不配对,则次序搭配错误
{
tag = false;
result = false;
break;
}
case '}':
if(stackEmpty(s))
{
tag = false;
result = false;
break;
}
stackTop(s, x);  //取当前栈顶
if(x == '{')  //匹配成功则出栈
{
popstack(s, x);
break;
}
else   //当前栈顶元素与扫描的括号不配对,则次序搭配错误
{
tag = false;
result = false;
break;
}
default:
break;
}
i++;
}
if(stackEmpty(s) && tag == true)
result= true;
else
result = false;
return result;
}