数据结构 栈的实现

根据某大学的教材，栈多用于递归(recursive)和多线程(multithread)，秉持先进后出(FILO)的原则，现在我要试着亲手实现一个基本的栈，基本的function应该有:

  • push()
  • pop()
  • peek()
  • isFull()
  • isEmpty() 顾名思义，isFull和isEmpty就是判断栈满栈空的的function，主要说下两个主要的函数，pop和push。以链表的形式定义一个struct来代表这个stack
struct elt {
  struct elt *next;int value;
};
typedef struct elt *Stack;

对于push来说主要做两件事情，第一先把此时stack指针指向的value赋值，第二部就是将指针指向next，具体代码如下：

void stackPush(Stack *s, int value)

{
    struct elt *e;
    e = malloc(sizeof(struct elt));
    assert(e);
     e->value = value;
     e->next = *s; *s = e;
}

那木pop呢，也很简单，就是将此时top的value取出来，再将next指向top的位置，而此时的next指向origin next的下一个，具体代码实现如下：

int stackPop(Stack *s){
    int ret;
    struct elt *e;
    assert(!stackEmpty(s));
    ret = (*s)->value;
    e = *s; *s = e->next;
    free(e);
    return ret;
}

第一题 集合栈

题目描述，实现将每个大小为给定size的栈填满，并且当当前栈填满时新建一个栈。 题目所给出的标准class 函数定义为:

class SetOfStacks {
public:
    vector<vector<int> > setOfStacks(vector<vector<int> > ope, int size) {
        // write code here
}

所以这题应该就是基本的入栈出栈，而所谓的“集合栈”就是另一层的入栈和出栈，最后的时候返回这个默认的”集合栈”。具体代码实现如下:

class SetOfStacks {
public:
    vector<vector<int> > setOfStacks(vector<vector<int> > ope, int size) {
        // write code here
        int ope_size;
        ope_size = ope.size();
        
        vector<vector<int> > setofstacks;
        vector<int> stacks;
        for(int i = 0;i<ope_size;i++){
            if(ope[i][0] == 1){
                if(stacks.size() == size ){
                    setofstacks.push_back(stacks);
                    stacks.clear();
                    stacks.push_back(ope[i][1]);
                }
                else
                    stacks.push_back(ope[i][1]);
            }
            else if(ope[i][0] == 2){
                if (stacks.size() != 0) {
                        stacks.pop_back();
                    }
                else{
                    stacks = setofstacks[setofstacks.size()-1];
                    stacks.pop_back();
                    setofstacks.pop_back();
                }
            }
        }
        if(!stacks.empty())
            setofstacks.push_back(stacks);
        return setofstacks;
    }
};
第二题 用两个栈实现队列

题目描述为用两个栈完成队列基本的pop和push 我没学过数据结构，所以还是先来看一下队列在数据结构的定义。 队列不一样的是先进先出(FIFO)，并且有指向head和tail的指针，下面为简单队列实现的struct定义：

struct elt {
    struct elt *next;
    int value;
};
struct queue {
    struct elt *head;
    struct elt *tail;
};
  typedef struct queue *q;

那么这道题目就变成了，怎样用两个实现先进后出stack来实现先进先出的队列形式，我认为很自然的就会想到，将其中一个队列用来将原本的数据倒序，以作为原本数据的先进先出，而倒序了的数据自然符合先进后出的原则。一下为实现代码：

class Solution
{
public:
    void push(int node) {
        stack1.push(node);
    }

