Positive integer N as the sum of positive integers using stack - c++

Question

So, I am working on this project, where we have to write a positive integer number n as the of positive integers. And all solutions should be ordered, for instance:
n = 3
1: 1 1 1
2: 1 2
3: 3
n = 5
1: 1 1 1 1 1
2: 1 1 1 2
3: 1 1 3
4: 1 2 2
5: 2 3
7: 5
I got (I think) very good algorithm on paper; yet, I have a trouble putting it into the code. The first time it gets into the inner do-while loop it runs smoothly, but then 'top' doesn't get a right value from the getTop function.
Here is my Stack.h file
#include <iostream>
using namespace std;
template <class T>
class Stack
{
private:
// Structure for the stach nodes
struct StackNode
{
T value; // Value in the node
StackNode *next; // Pointer to next node
};
StackNode *top; // Pointer to the stack top
int count;
public:
//Constructor
Stack(){top = NULL; count = 0;}
// Destructor
~Stack();
// Stack operations
bool push(T);
bool pop(T &);
bool isEmpty();
int getCount();
int getTop();
void print();
};
template <class T>
Stack<T>::~Stack()
{
StackNode *currNode, *nextNode;
// Position nodePtr at the top of the stack.
currNode = top;
// Traverse the list deleting each node.
while (currNode) //while (currNode != NULL)
{
nextNode = currNode->next;
delete currNode;
currNode = nextNode;
}
}
template <class T>
bool Stack<T>::push(T item)
{
StackNode *newNode; // Pointer to a new node
// Allocate a new node and store num there.
newNode = new StackNode;
if (!newNode)
return false;
newNode->value = item;
// Update links and counter
newNode->next = top;
top = newNode;
count++;
return true;
}
template <class T>
bool Stack<T>::pop(T &item)
{
StackNode *temp; // Temporary pointer
// empty stack
if (count == 0)
return false;
// pop value off top of stack
item = top->value;
temp = top->next;
delete top;
top = temp;
count--;
return true;
}
template <class T>
bool Stack<T>::isEmpty()
{
return count == 0;
}
template <class T>
int Stack<T>::getCount()
{
return count;
}
template <class T>
int Stack<T>::getTop()
{
if (this->top->next == NULL)
{
cout << "EXCEPTION" << endl;
}
else
{
return this->top->next->value;
}
//return top->value;
}
template <class T>
void Stack<T>::print()
{
StackNode *newNode;
newNode = top;
for (int i = count; i > 0; i--)
{
cout << newNode -> value;
cout << " ";
newNode = newNode -> next;
}
}
#endif
and here is my main.cpp
#include <iostream>
#include "Stack.h"
using namespace std;
int main()
{
int input = 0;
int counter = 0;
int pop1 = 0;
int pop2 = 0;
int top;
int CurrSum = 0;
Stack<int> *stack = new Stack<int>;
Stack<int> *tmpStack = new Stack<int>;
cout << "Please enter a integer: " << endl;
cin >> input;
while(input < 0)
{
cout << "Please enter a POSITIVE integer: " << endl;
cin >> input;
}
if ( input != 0)
{
counter ++;
for (int n = 1; n <= input; n ++)
{
stack -> push(1);
}
do
{
do
{
top = stack->getTop();
pop1 = stack->pop(top);
top = stack->getTop();
pop2 = stack->pop(top);
//increment the pop2 and push it back
stack->push(pop2 + 1);
top = stack->getTop();
CurrSum = CurrSum - pop1 - pop2 + top;
if (CurrSum < input)
{
stack->push(top);
CurrSum = CurrSum + top;
}
else if (CurrSum > input)
{
pop1 = stack->pop(top);
top = stack->getTop();
pop2 = stack->pop(top);
CurrSum = CurrSum - pop1 - pop2 + top;
}
}while (CurrSum == input);
cout << counter << ": ";
stack->print();
top = stack->getTop();
}while (top != input);
system("pause");
}
else
cout << "Thank you for using this program. Bye!" << endl;
return 0;
}

Answer 1

First, you do not need to write that Stack class for yourself, it's already done for you: it's called std::stack, and does exactly what you need. Second, you really don't need to dynamically allocate it, whether you use your own Stack or std::stack, though it does the same functionally, it is less efficient to allocate dynamically.
If that still doesn't work, you can now be sure that your algorithm is wrong (I didn't check it). Since it is a typical recursive problem, I'd try writing it recursively (now you don't need a Stack class at all), since recursive algorithms like this are usually easier to understand when you write them recursively. Later you can rewrite it iteratively if you want, once you understand what went wrong.