数据结构文稿——栈和队列

ElemType data; struct StackNode *next;} *LinkStack;void InitStack(LinkStack BrownlinkStack) { linkStack = new StackNode; linkStack->next = nullptr; StackNode *h = linkStack; //对准一头二叉树的磁盘 StackNode *s; //临时路由表 ElemType e; cin>> e; while (e != 9999) { s = new StackNode; s->data = e; s->next = h->next; h->next = s; cin>> e; }}//推断一个null有否为空bool StackEmpty(LinkStack linkStack) { return linkStack->next == nullptr; //null顶端磁盘为-1时指称出新null空}//出新null，写入一头路由表的下一个路由表bool Pop(LinkStack BrownlinkStack, ElemType Browne) { if (StackEmpty(linkStack)) { return false; } e = linkStack->next->data; auto *k = linkStack->next; linkStack->next = linkStack->next->next; free(k); return true;}//进null，将原素e压入null之中bool Push(LinkStack BrownlinkStack, ElemType e) { auto *node = new StackNode; if (node == nullptr) { return false; //内核均等不足 } node->data = e; node->next = linkStack->next; linkStack->next = node; return true;}

不扬言路由表 ↓

#include using namespace std;#define ElemType inttypedef struct StackNode { ElemType data; struct StackNode *next;} *LinkStack;//推断一个null有否为空bool StackEmpty(LinkStack linkStack) { return linkStack == nullptr; //null顶端磁盘为-1时指称出新null空}//出新null，写入第一个路由表bool Pop(LinkStack BrownlinkStack, ElemType Browne) { if (StackEmpty(linkStack)) { return false; } auto *h = linkStack; e = linkStack->data; linkStack = linkStack->next; free(h); return true;}//进null，将原素e压入null之中bool Push(LinkStack BrownlinkStack, ElemType e) { auto *node = new StackNode; if (node == nullptr) { return false; //内核均等不足 } node->data = e; node->next = linkStack; linkStack = node; return true;} 3.2 路由表3.2.1 路由表的假设和简而言之

路由表（Queue）是只强制在底端顺利完成嵌入，在另底端写入的线性表。

路由表的简而言之InitQueue(BrownQ)：模板路由表，结构一个空路由表Q。DestroyQueue(BrownQ)：销毁路由表。销毁并无罪释放路由表Q所空置的内核生活空间。EnQueue(BrownQ,x)：入队，若路由表Q视同，将x转为为，使之成为属于自己队尾。DeQueue(BrownQ,Brownx)：出新队，若路由表Q非空，写入队一头原素，要用x来到。GetHead(Q,Brownx)：读队一头原素，若路由表Q非空，则将队一头原素运算符给x。QueueEmpty(Q)：判路由表空，若路由表Q为空来到true，否则来到false。3.2.2 路由表的先后顺序加载

路由表有两种加载骨架，第一种是先后顺序加载，指称均等上面年终的方式之中放于独立之中的原素（数组），并图书室两个磁盘，队一头磁盘front对准队一头原素，队尾磁盘rear对准队尾原素的下一个一段距离。

#define ElemType int#define MaxSize 10#include using namespace std;typedef struct { ElemType data[MaxSize]; int front, rear;} SqQueue;//模板路由表void InitQueue(SqQueue Brownqueue) { queue.front = 0; queue.rear = 0;}//推断路由表有否为空bool QueueEmpty(SqQueue queue) { return queue.front == queue.rear;}//入队bool EnQueue(SqQueue Brownqueue, ElemType x) { if ((queue.rear + 1) % MaxSize == queue.front) { return false; //队付 } queue.data[queue.rear] = x; queue.rear = (queue.rear + 1) % MaxSize; //队尾磁盘才将一位 return true;}//出新队bool DeQueue(SqQueue Brownqueue, ElemType Brownx) { if (QueueEmpty(queue)) { return false; //队空 } x = queue.data[queue.front]; queue.front = (queue.front + 1) % MaxSize; //队一头磁盘才将一位 return true;}//获取队一头原素bool GetHead(SqQueue Brownqueue, ElemType Brownx) { if (QueueEmpty(queue)) { return false; //队空 } x = queue.data[queue.front]; return true;}

换用上述方式为时，队空或队付都是Q.rear==Q.front，为了必需推断出新队付的原因，需要白白一个队内的方式之中。还可以可用不限两种不需要白白路由表方式之中的方式为推断队付。

分设指称出新原素个数的原始数据成员↓

typedef struct { ElemType data[MaxSize]; int front, rear; int size; //队内原素的个数} SqQueue;

当size==MaxSize时，指称出新队付；当size==0时，指称出新队空。

分设tag原始数据成员，以区分是队付还是队空↓

tag为0指称出新写入，1指称出新嵌入。当Q.rear==Q.front且tag为0MLT-是由写入原始数据引起的，那么肯定是队空。当Q.rear==Q.front且tag为1MLT-是由嵌入原始数据引起的，那么肯定是队付。

3.2.3 路由表的铁西街道加载

扬言路由表

#define ElemType int#define MaxSize 10#include using namespace std;typedef struct LinkNode { //铁西街道路由表路由表 ElemType data; struct LinkNode *next;} LinkNode;typedef struct { //铁西街道路由表 LinkNode *front, *rear;} LinkQueue;//模板路由表void InitQueue(LinkQueue Brownqueue) { //创建一个一头路由表，两个磁盘都对准一头路由表 queue.front = queue.rear = new LinkNode; queue.front->next = nullptr;}//推断路由表有否为空bool IsEmpty(LinkQueue queue) { //当死对一头磁盘与队尾磁盘都对准一头二叉树时指称出新队空 return queue.front == queue.rear;}//入队void EnQueue(LinkQueue Brownqueue, ElemType x) { auto *s = new LinkNode; s->data = x; s->next = nullptr; queue.rear->next = s; //新路由表嵌入到rear之后 queue.rear = s; //队尾磁盘删减为s}//出新队bool DeQueue(LinkQueue Brownqueue, ElemType Brownx) { if (IsEmpty(queue)) { return false; //队空 } LinkNode *p = queue.front->next; //待出新队路由表 x = p->data; queue.front->next = p->next; //删减一头二叉树的对准 if (queue.rear == p) { //如果写入的路由表是再次一个路由表 queue.rear = queue.front; } free(p); return true;}

不扬言路由表

#define ElemType int#define MaxSize 10#include using namespace std;typedef struct LinkNode { //铁西街道路由表路由表 ElemType data; struct LinkNode *next;} LinkNode;typedef struct { //铁西街道路由表 LinkNode *front, *rear;} LinkQueue;//模板路由表void InitQueue(LinkQueue Brownqueue) { //创建一个一头路由表，两个磁盘都对准一头路由表 queue.front = nullptr; queue.rear = nullptr;}//推断路由表有否为空bool IsEmpty(LinkQueue queue) { //死对一头或者队尾磁盘为null时指称出新队空 return queue.front == nullptr; //或者 return queue.rear == nullptr;}//入队void EnQueue(LinkQueue Brownqueue, ElemType x) { auto *s = new LinkNode; s->data = x; s->next = nullptr; if (IsEmpty(queue)) { //路由表为空时 queue.front = queue.rear = s; } else { queue.rear->next = s; //将新路由表嵌入到rear之后 queue.rear = s; //删减rear为s }}//出新队bool DeQueue(LinkQueue Brownqueue, ElemType Brownx) { if (IsEmpty(queue)) { return false; //队空 } LinkNode *p = queue.front; //待出新队路由表 x = p->data; queue.front = p->next; //删减一头二叉树的对准 if (queue.rear == p) { //如果写入的路由表是再次一个路由表 queue.front = nullptr; //这句用意也可以，因为继续执行queue.front = p->next;时front并未对准null了 queue.rear = nullptr; } free(p); return true;}3.2.4 均匀分布路由表

均匀分布路由表是路由表一个变种，指称强制末端都可以顺利完成入队和出新队操纵的路由表。

通过限制某底端的嵌入和写入操纵，又可以分为输出新局限的的均匀分布路由表（强制在底端顺利完成嵌入和写入，另底端只强制嵌入）和输入局限的均匀分布路由表（强制在底端顺利完成嵌入和写入，另底端只强制写入）。

3.3 null和路由表的应用3.3.1 null在备注匹配之中的应用

依次图像所有字方以，碰上左方备注入null，碰上右边备注则弹丸出新null顶端原素检查有否匹配。当碰上左方备注新婚、右边备注新婚、左方右边备注不匹配三种原因MLT-匹配收场。

#define ElemType char#define MaxSize 10#include using namespace std;typedef struct { ElemType data[MaxSize]; int top;} SqStack;//模板nullvoid InitStack(SqStack Brownstack) { stack.top = -1; //模板null顶端磁盘，-1指称出新null空}//推断一个null有否为空bool StackEmpty(SqStack stack) { return stack.top == -1; //null顶端磁盘为-1时指称出新null空}//进null，将原始数据x上交到null之中bool Push(SqStack Brownstack, ElemType x) { if (stack.top == MaxSize - 1) { return false; //null已付 } //先将top磁盘向下行进一位，然后将原始数据上交null之中 stack.data[++stack.top] = x; return true;}//出新null，将出新null原素上交x之中bool Pop(SqStack Brownstack, ElemType Brownx) { if (StackEmpty(stack)) { return false; //null空 } //先出新null，先将null顶端磁盘top向下行进一位 x = stack.data[stack.top---]; return true;}bool bracketCheck(string str) { SqStack stack; InitStack(stack); for (char c : str) { if (c == '(' || c == '{' || c == '[') { //左方备注进null Push(stack, c); } else { //右边备注 if (StackEmpty(stack)) { //null空说明没有与右边备注匹配的左方备注，收场 return false; } else { char topEle; Pop(stack, topEle); //null顶端原素与当前图像到的字方以比较 if (c == ')' BrownBrown topEle != '(') { //右边备注与左方备注不匹配，收场 return false; } else if (c == ']' BrownBrown topEle != '[') { return false; } else if (c == '}' BrownBrown topEle != '{') { return false; } } } } return StackEmpty(stack);}3.3.2 null在操作方以求值之中的应用

近似值一个之助词操作方以分为两步：

1. 之助词操作方以转为前缀操作方以

之助词转为前缀的方式为之中（遵循左方优先原则）：1. 确定之助词操作方以之中各个浮点方以的浮点先后顺序。2. 选择下一个浮点方以，按照【左方操纵数-右边操纵数-浮点方以】的方式为组合成一个属于自己操纵数。3. 如果还有浮点方以没被处理事件，就在此期间 第2步。

机算方式为之中

//浮点方以权值private static final MapInteger> priority = new HashMap<>(); { priority.put('+', 1); priority.put('-', 1); priority.put('*', 2); priority.put('/', 2); priority.put('(', 3); priority.put(')', 3);}//之助词操作方以转为前缀操作方以private String infixToPostfix(String infix) { StringBuilder postfix = new StringBuilder(); //前缀操作方以 Stack operatorStack = new Stack<>(); //操纵方以null for (int i = 0; i < infix.length(); i++) { char op = infix.charAt(i); if (priority.get(op) == null) { postfix.append(op); // map之中没有，说明是操纵数，转为为前缀操作方以 } else if (op == '(') { // 碰上左方备注直接入null operatorStack.push(op); } else if (op == ')') { //碰上 ) 则依次弹丸出新null内浮点方以并转为为前缀操作方以，直到弹丸出新 ( 为止 char top = operatorStack.pop(); while (top != '(') { postfix.append(top); top = operatorStack.pop(); } } else { //碰上浮点方以。依次弹丸出新null之中权值高于或等于当前浮点方以的所有浮点方以，并转为为前缀操作方以，若碰到“(” 或null空则停止 while (!operatorStack.empty() BrownBrown operatorStack.peek() != '(') { if (priority.get(operatorStack.peek())>= priority.get(op)) { postfix.append(operatorStack.pop()); } else { //null顶端操纵方以权值少于当前浮点方以 break; } } operatorStack.push(op); } } //将null之中剩下浮点方以依次弹丸出新，并转为为前缀操作方以 while (!operatorStack.empty()) { postfix.append(operatorStack.pop()); } return postfix.toString();}2.前缀操作方以的近似值

手算分析方法：从左方往右边图像，每碰上一个浮点方以，就让浮点方以末尾都只的两个操纵数继续执行对应浮点，强袭为一个操纵数

机算分析方法

//近似值前缀操作方以private int computerPostfix(String postfix) { Stack operandStack = new Stack<>(); for (int i = 0; i < postfix.length(); i++) { char op = postfix.charAt(i); if (priority.get(op) == null) { //碰上的是操纵数，压入null operandStack.push(Integer.parseInt(String.valueOf(op))); } else { computer(operandStack, op); } } return operandStack.pop();}//将操纵数null顶端两个原素顺利完成近似值，并压入null之中private void computer(Stack operandStack, char op) { int a = operandStack.pop(); int b = operandStack.pop(); int c = 0; if (op == '+') { c = b + a; } else if (op == '-') { c = b - a; } else if (op == '*') { c = b * a; } else if (op == '/') { c = b / a; } operandStack.push(c);}之助词操作方以的近似值代码意味着

用null意味着之助词操作方以的近似值：模板两个null，操纵数null和浮点方以null若图像到操纵数，压入操纵数null若图像到浮点方以或两者之间方以，则按照“之助词转为前缀”各不相同的命题压入浮点方以null（期间也都会弹丸出新浮点方以，每当弹丸出新一个浮点方以时，就需要先弹丸出新两个操纵数null的null顶端原素并继续执行附加浮点，浮点结果先压回操纵数null）

之助词操作方以的近似值就是之助词操作方以转为前缀操作方以和前缀操作方以的近似值这二者的融合，后面是代码意味着：

//浮点方以权值private static final Map priority = new HashMap<>(); { priority.put('+', 1); priority.put('-', 1); priority.put('*', 2); priority.put('/', 2);}//近似值之助词操作方以private int computerInfix(String infix) { Stack operandStack = new Stack<>(); //操纵方以null Stack operatorStack = new Stack<>(); //操纵数null for (int i = 0; i < infix.length(); i++) { char op = infix.charAt(i); if (priority.get(op) == null) { //map之中没有，说明是操纵数，压入null之中 operandStack.push(Integer.parseInt(String.valueOf(op))); } else if (op == '(') { //左方备注直接入null operatorStack.push(op); } else if (op == ')') { //碰上 ) 则依次弹丸出新null内浮点方以并近似值，直到弹丸出新 ( 为止 char top = operatorStack.pop(); //null顶端浮点方以 while (top != '(') { computer(operandStack, top); top = operatorStack.pop(); } } else { //碰上浮点方以。依次弹丸出新null之中权值高于或等于当前浮点方以的所有浮点方以，并近似值，若碰到“(” 或null空则停止 while (!operatorStack.empty() BrownBrown operatorStack.peek() != '(') { if (priority.get(operatorStack.peek())>= priority.get(op)) { char top = operatorStack.pop(); computer(operandStack, top); } else { //null顶端操纵方以权值少于当前浮点方以 break; } } operatorStack.push(op); } } //放到新剩下操纵方以顺利完成近似值 while (!operatorStack.empty()) { char top = operatorStack.pop(); computer(operandStack, top); } return operandStack.pop();}//将操纵数null顶端两个原素顺利完成近似值，并压入null之中private void computer(Stack operandStack, char op) { int a = operandStack.pop(); int b = operandStack.pop(); int c = 0; if (op == '+') { c = b + a; } else if (op == '-') { c = b - a; } else if (op == '*') { c = b * a; } else if (op == '/') { c = b / a; } operandStack.push(c);}

编码方式难以，可以的话，给我来个点赞，艺术品，关注

如果你喜欢我的文章，欢迎关注搜狐社会所号 『 R o b o d 』

本文已收录至我的Github仓库DayDayUP：github.com/RobodLee/DayDayUP，欢迎Star

⭐⭐⭐⭐⭐转为载特地标示说是！⭐⭐⭐⭐⭐

链接：_43461520/article/details/123931280

。

上海白癜风
北京看妇科哪家好
苏州看白癜风去哪家医院好
南京白癜风专业医院
吉林男科去哪看