数据结构与算法--

最新推荐文章于 2022-06-10 15:57:41 发布

Dyleaf

最新推荐文章于 2022-06-10 15:57:41 发布

阅读量474

点赞数

分类专栏：数据结构&算法文章标签：数据结构 struct

本文链接：https://blog.csdn.net/qq_34480777/article/details/53842319

版权

数据结构&算法专栏收录该内容

5 篇文章 0 订阅

订阅专栏

顺序栈

#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;
}