C++ MyStack::top方法代码示例

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");
}

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

bool StackWithMin::push(int d){
	Node* p = new Node(d);
	p->next = head;
	head = p;
	++size;
	if(d<minValue){
		minS.push(d);
		minS.top(minValue);
	}
	return true;
}

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

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

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

int libFunc()
{
  MyStack s;
  return s.top();
}