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的访问结束
}
