牛客网初级算法之三

题目一： 用数组结构实现大小固定的队列和栈 

/*
 用数组结构实现大小固定的队列和栈
 */
//实现栈，
class MyStack {
public:
    MyStack(int _initSize){
        num = new int[_initSize];
        size=0;
        initSize = _initSize;
    }
    ~MyStack(){
        delete [] num;
    }
    
    void push(int input){
        if(size>=initSize){
            printf("栈已经满了\n");
            return;
        }
        num[size++]=input;
    }
    int pop(){
        if(size<=0){
            printf("栈已经空了\n");
            return 0;
        }
        return num[--size];
    }
    
    
private:
    int *num;
    int size;
    int initSize;
};
/*
 队列
 使用两根指针，分别指向“队头”和“队尾”，size记录“队列”中的元素个数。
 每次新来的元素都存在end指针所指向的位置。每次执行出队操作的时候，如果size的值不为零，则把start所指的元素弹出。利用size将start和end进行解耦
 */

class ArrayQueue {
public:
    ArrayQueue(int _initSize){
        arr = new int[_initSize];
        size=0;
        first=0;
        last=0;
        initSize = _initSize;
    }
    void push(int obj){
        if(size==initSize){
            printf("元素已满\n");
            return;
        }
        size++;
        arr[last] = obj;
        last = (last == initSize-1?0:last+1);
    }
    int pop(){
        if(size==0){
            printf("元素已空\n");
            return -1;
        }
        size--;
        int tmp = first;
        first = (first == initSize-1?0:first+1);
        return arr[tmp];
    }
private:
    int *arr;
    int size;
    int initSize;
    int first;
    int last;
};

题目二：用栈实现队列和用队列实现栈

1 用栈实现队列

原则：

1、push栈向pop栈倒数据，一定要把push栈倒空；

2、如果pop栈非空，则不允许push栈向pop栈倒数据；

class MyQueue {
private:
    stack<int>pushStack, popStack;
public:
    void push(int num);
    void pop();
    int peak();
    bool empty();
};

void MyQueue::push(int num) {
    pushStack.push(num);
}

void MyQueue::pop() {
    if (popStack.empty()) {
        if (pushStack.empty()) {
            cout << "queue is empty" << endl;
            return;
        }
        while (!pushStack.empty()) {
            popStack.push(pushStack.top());
            pushStack.pop();
        }
    }
    popStack.pop();
}

int MyQueue::peak() {
    if (popStack.empty()) {
        if (pushStack.empty()) {
            cout << "queue is empty" << endl;
            return;
        }
        while (!pushStack.empty()) {
            popStack.push(pushStack.top());
            pushStack.pop();
        }
    }
    return popStack.top();
}

bool MyQueue::empty() {
    if (pushStack.empty() && popStack.empty()) return true;
    else return false;
}

2 用队列实现栈

原则：

1 建立一个入栈队列和一个帮助队列，入站的时候只向入栈队列中加入数据
2 出栈的时候，除了入栈队列的最后一个元素之外，其余的加入帮助队列，出栈之后，
交换入站队列和帮助队列的指向

class MyStack {
public:
    MyStack(){
        que = new queue<int>();
        help = new queue<int>();
    }
    ~MyStack(){
        delete que;
        delete help;
    }
    void push(int pushInt){
        que->push(pushInt);
    }
    int pop(){
        if(que->empty()){
            printf("栈已经空了\n");
            return -1;
        }
        while (que->size()!=1) {
            int t = que->front();
            help->push(t);
            que->pop();
        }
        int res = que->front();
        que->pop();
        swap();
        return res;
    }
    int peek(){
        if(que->empty()){
            printf("栈已经空了\n");
            return -1;
        }
        while (que->size()!=1) {
            int t = que->front();
            help->push(t);
            que->pop();
        }
        int res = que->front();
        help->push(res);
        swap();
        return res;
    }
private:
    void swap(){
        queue<int>* temp = que;
        que=help;
        help=temp;
    }
    queue<int>*que;
    queue<int>*help;
    
};