    int pop() {
     int result;
        if(!stack2.empty())//判断是否为空，不为空那么说明已经压入了栈，倒序了stack1，直接pop就可以了
         {
            result=stack2.top();
            stack2.pop();
            return result;
         }
        else
        {  //不为空的话就需要重新压栈
            int num=stack1.size();
            for(int i=0;i<num;++i)
            {
                int temp=stack1.top();
                stack1.pop();
                stack2.push(temp);
            }                     
            result=stack2.top();
            stack2.pop();
            return result;
        }   
    }

private:
    stack<int> stack1;
    stack<int> stack2;
};

第三题 双栈排序

题目描述为将一个乱序排放的数据栈重新排序，最大的元素在栈的顶端。 既然有两个栈，那么实现方式应该和上一题大同小异，两个栈中的最顶元素进行比较和压栈出栈。首先，原始的数据链先pop_back()出最顶元素到新定义的栈中，当新定义的临时栈不为空时，每次循环比较最顶元素的大小，我天真的认为这个和数组中的冒泡法理想一样，通过多次的循环比较以达到排序。第一步新定义一个栈，并且pop_back()出原数据栈中的最顶元素:

vector<int> forSort;
        if(numbers.size() <= 1) return numbers;
        forSort.push_back(numbers.back());
        numbers.pop_back();

第二步，建立第一层循环，while loop直到比较到最先压入原数据栈的元素

while(numbers.size() > 0)
            {
                int temp = numbers.back();
                numbers.pop_back();
                int popNum = 0;  
            }

每一次首先拿出原数据栈中的最顶元素，以一个integer作为存储以便之后的比较，将此时最顶元素pop_back()。将取出来的原数据栈的顶层元素与届时的sort stack的顶层元素作比较，将更大的元素压入sort stack，而将较小的元素重新压回原数据栈，这样在最后把循环比较之后剩余在原数据栈中的所有元素按顺序一一压入sort stack数据栈中，这样最大的元素就最后压入最终返回的stack。示例代码如下：

while(!forSort.empty() && temp > forSort.back()){
                    numbers.push_back(forSort.back());
                    forSort.pop_back();
                    popNum++;
                }
                forSort.push_back(temp);
                while(popNum > 0){
                    forSort.push_back(numbers.back());
                    numbers.pop_back();
                    popNum--;
                }

第四题 猫狗收容所

题目描述，有两种收养方式，一个是收养所有最早进入收容所的动物，另一个是选择性的收养最早进入收容所的猫或者狗。 首先，最早意味着先进先出，所以应该选择队列的数据结构来做。 因为有猫狗两种动物，都有先进先出，所以第一步先将两个队列分别对应猫和狗定义。

queue<int> cat;
queue<int> dog;
vector<int> vec;

首先在循环内判断是入收养所还是被收养，也就是入还是出的问题:

if(ope[i][0] == 1)
            {
                //入收养所
            }
 else if (ope[i][0] == 2)
{
      //出收养所
}

情况很简单了，那么入收养所的时候只需要一个判断，是狗还是猫，出收养所的时候麻烦一些，第一步判断是哪种收养方式，若是第二种就只需要进一步看猫狗的选择直接在cat和dog两个定义的队列中pop最先进入的元素即可。若是第一种那么就需要比较了，在两个定义的队列中选取更早进入的一个。所以这就需要在每一次push到两个猫狗队列的同时，增加一个计数的index，完整的代码示例如下：

class CatDogAsylum {
public:
    vector<int> asylum(vector<vector<int> > ope) {
        // write code here
        queue<int> cat;
        queue<int> dog;
        queue<int> s
        vector<int> vec;
        int index=0;
        int size1=ope.size();
        for(int i=0;i<size1;i++)
        {
            int kind=ope[i][0];
            if(kind==1)
            {
                if(ope[i][1]>=0)
                {
                    dog.push(index++);
                    dog.push(ope[i][1]);
                }
                else
                {
                    cat.push(index++);
                    cat.push(ope[i][1]);
                }
            }
            else
            {
                if(ope[i][1]==0)
                {
                    int min=0;
                    if(cat.empty()&&!dog.empty())
                        min=1;
                    if(!cat.empty()&&dog.empty())
                        min=-1;
                    if(!cat.empty()&&!dog.empty())
                        min=dog.front()>cat.front()?-1:1;
                    if(min==-1)
                    {
                        cat.pop();
                        vec.push_back(cat.front());
                        cat.pop();
                    }
                    if(min==1)
                    {
                        dog.pop();
                        vec.push_back(dog.front());
                        dog.pop();
                    }
                }
                else
                {
                    if(ope[i][1]==1&&!dog.empty())
                    {
                        dog.pop();
                        vec.push_back(dog.front());
                        dog.pop();
                    }
                    if(ope[i][1]==-1&&!cat.empty())
                    {
                        cat.pop();
                        vec.push_back(cat.front());
                        cat.pop();
                    }
                }
 
            }
        }
        return vec;
    }
};