为了账号安全,请及时绑定邮箱和手机立即绑定
  • 修改后:

    #include <iostream>
    #include <stdlib.h>
    #include "MyStack.h"
    #include <algorithm>
    #include <string>
    using namespace std;
    
    //用栈进行括号匹配
    
    int main(void)
    {
        //定义两个栈
        MyStack *pStack = new MyStack(30);//用于存放输入字符串的字符
        MyStack *pNeedStack = new MyStack(30);//用于存放栈顶急需匹配的字符
    
        char str[] = "[()]";
        char currentNeed = 0;
        for(int i = 0; i < strlen(str);i++)
        {
            if(str[i] != currentNeed)
            {
                pStack->push(str[i]);
                switch(str[i])
                {
                    case'[':
                        if(currentNeed != 0)//currentNeed有一个正确的值
                        {
                            pNeedStack->push(currentNeed);
                        }
                        currentNeed = ']';
                        break;
                    case '(':
                        if(currentNeed != 0)
                        {
                            pNeedStack->push(currentNeed);
                        }
                        currentNeed = ')';
                        break;
                    default:
                        cout<<"字符串括号匹配"<<endl;
    
                        return 0;
                }
            }
            else
            {
                char elem;
                pStack->pop(elem);
                if(pNeedStack->pop(currentNeed))
                {
                    currentNeed = 0;
                }
    
            }
        }
    
        if(pStack->stackEmpty())
        {
            cout<<"字符串括号匹配"<<endl;
        }
        else
        {
            cout<<"字符串括号不匹配"<<endl;
        }
    
    
        delete pStack;
        pStack = NULL;
    
        delete pNeedStack;
        pNeedStack = NULL;
    
    
        return 0;
    }

    还是有点不太理解,自己做

  • #include <iostream>
    #include <stdlib.h>
    #include "MyStack.h"
    #include <algorithm>
    #include <string>
    using namespace std;
    
    //用栈进行括号匹配
    
    int main(void)
    {
        //定义两个栈
        MyStack *pStack = new MyStack(30);//用于存放输入字符串的字符
        MyStack *pNeedStack = new MyStack(30);//用于存放栈顶急需匹配的字符
    
        char str[] = "[()]";
        char currentNeed = 0;
        for(int i = 0; i < strlen(str);i++)
        {
            if(str[i] != currentNeed)
            {
                pStack->push(str[i]);
                switch(str[i])
                {
                    case'[':
                        if(currentNeed != 0)//currentNeed有一个正确的值
                        {
                            pNeedStack->push(currentNeed);
                        }
                        currentNeed = ']';
                        break;
                    case '(':
                        if(currentNeed != 0)
                        {
                            pNeedStack->push(currentNeed);
                        }
                        currentNeed = ')';
                        break;
                }
            }
            else
            {
                char elem;
                pStack->pop(elem);
                pNeedStack->pop(currentNeed);
            }
        }
    
        if(pStack->stackEmpty())
        {
            cout<<"字符串括号匹配"<<endl;
        }
        else
        {
            cout<<"字符串括号不匹配"<<endl;
        }
    
    
        delete pStack;
        pStack = NULL;
    
        delete pNeedStack;
        pNeedStack = NULL;
    
    
        return 0;
    }


  • 老师是把余数10,11,12,13直接压进栈的,感觉直接压A、B、C、D方便很多。


    老师的方法暂未看。

  • 上一个程序不完善,因为有16进制。

    https://www.cnblogs.com/curo0119/p/8304924.html

    自己修改:应该正确:

    #include <iostream>
    #include <stdlib.h>
    #include "MyStack.h"
    #include <algorithm>
    #include <string>
    using namespace std;
    
    //用栈进行进制转换
    
    #define BIN 2
    #define OCT 8
    #define HEX 16
    
    int main(void)
    {
        string str = "0123456789ABCDEF";
        MyStack *pStack = new MyStack(30);
    
        int N = 12;
    
        while(N)
        {
            int tmp = N % HEX;
    
            pStack->push(str[tmp]);
    
            N /= HEX;
        }
    
        pStack->stackTraverse(false);
        delete pStack;
        pStack = NULL;
        return 0;
    }



  • <!--此处有图片-->

    首先把之前的MyStack改成int型:

    #include <iostream>
    #include <stdlib.h>
    #include "MyStack.h"
    #include <algorithm>
    using namespace std;
    
    //用栈进行进制转换
    
    #define BIN 2
    #define OCT 8
    #define HEX 16
    
    int main(void)
    {
        MyStack *pStack = new MyStack(30);
    
        int N = 1348;
    
        while(N)
        {
            int tmp = N % OCT;
            pStack->push(tmp);
            N /= OCT;
        }
    
        pStack->stackTraverse(false);
        delete pStack;
        pStack = NULL;
        return 0;
    }


  • main.cpp
    
    #include <iostream>
    #include <stdlib.h>
    #include "MyStack.h"
    using namespace std;
    
    //实现栈
    
    int main(void)
    {
        MyStack *pStack = new MyStack(5);
    
        pStack->push('h');
        pStack->push('e');
        pStack->push('l');
        pStack->push('l');
        pStack->push('o');
    
        pStack->stackTraverse(true);
    
        pStack->clearStack();
    
        cout<<pStack->stackLength()<<endl;
    
        if(pStack->stackEmpty())
        {
            cout << "栈为空" << endl;
        }
    
        delete pStack;
        pStack = NULL;
        return 0;
    }
    MyStack.cpp
    
    //
    
    #include "MyStack.h"
    #include <iostream>
    using namespace std;
    
    MyStack::MyStack(int size)//分配内存初始化栈空间,设定栈容量,栈顶
    {
        m_iSize = size;
        m_pBuffer = new char[size];
        m_iTop = 0;//表示此时的栈是个空栈
    
    }
    
    MyStack::~MyStack()
    {
        delete []m_pBuffer;
    }
    
    bool MyStack::stackEmpty()//判定栈是否为空,为空返回true,非空返回false
    {
        if(0 == m_iTop)
        {
            return true;
        }
        return false;
    }
    bool MyStack::stackFull()
    {
        if(m_iTop == m_iSize)
        {
            return true;
        }
        return false;
    }
    
    void MyStack::clearStack()//清空栈
    {
           m_iTop = 0;
    }
    
    int MyStack::stackLength()//已有元素的个数
    {
        return m_iTop;
    }
    
    bool MyStack::push(char elem)//元素入栈,栈顶上升
    {
        //先判断是否栈满
        if(stackFull())
        {
            return false;
        }
        m_pBuffer[m_iTop] = elem;
        m_iTop++;
        return true;
    }
    //法二
    //char MyStack::pop()
    //{
    //    if(stackEmpty())
    //    {
    //        throw 1;
    //    }
    //    else
    //    {
    //        m_iTop--;
    //        return m_pBuffer[m_iTop];
    //    }
    //}
    bool MyStack::pop(char &elem)//元素出栈,栈顶下降
    {
        //先判定是否为空
        if(stackEmpty())
        {
            return false;
        }
        m_iTop--;//入栈之后栈顶指向的是一个空位置
        elem = m_pBuffer[m_iTop];
        return true;
    }
    
    void MyStack::stackTraverse(bool isFromButoom)//遍历栈中所有元素
    {
        if(isFromButoom)
        {
            for(int i = 0; i < m_iTop;i++)//栈的长度就是m_iTop
            {
                cout<< m_pBuffer[i] << ",";
            }
        }
        else
        {
            for(int i = m_iTop-1; i>=0;i--)
            {
                cout << m_pBuffer[i] << ",";
            }
        }
    
    }
    MyStack.h
    
    
    
    #ifndef INC_0131_MYSTACK_H
    #define INC_0131_MYSTACK_H
    class MyStack
    {
    public:
        MyStack(int size);//分配内存初始化栈空间,设定栈容量,栈顶
        ~MyStack();//回收栈空间内存
        bool stackEmpty();//判定栈是否为空,为空返回true,非空返回false
        bool stackFull();
        void clearStack();//清空栈
        int stackLength();//已有元素的个数
        bool push(char elem);//元素入栈,栈顶上升
        bool pop(char &elem);//元素出栈,栈顶下降
        void stackTraverse(bool isFromButoom);//遍历栈中所有元素
    
    private:
        char *m_pBuffer;//栈空间指针
        int m_iSize;//栈容量
        int m_iTop;//栈顶,栈中元素个数栈顶为1说明有一个元素
    };
    
    #endif //INC_0131_MYSTACK_H


  • 为什么用.h和.cpp:https://blog.csdn.net/happywlg123/article/details/80375593

  • 要想用 new,这个类要有一个默认的构造函数

    02:51
    看视频
  • 抛出异常 throw

    外部 try catch

    ?????

    (exception)异常,是用来报告你能恢复的那一类错误的,不是bugfix。

    02:04
    看视频
  • public class Coordinate {
        private int x;
        private int y;
        Coordinate(int x,int y){
            this.x=x;
            this.y=y;
        }
        void PrintCoordinate(){
            System.out.println("("+x+","+y+")");
        }
    }


  • public class Mystackmain {
        public static void main(String[] args) {
            Mystack p=new Mystack(5);
    
            p.push('h');
            p.push('e');
            p.push('l');
            p.push('l');
            p.push('0');
    
            p.StackTraverse(false);
            System.out.println(p.StackLength());
    
    
            p.pop();
            p.pop();
    
            p.StackTraverse(false);
            System.out.println(p.StackLength());
    
            if(p.isEmpty()){
                System.out.println("栈为空");
            }
            if(p.isFull()){
                System.out.println("栈为满");
            }
    
            p.DeleteMystack();
    
        }


  • public class Mystack {
        private int head;
        private char[] stack;
        private int StackLength;
        private int StackCapacity;
        Mystack(int StackCapacity){
            this.StackCapacity=StackCapacity;
            head=-1;
            StackLength=0;
            stack=new char[StackCapacity];
        }
        void DeleteMystack(){
            stack=null;
        }
    
        boolean isFull(){
            if(head+1==StackCapacity){
                return true;
            }
            return false;
        }
    
        boolean isEmpty(){
            if(head==-1){
                return true;
            }
            return false;
        }
    
        void ClearStack(){
            head=-1;
            StackLength=0;
        }
    
        int StackLength(){
            return StackLength;
        }
    
        boolean push(char k){
            if(isFull()){
                return false;
            }
            head++;
            stack[head]=k;
            StackLength++;
            return true;
        }
    
        boolean pop(){
            if(isEmpty()){
                return false;
            }
            System.out.println("出栈元素为"+stack[head]);
            head--;
            StackLength--;
            return true;
        }
    
        void StackTraverse(boolean isFromTop){
            if(!isFromTop){
                for(int i=0;i<=head;i++){
                    System.out.print(stack[i]);
                }
                System.out.println();
            }
            else {
                for (int i = head; i >= 0; i--) {
                    System.out.print(stack[i]);
                }
                System.out.println();
            }
        }

    java实现

  • 栈类:后进先出

    公有函数:

    MyStack(int size):构造函数,分配内存空间

    ~MyStack()           :析构函数与构造函数相反,主要在构造函数执行完毕后被自动调用执行善后工作,如释放构造函数开辟的内存

    int stackLength(): 返回栈里面的元素个数(不是内存空间大小)

    void push(char elem):入栈(入栈前要判断栈是否已满)

    void pop(char &elem):出栈(出栈前要判断栈是否为空)

    入栈导致栈顶上升    出栈导致栈顶下降

                        


    04:57
    看视频
首页上一页1234567下一页尾页

举报

0/150
提交
取消
课程须知
"本课程是数据结构初级课程 1、熟练掌握C++语言基础语法"
老师告诉你能学到什么?
1、栈的工作原理 2、栈的实现方法及编码技巧 3、栈模板的编码技巧和使用技巧 4、数制转换编程思路及栈的作用 5、括号匹配编程思路及栈的作用
意见反馈 帮助中心 APP下载
官方微信
友情提示:

您好,此课程属于迁移课程,您已购买该课程,无需重复购买,感谢您对慕课网的支持!