void printHistory(LinkedStack<LinkedStack<Point> >& history, ostream& os = cout) {
if (!history.empty()) {
Point x = history.pop().peek();
printHistory(history);
os << x << endl;
}
}
void printPath(LinkedStack<Point>& path, ostream& os = cout) {
if (!path.empty()) {
Point x = path.pop();
printPath(path, os);
os << x << endl;
}
}
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);
}
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;
}
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 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);
}
int main() {
int x;
LinkedStack<int> L;
L.Add(2).Add(1).Add(8);
cout << " Top element is " << L.Top() << endl;
L.Delete(x);
cout << " Element deleted is " << x << endl;
cout << " Top element is " << L.Top() << endl;
system("pause");
return 0;
}
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);
}
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> numbers;
try
{ for (int i=10; i < 100; i+=10) numbers.push(i);
while (!numbers.isEmpty()) cout << numbers.pop() << endl;
numbers.pop();
}
catch(StackEmptyException e)
{ cerr << e;
return 1;
}
return 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;
}
}
}
void sendSolution() {
file << "Process 0 : Sending Solutions\n";
LinkedStack<Kostra> tempStack;
tempStack.add(solution);
solution->toString();
Transfer * t = new Transfer(&tempStack);
for (int i = 0; i < worldSize; i++) {
//neposilej zpravu sam sobe
if (i == rank) continue;
MPI_Send(t->transfer, t->size, MPI_SHORT, i, SOLUTION_TRANSMIT, MPI_COMM_WORLD);
}
t->print();
delete t;
}
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 LinkedStack<T>::copy(LinkedStack<T> const& ls) {
/* !!! неправилно !!!
top = NULL;
while(!ls.empty())
push(ls.pop());
*/
if (ls.empty())
top = NULL;
else {
// първа стъпка
top = new StackElement<T>;
top->data = ls.top->data;
// подготовка за втората стъпка
StackElement<T>* toCopy = ls.top->next;
StackElement<T>* lastCopy = top;
while (toCopy != NULL) {
// копиране
StackElement<T>* newCopy = new StackElement<T>;
newCopy->data = toCopy->data;
// завързване
lastCopy->next = newCopy;
// подготовка за следващата стъпка
toCopy = toCopy->next;
lastCopy = newCopy;
}
// затваряме веригата
lastCopy->next = NULL;
}
}
int main()
{
int x;
LinkedStack<int> intStack;
for( int i = 0 ; i < 22 ; i++)
intStack.push( i*2);
intStack.printStack();
intStack.pop( x);
cout << "After pop" << endl;
intStack.printStack();
return 0;
}
void make_sum(int n, int m, LinkedStack<int>& x, LinkedStack<int>& y, LinkedStack<int>& z){
//Kristian: Следващите 3 функции са напълно на 100% излишни. Можеше да използваш 2 stack-а и да направиш следното:
/*
int carryOver = 0;
while(!stack1.empty() || !stack2.empty()){
int sum = stack1.top() + stack2.top() + carryOver;
carryOver = sum/10 >= 0 ? 1 : 0;
stack3.push(sum%10);
}
if(carryOver == 1)
stack3.push(1);*/
if(n < m) {
make_sum_small(n,m,x,y,z); ///Първото число е по-голямо от второто
}
else if (n > m){
make_sum_bigger(n,m,x,y,z); ///Второто число е по-голямо от първото
}
else {
make_sum_equel(n,m,x,y,z); ///Двете са равни
}
int p = 0;
if (n>m) p = n;
else p = m;
for(int i=0;i<p;i++){
cout<<z.pop();
}
}
bool CheckBox(int p[],int n)
{
LinkedStack<int> s;
int c;
for(int i=0;i<n;i++)
{
if(!s.IsEmpty())
{
if(s.Top()==p[i])
s.Delete(c);
else
s.Add(p[i]);
}
else
{
s.Add(p[i]);
}
}
if(s.IsEmpty())
return true;
else
return false;
}
/*
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;
}
bool is_balanced(string brackets)
{
if(brackets == "") return true;
LinkedStack ls;
for (unsigned i = 0; i < brackets.size() ; i++)
{
string c = brackets.substr(i,i+1);
if(c == "[" || c == "(" || c == "{")
{
ls.push(c);
}
else if(c == "]" )
{
if(ls.top() == "[")
{
ls.pop();
}
else return false;
}
else if(c == "}")
{
if(ls.top() == "{")
{
ls.pop();
}
}
else if( c == ")" )
{
if(ls.top() == "(")
{
ls.pop();
}
else return false;
}
else
{
if(ls.isEmpty()) return true;
}
}
if(ls.isEmpty()) return true;
return false;
}
/*
The main entry point for the program.
*/
int main ( int argc, const char * argv[] )
{
char input;
LinkedStack s;
while ( !cin.eof() )
{
cout << "Please enter a string." << endl;
while ( cin.get ( input ) && input != ( char ) '\n' )
{
s.push ( input );
}
while ( !s.isEmpty() )
{
cout << s.pop();
}
cout << endl;
}
}
int main()
{
LinkedStack<int> stack = LinkedStack<int>();
for (int i = 0; i < 10; i = i + 2)
{
stack.push(i);
std::cout << stack.peek() << std::endl;
}
try
{
for (int i = 0; i < 10; i++)
{
int topValue = stack.pop();
std::cout << topValue << std::endl;
}
}
catch (std::exception e)
{
std::cout << e.what() << std::endl;
}
return 0;
}
bool checkParentheses(char const* s) {
LinkedStack<char> stack;
char const* p = s;
while (*p != '\0') {
switch (*p) {
case '(':
case '[':
case '{':
case '<':
stack.push(*p);
break;
case ')':
case ']':
case '}':
case '>':
if (stack.empty() ||
!matchParentheses(stack.pop(), *p))
return false;
break;
}
p++;
}
return stack.empty();
}
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);
}
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;
}
bool isHtmlMatched(const vector<string>& tags) {
LinkedStack<string> S;
typedef vector<string>::const_iterator Iter;
for (Iter p = tags.begin(); p != tags.end(); ++p) {
if (p->at(1) != '/')
S.push(*p);
else {
if (S.empty()) return false;
string open = S.top().substr(1);
string close = p->substr(2);
if (open.compare(close) != 0) return false;
else S.pop();
}
}
if (S.empty()) return true;
else return false;
}
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);
}
}
int main()
{
bool stay = true;
// create one instance for each of the test classes
cout << "\nInstanciate an object of LinkedStack\n";
LinkedStack<string>* stackPtr = new LinkedStack<string>();
cout << "\nProgram started, \n"
<< " initiate the TEST DRIVER with a set of hard-wired data!\n"
<< "For example, \n"
<< " you may use this set of tokens as a default test case: \n"
<< " the, items, are, 123, 456, 789, and, abc";
string choice; // user input for choices
// initialize the LinkedStack class instances
stackPtr->push("the");
stackPtr->push("items");
stackPtr->push("are");
stackPtr->push("123");
stackPtr->push("456");
stackPtr->push("789");
stackPtr->push("and");
stackPtr->push("abc");
cout << "\n Use the P - peek command to view the stack.\n";
// main menu while
while(stay) { // main menu while starts
menu();
stay = true;
cin >> choice;
cin.ignore();
if(choice.size() == 1) {
char ch = choice[0];
vector<string> dump;
string value;
switch(ch) { // main menu switch starts
case 'd': // display stack
case 'D':
if(stackPtr->isEmpty()) {
cout << "\n Stack is empty.\n";
} else {
stackPtr->displayStack();
}
break;
case 'e': // is stack empty?
case 'E':
if(stackPtr->isEmpty())
{
cout << "\n The list is empty\n";
} else {
cout << "\n There are items in the stack\n";
}
break;
case 'i': // insert item
case 'I':
cout << " insert item: ";
cin >> value;
stackPtr->push(value);
break;
case 'r': // remove item
case 'R':
if(stackPtr->isEmpty())
{
cout << "\n The list is empty\n";
} else {
stackPtr->pop();
cout << "\n Top item removed.\n";
}
break;
case 'c': // clear stack
case 'C':
// to be completed by you;
if(stackPtr->isEmpty()) {
cout << "\n Stack already empty.\n";
} else {
stackPtr->clear();
}
break;
case 'p': // peek TOP value
case 'P':
cout << "\n The top value is: " << stackPtr->peek() << endl;
break;
case 'q': // quit main menu
case 'Q':
stay = false;
break;
default:
cout << "\nInvalid Selection!\nTry again!\n\n";
} // end of menu switch
} // only process single character
} // end of main menu while
LinkedStack<T> operator+(LinkedStack<T> ls, T const& y) {
ls.push(y);
return ls;
}
void horse_queue(Point start, Point end) {
LinkedQueue<Position> q;
q.enqueue(start);
board[start.first][start.second] = true;
Position current;
LinkedStack<LinkedQueue<Position> > history;
LinkedQueue<Position> level;
int currentMove = 0;
history.push(level);
while (!q.empty() && (current = q.dequeue()).p != end) {
if (current.move == currentMove) {
history.peek().enqueue(current);
} else {
// current.move == currentMove + 1
currentMove = current.move;
LinkedQueue<Position> level;
level.enqueue(current);
history.push(level);
}
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.p.first + dx,
current.p.second + dy);
Position newposition(newstart, current.move + 1);
if (inside_board(newstart)
&&
!board[newstart.first][newstart.second]) {
q.enqueue(newposition);
clog << newposition << endl;
board[newstart.first][newstart.second] = true;
}
}
}
// current == end -- успех
// q.empty() -- неуспех
clog << history;
history.pop();
if (current.p == end) {
cout << "Успех за " << current.move << " хода!" << endl;
LinkedStack<Point> path;
path.push(current.p);
while(!history.empty()) {
// в history.peek() търсим първата позиция position,
// за която isValidMove(current.p,position.p)
Position position;
while (!isValidMove(current.p,
(position = history.peek().dequeue()).p));
// знаем, че isValidMove(current.p,position.p)
// добавим position в пътя
path.push(position.p);
history.pop();
current = position;
}
cout << path << endl;
}
else
cout << "Неуспех!" << endl;
}