C++ LinkedStack::push方法代码示例

void make_sum_small(int n, int m, LinkedStack<int>& x, LinkedStack<int>& y, LinkedStack<int>& z){
  //81094: Confusing bracket alignment within this function.
  int data = 0;
  for(int i=0;i<n;i++){
    data += x.pop() + y.pop();
    if(data < 10){
        z.push(data);
        data = 0; }
    else {
        z.push(data%10);
        data = 1;
    }
}   int result = data;
    while(!y.empty()){
    result += y.pop();
    if (result >= 10){
    z.push(result % 10);
    result = 1;
    }
    else {
    z.push(result);
    result = 0;
    }
}
}

void make_sum_bigger(int n, int m, LinkedStack<int>& x, LinkedStack<int>& y, LinkedStack<int>& z){
int data_f = 0;
  for(int i=0;i<m ;i++){                       //Събира двета числа до позицията на по-малко
    data_f += x.pop() + y.pop();               //
    if(data_f < 10){
        z.push(data_f);
        data_f = 0; }
    else {
        z.push(data_f%10);
        data_f = 1;
    }
}
    int result = data_f;                  // и прехвърля останалите цифри (+1 ако има едно на ум) от по-голямото число в стека с резултата
    while(!x.empty()){
    result += x.pop();
    if (result >= 10){
    z.push(result % 10);
    result = 1;
    }
    else {
    z.push(result);
    result = 0;
    }
}
}

bool horse_rec(Point start, Point end,
			LinkedStack<Point>& path) {
	if (start == end) {
		path.push(end);
		cout << "Успех!" << endl;
		printPath(path);
		return true;
	}
	if (board[start.first][start.second])
		return false;
	board[start.first][start.second] = true;
	path.push(start);
	// !!! cout << start << endl;
	for(int dx = -2; dx <= 2; dx++)
		if (dx != 0)
			for(int sign = -1; sign <= 1; sign += 2) {
				int dy = sign * (3 - abs(dx));
				Point newstart(start.first + dx,
						       start.second + dy);
				if (inside_board(newstart) &&
					horse_rec(newstart, end, path))
					return true;

			}
	path.pop();
	return false;
}

void testPointStack() {
	LinkedStack<Point2D<int> > s;
	s.push(Point2D<int>(1, 2));
	s.push(Point2D<int>(2, 3));
	s.push(Point2D<int>(3, 4));
	while (!s.empty())
		cout << s.pop();
}

void testStackTemplate() {
	LinkedStack<double> ls;
	ls.push(1.8);
	cout << ls.pop() << endl;

	LinkedStack<Point2D<double> > sp;
	Point2D<double> p(1,2);
	sp.push(p);
}

void testStackStack() {
	LinkedStack<LinkedStack<Rational> > ss;
	for(int i = 1; i <= 10; i++) {
		LinkedStack<Rational> s;
		for(int j = 1; j <= 10; j++) {
			Rational r(i * j, (i+1)*(j+1));
			s.push(r);
		}
		ss.push(s);
	}
	cerr << ss;
}

int main() {

	LinkedStack<int> testLinkedStack;

	std::cout << "testLinkedStack.isEmpty() : " << testLinkedStack.isEmpty() << std::endl;
	std::cout << "testLinkedStack.getAllocatedSize() : " << testLinkedStack.getAllocatedSize() << std::endl;
	std::cout << "testLinkedStack.getSize() : " << testLinkedStack.getSize() << std::endl;

	testLinkedStack.push(5);
	testLinkedStack.push(6);
	testLinkedStack.push(7);
	testLinkedStack.push(9);
	testLinkedStack.push(10);

	std::cout << testLinkedStack.peek() << std::endl;

	int a = testLinkedStack.peek();
	testLinkedStack.pop();
	std::cout << a << std::endl;

	std::cout << testLinkedStack.peek() << std::endl;

	a = testLinkedStack.peek();
	testLinkedStack.pop();
	//testLinkedStack.pop(a);
	std::cout << a << std::endl;

	std::cout << testLinkedStack.peek() << std::endl;

	LinkedStack<int> testLinkedStack_2;
	testLinkedStack_2 = testLinkedStack;

	std::cout << testLinkedStack_2.peek() << std::endl;

	std::cout << "testLinkedStack.getSize() : " << testLinkedStack.getSize() << std::endl;

	testLinkedStack.clean();
	std::cout << "testLinkedStack.getSize() : " << testLinkedStack.getSize() << std::endl;
	std::cout << testLinkedStack.getAllocatedSize() << std::endl;

	testLinkedStack.push(5);
	testLinkedStack.push(6);
	std::cout << "testLinkedStack.getSize() : " << testLinkedStack.getSize() << std::endl;
	std::cout << testLinkedStack.peek() << std::endl;


	return 0;
}

