C++ MyStack类代码示例

int Graph::_GetComponentAff(double *A,int size,bool * node_list,int i,int * row)
{
	MyStack * stack;
	int n=0,j,tmp,k;

	stack = new MyStack(size);
	row[n++] = i;
	stack->stack_push(i,0);

	while(stack->stack_pop(&j,&tmp)!=-1)
	{
		for(k=0;k<size;k++)
		{
			if(A[j*size+k]>0.0000001 && node_list[k]==false)
			{
				row[n++] = k;
				stack->stack_push(k,0);
				node_list[k] = true;
			}
		}
	};
	row[n] = -1;

	delete stack;
	return n+1;
}

int Graph::_GetComponent(int i,int * row)
{
	MyStack * stack;
	int n=0,j,tmp,result[1000],result_e[1000],neib_no=0,k;

	stack = new MyStack;
	row[n++] = i;
	stack->stack_push(i,0);

	while(stack->stack_pop(&j,&tmp)!=-1)
	{
		neib_no = GetNeighborNodeAndEdge(j, result,result_e);
		for(k=0;k<neib_no;k++)
		{
			if(node_list[result[k]].color==0 && edge_list[result_e[k]].weight > 0.5)  // hasn't been dried
			{
				row[n++] = result[k];
				stack->stack_push(result[k],0);
				node_list[result[k]].color=1;
			}
		}
	};
	row[n] = -1;
	delete stack;
	return 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());
  
}

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

}

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

// reachability test, from ni -> nj, according to weight
bool Graph::Reachable(int ni, int nj)
{
	MyStack * stack;
	int tmp,result[1000],result_e[1000],neib_no=0,k;
	int nt,i;

	for(i=0;i<node_num;i++)
		NODE_PTR(i)->color = 0;

	stack = new MyStack;
	stack->stack_push(ni,0);
	NODE_PTR(i)->color = 1;

	while(stack->stack_pop(&nt,&tmp)!=-1)
	{
		neib_no = GetNeighborNodeAndEdge(nt, result,result_e);
		for(k=0;k<neib_no;k++)
		{
			if(result[k]==nj && EDGE_PTR(result_e[k])->weight > 0.5)
			{
				delete stack;
				return true;
			}
				
			if(NODE_PTR(result[k])->color==0 && EDGE_PTR(result_e[k])->weight > 0.5)  // hasn't been dried
			{
				stack->stack_push(result[k],0);
				NODE_PTR(result[k])->color=1;
			}
		}
	};
	delete stack;

	return false;
}

/* Function: sortTokenByStacks()
 * Usage: is called by formulaStringScanning() for single token;
 * -----------------------------------------------------------------------------------------//
 * Sort this token through the stacks. If token is number - push it to stackNumbers.
 * If token is valid operator token - process it due to Shunting-Yard conditions.
 *
 * @param token             Current token in formula string
 * @param stackNumbers      Stack of number values for current recursion
 * @param stackOperators    Stack of operators for current recursion */
void sortTokenByStacks(string token,
                       MyStack<double> &stackNumbers,
                       MyStack<string> &stackOperators) {
    if(stringIsDouble(token)) { //Token is number
        double num = stringToDouble(token);
        stackNumbers.push(num);//Just save token to stack
    } else { // Token is operator
        /* Main operators process */
        if(stackOperators.isEmpty()) { //Empty - push there without conditions
            stackOperators.push(token);
        } else { //If there are some operators in stack
            string topOper = stackOperators.peek();//Get top operator
            if(getOperPrecedence(topOper) < getOperPrecedence(token)) {
                /* Top operator precednce is
                 * weaker then this token operator - just save this token */
                stackOperators.push(token);
            } else {
                /* Top operator precednce is higher - evaluate two top numbers
                 * with top operator, and sort current token again */
                if(!failFlag) { //If there some fails - break this function
                    /* Main calculation for top numbers and top operator  */
                    twoNumsProcess(stackNumbers, stackOperators);
                    /* Call sorting again to process current token operator  */
                    sortTokenByStacks(token, stackNumbers, stackOperators);
                }
            }
        }
    }
}

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

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

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<int> stack;
	for(int i=0;i<10;i++)
		stack.Push(i);
	for(i=0;i<10;i++)
		cout<<stack.Pop()<<endl;
	return 0;
}

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

// 追加スタック数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;
}

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