int main() { cout<<"----------MyStack<int>---------------"<<endl; MyStack<int> mysatck; mysatck.push(1); mysatck.push(2); mysatck.push(3); cout<<mysatck.pop()<<endl; cout<<mysatck.pop()<<endl; cout<<mysatck.pop()<<endl; cout<<"----------deque<int>---------------"<<endl; deque<int> dequeint; dequeint.push_front(1); dequeint.push_front(2); dequeint.push_front(3); cout<<dequeint.front()<<endl; dequeint.pop_front(); cout<<dequeint.front()<<endl; dequeint.pop_front(); cout<<dequeint.front()<<endl; dequeint.pop_front(); return 0; }
bool uTest( UnitTest *utest_p) { bool thrown_error = false; //Tested instance MyStack stack; stack.push(1); stack.push(2); UTEST_CHECK( utest_p, stack.size() == 2); int second = stack.pop(); int first = stack.pop(); UTEST_CHECK( utest_p, second == 2); UTEST_CHECK( utest_p, first == 1); UTEST_CHECK( utest_p, stack.size() == 0); try { stack.pop(); } catch ( MyStack::Error) { thrown_error = true; } UTEST_CHECK( utest_p, thrown_error); return utest_p->result(); }
int main(void) { MyStack<char> *pStack = new MyStack<char>(20); MyStack<char> *pNeedStack = new MyStack<char>(20); char str[] = "[[]>]]"; char isNeeded = 0; cout << strlen(str) << endl; for (int i = 0; i < strlen(str); i++) { cout << str[i] << endl; if (str[i] != isNeeded) { pStack->push(str[i]); cout << "push stack: " << str[i] << endl; switch(str[i]) { case '[': if (0 != isNeeded) { pNeedStack->push(isNeeded); cout << "push isNeeded: " << isNeeded << endl; } isNeeded = ']'; break; case '(': if (0 != isNeeded) { pNeedStack->push(isNeeded); cout << "push isNeeded: " << isNeeded << endl; } isNeeded = ')'; break; default: cout << "string is not matched." << endl; return 0; break; } } else { char temp = 0; pStack->pop(temp); cout << "pop stack: " << temp << endl; if (!pNeedStack->pop(isNeeded)) { isNeeded = 0; } cout << "pop isNeeded: " << isNeeded << endl; } } if (pStack->stackEmpty()) { cout << "string is matched" << endl; } else { cout << "string is not matched" << endl; } delete pStack; pStack = NULL; delete pNeedStack; pNeedStack = NULL; return 0; }
int pop() { while(!S1.isEmpty()) S2.push(S1.pop()); temp = S2.pop(); while(!S2.isEmpty()) S1.push(S2.pop()); return temp; }
void Expression::checkvp() { stk = new MyStack(exp.length()); for (int i = 0; i < exp.length(); ++i) { if (exp.at(i) == '{' || exp.at(i) == '(' || exp.at(i) == '[') { stk->push(exp.at(i)); } else if (exp.at(i) == '}' || exp.at(i) == ')' || exp.at(i) == ']') { if (exp.at(i) == '}') { char c = stk->get_top(); if (c == '{') { stk->pop(exp.at(i)); } else { cout << "Not well parenthesized!\n" return; } } if (exp.at(i) == ')') { char c = stk->get_top(); if (c == '(') { stk->pop(exp.at(i)); } else { cout << "Not well parenthesized!\n" return; } } if (exp.at(i) == ']') { char c = stk->get_top(); if (c == '[') { stk->pop(exp.at(i)); } else { cout << "Not well parenthesized!\n" return; } }
/* Function: twoNumsProcess() * Usage: is called by sortTokenByStacks() or getFinalStacksResult() functions * -----------------------------------------------------------------------------------------// * Makes single calculation for two top numbers in stack, and return result to * stackNumbers back. * * * @param stackNumbers Stack of number values for current recursion * @param stackOperators Stack of operators for current recursion */ void twoNumsProcess(MyStack<double> &stackNumbers, MyStack<string> &stackOperators) { /* Stacks elements validation checking for calculating process */ if((stackNumbers.size() - stackOperators.size()) != 1) { cout << " - CHECK YOUR INPUT, NOT ENOUGH NUMBERS IN FORMULA!" << endl; failFlag = true; } else { /* Calculating process */ double num2 = stackNumbers.pop(); double num1 = stackNumbers.pop(); string thisOper = stackOperators.pop(); double result = singleCalculation(num1, thisOper, num2); stackNumbers.push(result); } }
void processChar( char item, MyStack<Token> &stack, string &operations, bool &OK ) { // Note: // I could check top of stack before adding tokens // and catch many errors "now" instead of later. // I'd rather be lazy and let collapse() catch the errors. Token token = toToken(item); switch (token) { case TOKEN_VALUE: if ( stack.isEmpty() ) { stack << token; return; } switch ( stack.top() ) { case TOKEN_LEFT_GROUP: stack << token; break; case TOKEN_ADDITION: stack << token; break; // don't collapse yet case TOKEN_MULTIPLICATION: collapse( stack << token, operations, OK ); break; default: OK = false; break; } break; case TOKEN_ADDITION: collapse( stack, operations, OK); stack << TOKEN_ADDITION; break; case TOKEN_MULTIPLICATION: case TOKEN_LEFT_GROUP: stack << token; break; case TOKEN_RIGHT_GROUP: // clear any pending addidion collapse( stack, operations, OK ); if ( !OK ) return; // convert ( value ) to value if ( !stack.isEmpty() && TOKEN_VALUE == stack.pop() && !stack.isEmpty() && TOKEN_LEFT_GROUP == stack.pop() ) stack << TOKEN_VALUE; else OK = false; break; case TOKEN_UNKNOWN: OK = false; break; } }
void string_test() { string next; char c; MyStack<string> s; cout << "Enter a sentence or two\n"; // read from terminal word by word while (cin >> next) { // put latest word into stack s.push(next); // was that the last word on the line? c = cin.get(); if (c == '\n') break; else cin.putback(c); } cout << "Written backward that is:\n"; while (!s.empty()) cout << s.pop() << " "; cout << "\n"; }
void test_qa(AnsType& expectAns, OpreateType& opreateParam, InitType& initData, DataType1 firstData = DataType1()) { AnsType ans; MyStack work; for(int i=0; i<opreateParam.size(); i++) { int ansTmp = -1; if(opreateParam[i] == "push") { work.push(firstData[i]); } if(opreateParam[i] == "pop") { ansTmp = work.pop(); } if(opreateParam[i] == "top") { ansTmp = work.top(); } if(opreateParam[i] == "empty") { ansTmp = work.empty(); } ans.push_back(ansTmp); } int index = getIndex(); bool check = eq(ans, expectAns); if(!check) { printf("index %d: NO\n", index); output("opreateParam", opreateParam); output("initData", initData); output("firstData", firstData); output("ans", ans); output("expectAns", expectAns); } else { printf("index %d: YES\n", index); } printf("\n"); }
//Driver code int main() { MyStack s; s.push(3); s.push(5); s.getMin(); s.push(2); s.push(1); s.getMin(); s.pop(); s.getMin(); s.pop(); s.peek(); return 0; }
bool solveMas(string s) { MyStack<char> st; char skob[3][2]; skob[0][0] = '('; skob[1][0] = '['; skob[2][0] = '{'; skob[0][1] = ')'; skob[1][1] = ']'; skob[2][1] = '}'; for (int i = 0 ; i < s.size() ; i++) { char c = s[i]; int curJ = -1, curK; for (int j = 0 ; j < 3 ; j++) { for (int k = 0 ; k < 2 ; k++) { if (skob[j][k] == c) { curJ = j, curK = k; break; } } if (curJ != -1) break; } if (curK == 1) { if (!st.sz || st.front() != skob[curJ][0]) { return false; } st.pop(); } else { st.push(c); } } return !st.sz; }
int main (void) { MyStack *pStack = new MyStack(5); pStack->push('a'); pStack->push('e'); pStack->push('i'); pStack->push('o'); pStack->push('u'); //pStack->clearStack(); pStack->stackTraverse(true); char elem = 0; pStack->pop(elem); cout << elem << endl; pStack->stackTraverse(true); cout << pStack -> stackLength() << endl; if(pStack->stackEmpty()){ cout << "栈为空" << endl; } if(pStack->stackFull()){ cout << "栈为满" << endl; } delete pStack; pStack = NULL; return 0; }
void char_test() { char next; MyStack<char> s; cout << "Enter some text\n"; // read characters in one by one until newline reached cin.get(next); while (next != '\n') { // push latest character s.push(next); cin.get(next); } cout << "Written backward that is:\n"; // output all characters stored in stack while (!s.empty()) cout << s.pop(); cout << "\n"; }
//先序 void MyTree::PreTraverse(TreeNode* pNode) { // if(pNode == NULL) // { // return; // } // // printf("%d ", pNode->m_Data); // PreTraverse(pNode->m_pLeft); // PreTraverse(pNode->m_pRight); MyStack<TreeNode*> ss; TreeNode* pCur = pNode; do { while(pCur) { printf("%d ", pCur->m_Data); ss.push(pCur); pCur = pCur->m_pLeft; } if(!ss.IsEmpty()) { pCur = ss.pop(); pCur = pCur->m_pRight; } }while(pCur || !ss.IsEmpty()); }
// 追加スタック数2 MyStack sortStack(MyStack stack) { MyStack ans(10), tmp(10); // 最小値を見つける while (!stack.isEmpty()) { int min = stack.peek(); while (!stack.isEmpty()) { int t = stack.peek(); stack.pop(); if (t <= min) { min = t; } tmp.push(t); } // 最小値を入れる while (!tmp.isEmpty()) { if (tmp.peek() == min) { ans.push(tmp.peek()); } else { stack.push(tmp.peek()); } tmp.pop(); } } return ans; }
void Graph<Tv, Te>::bcc(int s){ reset(); int clock = 0; int v = s; MyStack<int> S; //栈s用以记录已访问的顶点 do{ if(UNDISCOVERED == status(v) ){ //一旦发现未发现的顶点(新连通分量) BCC(v, clock, S); //即从该顶点触发启动一次BCC S.pop(); //遍历返回后,弹出栈中最后一个顶点---当前连通域的起点 } }while( s != (v = ( ++v % n))); }
int main(){ MyStack currStack; currStack.push(10); currStack.push(3); currStack.push(12); currStack.push(13); currStack.push(14); currStack.push(1); currStack.push(8); cout << currStack.max() << endl; cout << currStack.min() << endl; cout << "----" << endl; int data; //data = currStack.pop(); //data = currStack.pop(); data = currStack.pop(); cout << data << endl; cout << currStack.max() << endl; cout << currStack.min() << endl; cout << "----" << endl; data = currStack.pop(); cout << data << endl; cout << currStack.max() << endl; cout << currStack.min() << endl; cout << "----" << endl; data = currStack.pop(); cout << data << endl; cout << currStack.max() << endl; cout << currStack.min() << endl; cout << "----" << endl; data = currStack.pop(); cout << data << endl; cout << currStack.max() << endl; cout << currStack.min() << endl; cout << "----" << endl; return 0; }
int main() { MyStack<int> st; for (int i = 0; i < 100; i++) st.push(i); std::cout << st.size() << std::endl << std::endl; for (int i = 0; i < 10; i++) st.pop(); std::cout << st.size() << std::endl << std::endl; for (int i = 0; i < 10; i++) st.push(i); std::cout << st.size() << std::endl << std::endl; while (!st.empty()) { int k; st.top(k); std::cout << k << std::endl; st.pop(); } std::cout << st.size() << std::endl << std::endl; return 0; }
// 追加スタック数1 MyStack sortStack1(MyStack stack) { MyStack ans(10); while(!stack.isEmpty()) { int t = stack.peek(); stack.pop(); /// 要素がansのtopより小さい間,ansからstackに戻す while (!ans.isEmpty() && ans.peek() < t) { stack.push(ans.peek()); ans.pop(); } ans.push(t); } return ans; }
bool isExpression( string expressionCandidate, string &operations ) { MyStack<Token> stack; bool OK = true; for ( string::size_type index = 0 ; index < expressionCandidate.size() ; ++index ) //loop through each character in the string like an array //e.g. "(a+b)*c+b+c" will loop over one iteration per character: '(', 'a', '+', 'b', ')', etc. processChar( expressionCandidate[index], stack, operations, OK ); if ( !OK ) return false; // clean up any remaining addition operation collapse( stack, operations, OK ); // make sure only a single value remains return OK && !stack.isEmpty() && TOKEN_VALUE == stack.pop() && stack.isEmpty(); }
// remove one complete arithmetic operation, if it is there void collapse( MyStack<Token> &stack, string &operations, bool &OK ) { // It should end with a value if ( stack.isEmpty() || stack.top() != TOKEN_VALUE ) return; stack.pop(); // if that was the ONLY thing on the stack or it is preceeded by (, it is OK if ( stack.isEmpty() || TOKEN_LEFT_GROUP == stack.top() ) { stack << TOKEN_VALUE; return; } // The value should be preceeded with an operator Token operation; if ( stack.isEmpty() || !isOperator(operation = stack.pop()) ) { OK = false; return; } operations += ((operation==TOKEN_ADDITION) ? "+" : "*"); // The operator should be preceeded with a value if ( stack.isEmpty() || stack.pop() != TOKEN_VALUE ) { OK = false; return; } // sucessful collapse - to a single value stack << TOKEN_VALUE; }
bool StackWithMin::pop(int& d){ if(empty()) return false; d = head->data; Node* p = head; head = head->next; delete p; --size; if(d==minValue){ minS.pop(minValue); minS.top(minValue); if(minS.empty()) minValue = INT_MAX; } return true; }
void testStack() { MyStack s; for(int i = 1; i <= 10; i++) s.push(i); MyStack s2 = s; cout << "s:\n"; while (!s.empty()) cout << s.pop() << endl; MyStack s3; s3 = s; for(int i = 11; i <= 20; i++) s.push(i); cout << "s2:\n"; while (!s2.empty()) cout << s2.pop() << endl; cout << "Живи сме!\n"; }
int main(){ MyStack<int> a; MyQueue<int> c; a.push(4); a.push(5); cout << a.top() << endl; a.pop(); cout << a.top() << endl; c.enqueue(4); c.enqueue(5); cout << c.front() << endl; c.dequeue(); cout << c.front() << endl; }
void MyTree::RemoveAll() { MyStack ss; TreeNode *pCurNode = m_pRoot; TreeNode *pLastNode = NULL; while (true) { while (pCurNode != NULL) { ss.push(pCurNode); pCurNode = pCurNode->m_pLeft; } if (ss.IsEmpty()) { break; } pCurNode = ss.pop(); if (pCurNode->m_pLeft == NULL && pCurNode->m_pRight == NULL) { pLastNode = pCurNode; } else if (pCurNode->m_pRight == NULL || pCurNode->m_pRight == pLastNode) { pLastNode = pCurNode; Del(pCurNode); pCurNode = NULL; continue; } else { ss.push(pCurNode); pCurNode = pCurNode->m_pRight; continue; } TreeNode *pDelNode = pCurNode; pCurNode = pCurNode->m_pRight; Del(pDelNode); } }
/* Function: getFinalStacksResult() * Usage: is called by formulaStringScanning() at the end of current recursion. * -----------------------------------------------------------------------------------------// * Calculates main result, due to stacks, for current formulaStringScanning() recursion * stage. * Precondition: it's end of main formula string or brackets closed process. * * @param stackNumbers Stack of number values for current recursion * @param stackOperators Stack of operators for current recursion */ double getFinalStacksResult(MyStack<double> stackNumbers, MyStack<string> stackOperators) { /* Stacks elements validation checking for calculating process */ if((stackNumbers.size() - stackOperators.size()) != 1) { cout << " - CHECK YOUR INPUT, NOT ENOUGH NUMBERS IN FORMULA!" << endl; failFlag = true; } /* Lunches calculations for all remain values from stacks */ while(!stackOperators.isEmpty()) { if(failFlag) break;//Some fails appear during calculations /* Calculation for two top stack numbers and single top operator */ twoNumsProcess(stackNumbers, stackOperators); } /* If all operators are processed - end result value remains at top of numbers stack */ if(!failFlag) { return stackNumbers.pop(); } else { return 0; } }
//中序 void MyTree::MidTraverse(TreeNode* pNode) { MyStack<TreeNode*> ss; TreeNode* pCur = pNode; do { while(pCur) { ss.push(pCur); pCur = pCur->m_pLeft; } if(!ss.IsEmpty()) { pCur = ss.pop(); printf("%d ", pCur->m_Data); pCur = pCur->m_pRight; } }while(pCur || !ss.IsEmpty()); }
void Driver(MyStack<T> &listObject) { T max; cout << "Welcome to MyStack , Lets Get you started \n\n "; cout << "Ok , Lets get one thing straight how big must the Stack be : "; cin >> max; cout << "\n\nThank you ... Ready Steady Go .. \n\n"; //instruc(); int choice; T value; listObject.setMax(max); do { instruc(); cin >> choice; switch (choice) { case 1: cout << "Enter Your Value : "; cin >> value; listObject.push(value); system("cls"); listObject.peek(); break; case 2: listObject.pop(value); system("cls"); listObject.peek(); break; } } while (choice < 3); }
int main() { MyStack S; Queue Q; Q.enQueue(5); Q.enQueue(6); Q.enQueue(1); Q.enQueue(2); Q.enQueue(3); Q.enQueue(4); Q.enQueue(7); Q.enQueue(9); Q.display(); while(!Q.isEmpty()) S.push(Q.deQueue()); while(!S.isEmpty()) Q.enQueue(S.pop()); Q.display(); }
void Graph<Tv, Te>::BCC(int v, int &clock, MyStack<int> &S){ //assert: 0 <= v < n hca(v) = dTime(v) = ++clock; status(v) = DISCOVERED; S.push(v); //v被发现并入栈 for(int u = firstNbr(v); -1 < u; u = nextNbr(v, u)) //枚举v的所有邻居u switch(status(u)){ //并视u的状态分别处理 case UNDISCOVERED: parent(u) = v; type(v,u) = TREE; BCC(u, clock, S); //从顶点u处深入 if(hca(u) < dTime(v)) //遍历返回后, 若发现u(通过回边)可指向v的真祖先 hca(v) = min( hca(v), hca(u) ); //则v亦必如此 else{ //否则,以v为关节点(u以下即是一个BCC, 且其中顶点此时正集中于栈s的顶部) while( v != S.pop() ); //依次弹出当前BCC中的节点,亦可根据实际需求转存至其他结构 S.push(v); //最后一个顶点(关节点)重新入栈---总计至多两次 } break; case DISCOVERED: type(v, u) = BACKWARD; //标记(v,u), 并按照"越小越高"的准则 if( u != parent(v) ) hca(v) = min(hca(v), dTime(u)); //更新hca(v) break; default: //VISITED(digraphs only) type(v, u) = (dTime(V) < dTime(u) ? FORWARD : CROSS); break; } status(v) = VISITED; //对v的访问结束 }