void  make_sum_equel(int n, int m, LinkedStack<int>& x, LinkedStack<int>& y, LinkedStack<int>& z){

    int data_s = 0;                            ///пази допълнителната еденица
      for(int i=0;i<m-1;i++){
    data_s += x.pop() + y.pop();
    if(data_s < 10) {
        z.push(data_s);
        data_s = 0; }
    else {
        z.push(data_s %10);
        data_s = 1;
    }
}
  data_s += x.pop() + y.pop();
  z.push(data_s);
}

bool isBalanced(string brackets)		//O(N)
{
	LinkedStack bal = LinkedStack();
	int c1=0, c2=0, c3=0;
	string check;
	for(int i=0; i< brackets.size(); i++)
	{
		bal.push(brackets.substr(i,1));
	}
	
	for(int j=0; j<brackets.size(); j++)
	{
		check=bal.pop();
		if(check=="(") --c1;
		else if(check==")") ++c1;
		else if(check=="{") --c2;
		else if(check=="}") ++c2;
		else if(check=="[") --c3;
		else if(check=="]") ++c3;

		if(c1<0||c2<0||c3<0) return false;
	}
	//cout<<"c1: "<<c1<<" c2: "<<c2<<" c3: "<<c3<<endl;
	return (c1==0&&c2==0&&c3==0); 
}

void expressionMain() {
    LinkedStack expressionNum;
    LinkedStack expressionOp;
    int choice = 1, num;
    string op, expression = "", numS;
    stringstream ss;
    cout << "Please enter your expression one character at a time." << endl;
    cout << "num:";
    num = enterNum();
    ss << num;
    ss >> numS;
    expression += numS;
    expressionNum.push(num);
    while (choice != 3) {
        switch (choice) {
            case 1: cout << "op:";
                    op = enterOp();
                    cout << "num:";
                    num = enterNum();
                    ss.clear();
                    ss << num;
                    ss >> numS;
                    expression += op + numS;
                    if (!expressionOp.empty() && opSize(expressionOp.top()) >= opSize(op)) {
                        eval(expressionOp,expressionNum);
                        if (!expressionOp.empty() && opSize(expressionOp.top()) >= opSize(op)) {
                            eval(expressionOp,expressionNum);
                        }
                        expressionOp.push(op);
                        expressionNum.push(num);
                    }
                    else {
                        expressionOp.push(op);
                        expressionNum.push(num);
                    }
                    cout << "Expression: " << expression << endl;
                    cout << "More(1),Quit(2)?: ";
                    cin >> choice;
                break;
            case 2: while (!expressionOp.empty())
                        eval(expressionOp,expressionNum);
                    cout << "Answer: " << expressionNum.top2() << endl;
                    choice = 3;
        }
    }
    
}

bool Railroad(int inputOrder[], int numberOfCars, int numberOfTracks) {
    LinkedStack *holdingTracks = (LinkedStack *)malloc(numberOfTracks*sizeof(LinkedStack));
    for (int i=0; i < numberOfTracks; i++) {
        holdingTracks[i] = LinkedStack();
    }
    LinkedStack *outputTrack = new LinkedStack();
    ostringstream railroadMoves;              // stores the "moves" of each railroad car permutation

    int nextCar = 1;
    int index = numberOfCars - 1;
    int currentCar = inputOrder[index];
    
    while (nextCar <= numberOfCars) {
        if (index >= 0) {
            currentCar = inputOrder[index];
            
            // send car straight to output
            if (currentCar == nextCar) {
                outputTrack->push(currentCar);
                railroadMoves << "Move car " << currentCar << " from input to output" << endl;
                nextCar++;
                index--;
            
                // try to output from holding tracks
                if (outputFromHoldTrack(numberOfTracks, nextCar, outputTrack, holdingTracks, railroadMoves)) {
                    nextCar++;
                }
            }
        
            else {
                // if car cannot be sent straight to ouptut, put car in holding track
                if (putInHold(currentCar, numberOfTracks, holdingTracks, railroadMoves)) {
                    index--;
                }
                // output from holding tracks
                else if (outputFromHoldTrack(numberOfTracks, nextCar, outputTrack, holdingTracks, railroadMoves)) {
                    nextCar++;
                }
                // if none of the above work, return error
                else {
                    cout << "permutation ";
                    for (int i=0; i< numberOfCars; i++) {
                        cout << inputOrder[i];
                    }
                    cout << " not feasible" << endl;
                    return false;
                }
            }
        }
        else {
            // try to output from holding tracks
            if (outputFromHoldTrack(numberOfTracks, nextCar, outputTrack, holdingTracks, railroadMoves)) {
                nextCar++;
            }
        }
    }
    cout << railroadMoves.str();           // print moves if permutation is feasible
    return true;
}

