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;
}
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;
}
// 追加スタック数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);
}
}
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;
}
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;
}
}
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();
}
int main() {
MyStack s(10);
s.push(2);
s.push(0);
s.push(1);
s.push(1);
s.push(5);
s.push(4);
std::cout << "in: ";
s.printAll();
MyStack sorted = sortStack(s);
std::cout << "out: ";
sorted.printAll();
}
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;
}
int main (void)
{
char num[] = "0123456789ABCDEF";
MyStack<char> *pStack = new MyStack<char>(50);
int N = 10;
int mod = 0;
while (N != 0) {
mod = N % 16;
pStack->push(num[mod]);
N /= 16;
}
pStack->stackTraverse(false);
cout << endl;
delete pStack;
pStack = NULL;
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();
}
//前序遍历用循环实现
void CTree::PreOrderLoop(CTreeNode *lpRoot)
{
CTreeNode *lpCurt = lpRoot;
MyStack<CTreeNode*> stack;
while(1)
{
assert(lpCurt != NULL);
if (lpCurt != NULL)
{
cout << lpCurt->m_data << " ";
if (lpCurt->m_lpLeft != NULL)
{
if (lpCurt->m_lpRight)
{
stack.Push(lpCurt->m_lpRight);
}
lpCurt = lpCurt->m_lpLeft;
continue;
}
else
{
if (lpCurt->m_lpRight != NULL)
{
lpCurt = lpCurt->m_lpRight;
}
else
{
if (stack.Length() != 0)
{
lpCurt = stack.GetHead();
stack.Pop();
}
else
{
break;
}
}
continue;
}
}
else //(lpCurt == NULL)
{
}
}
}
int pop() {
while(!S1.isEmpty())
S2.push(S1.pop());
temp = S2.pop();
while(!S2.isEmpty())
S1.push(S2.pop());
return temp;
}
//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;
}
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;
}
}
