theory_lab2

#include <iostream>
#include <sstream>
#include <string>
#include <iomanip>

using namespace std;

struct Node {
    int data;
    Node* next;
    Node() : data(0), next(nullptr) {}
    explicit Node(int data): data(data), next(nullptr) {}
};

class Stack {
    static const int STACK_LENGTH = 10;
    Node* stack;
    int top;
    unsigned int size = 0;

public:
    Stack();
    ~Stack();
    void push(int);
    int pop();
    unsigned int getSize() const;
    bool isOrdered() const;
    void pushOrder(int);
    string toString() const;
    Stack operator+(Stack);
    void stackSort() {
        for (int i = 0; i < STACK_LENGTH; i++){
            for (int j = i+1; j < STACK_LENGTH; j++){
                if (stack[i].data < stack[j].data)
                {
                    int tmp = stack[i].data;
                    stack[i] = stack[j];
                    stack[j].data = tmp;
                }
            }
        }
    }
};

Stack::Stack() : top(-1) {
    stack = new Node[STACK_LENGTH];
}

Stack::~Stack() {
    delete stack;
}

void Stack::push(int i) {
    top++;
    size++;
    stack[top] = Node(i);
}

int Stack::pop() {
    if (top == -1) {
        cout << "Stack is empty!" << endl;
        return NULL;
    }

    int data = stack[top].data;
    //stack[top] = NULL;
    top--;
    size--;

    return data;
}

unsigned Stack::getSize() const {
    return size;
}

bool Stack::isOrdered() const {
    for (int i = 0; i < size; i++) {
        if (i != 0) {
            if (stack[i].data >= stack[i - 1].data) {
                return false;
            }
        }
    }
    return true;
}

void Stack::pushOrder(int input) {
    if(size != STACK_LENGTH) {
        if(isOrdered()) {
            int i=0;
            while (i < size && input < stack[i].data) i++;
            for (int j = size; j > i; j--) {
                stack[j] = stack[j - 1];
            }
            stack[i].data = input;
            size++;
            top++;
        } else {
            cout << "Stack is not ordered" << endl;
        }
    } else {
        cout << "Stack is full" << endl;
    }
}

string Stack::toString() const {
    stringstream ss;

    for (int i = 0; i < size; i++) {
        ss << setw(2) << stack[i].data;
    }

    ss << endl;

    return ss.str();
}

Stack Stack::operator+(Stack stackToMerge) {
    Stack resultStack;

    for (int i = 0; i < STACK_LENGTH; i++) {
        if (i % 2 == 0) {
            if (size > 0) {
                resultStack.push(pop());
            } else if (stackToMerge.getSize() > 0) {
                resultStack.push(stackToMerge.pop());
            }
        } else {
            if (stackToMerge.getSize() > 0) {
                resultStack.push(stackToMerge.pop());
            } else if (size > 0) {
                resultStack.push(pop());
            }
        }
    }

    return resultStack;
}

int main() {
    Stack firstStack;
    Stack secondStack;

    firstStack.push(1);
    firstStack.push(3);
    firstStack.push(5);
    firstStack.push(1);
    firstStack.push(7);
    firstStack.push(9);

    secondStack.push(2);
    secondStack.push(4);
    secondStack.push(6);
    secondStack.push(8);

    cout << "Merge" << endl;

    cout << "First Stack:" << firstStack.toString();
    cout << "Second Stack:" << secondStack.toString();

    Stack resultStack = firstStack + secondStack;

    cout << "Result Stack:" << resultStack.toString();

    cout << "Pop" << endl;

    cout << "pop two last elements" << endl;

    resultStack.pop();
    resultStack.pop();

    cout << "Stack: " << resultStack.toString();

    cout << "Size" << endl;

    cout << "size: " << resultStack.getSize() << endl;

    cout << "Sort" << endl;
    resultStack.stackSort();
    cout << "sorted: " << resultStack.toString() << endl;

    cout << "isOrdered?" << endl;

    cout << "isOrdered: " << (resultStack.isOrdered() == 1 ? "true" : "false") << endl;

    cout << "pushOrder" << endl;

    cout << "pushOrder 10" << endl;

    resultStack.pushOrder(10);

    cout << "Stack: " << resultStack.toString();

    return 0;
}