void generate_numbers(int n, int m, LinkedStack<int>& first, LinkedStack<int>& second){
   int random_f, random_s;
   for (int i=0;i<n;i++){                   ///Представяне със свързан стек като всяка кутийка пази едноцифрено число
    if(i==0){
        random_f = rand() %9 + 1;
        first.push(random_f);
    }
    else {
        random_f = rand() %10;
        first.push(random_f);
    }
   }

    for (int i=0;i<m;i++){
    if(i==0){
        random_s = rand() %9 + 1;
        second.push(random_s);
    }
    else {
        random_s = rand() % 10;
        second.push(random_s);
    }
   }
LinkedStack<int> copy_of_first ;
LinkedStack<int> copy_of_second ;
LinkedStack<int> help = first;

 cout<<"First number: ";                   ///обръщане на стека, използвайки помощен стек
 for(int i=0; i<n; i++){
    copy_of_first.push(help.pop());
 }
 for(int i=0; i<n; i++){
    cout<<copy_of_first.pop();
 }
 cout<<endl;
 cout<<"Second number: ";
 help = second;
 for(int i=0; i<m; i++){
    copy_of_second.push(help.pop());
 }
 for(int i=0;i<m;i++){
    cout<<copy_of_second.pop();
 }
cout <<endl;
}

void horse_stack(Point start, Point end) {
	LinkedStack<LinkedStack<Point> > history;
	LinkedStack<Point> startStack;
	ofstream clog("log.txt");
	startStack.push(start);
	history.push(startStack);
	while (!history.empty() &&
			(history.peek().empty() || history.peek().peek() != end)) {
		if (history.peek().empty()) {
			// Стъпка назад
			history.pop();
			if (!history.empty())
				history.peek().pop();
			clog << "Стъпка назад" << endl;
		}
		else {
			// стъпка напред
			Point current = history.peek().peek();
			clog << "Стъпка напред: " << current << endl;
			LinkedStack<Point> possibleMoves;
			board[current.first][current.second] = true;
			for(int dx = -2; dx <= 2; dx++)
				if (dx != 0)
					for(int sign = -1; sign <= 1; sign += 2) {
						int dy = sign * (3 - abs(dx));
						Point newstart(current.first + dx,
									   current.second + dy);
						if (inside_board(newstart)
							&&
							!board[newstart.first][newstart.second])
							possibleMoves.push(newstart);
					}
			LinkedStack<Point> pm(possibleMoves);
			clog << "---\n";
			printPath(pm,clog);
			clog << endl << "---\n";
			history.push(possibleMoves);
		}
	}
	if (!history.empty() && !history.peek().empty()) {
		cout << "Успех:\n";
		printHistory(history);
	}
}

/*
The main entry point for the program.
*/
int main ( int argc, const char * argv[] )
{
    cout << "Jim Counts" << endl;
    cout << "CS 542 Homework 2" << endl << endl;

    LinkedStack s;

    cout << "Test Memento" << endl;
    print_stack("Empty Stack:", s);

    LinkedStackMemento * empty = s.createMemento();
    s.push('t');
    print_stack("One: ", s);

    LinkedStackMemento * one = s.createMemento();
    s.push('a');
    s.push('c');
    for(char c = 'A'; c <= 'Z'; ++c)
    {
        s.push(c);
    }
    print_stack("Full: ", s);

    LinkedStackMemento * full = s.createMemento();

    cout << "Restore Empty" << endl;
    s.restore(empty);
    print_stack("Restored Empty:", s);

    cout << "Restore Full" << endl;
    s.restore(full);
    print_stack("Restored Full:", s);

    cout << "Restore One" << endl;
    s.restore(one);
    print_stack("Restored One:", s);

    cout << "Done" << endl;

    delete empty;
    delete one;
    delete full;
}

void testCopy() {
	LinkedStack<int> s;
	for(int i = 1; i <= 10; i++)
		s.push(i);
	LinkedStack<int> s2 = s + 11 + 12;
	LinkedStack<int> s3 = s;
	s3 = 15 + s2;
	printStack(s);
	printStack(s2);
	printStack(s3);
}