stack(栈堆)

栈堆的一些探究

栈堆的原理与原则

栈（stack）在计算机科学中是限定仅在表尾进行插入或删除操作的线性表。栈是一种数据结构，它按照后进先出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据。栈是只能在某一端插入和删除的特殊线性表。用桶堆积物品，先堆进来的压在底下，随后一件一件往上堆。取走时，只能从上面一件一件取。读和取都在顶部进行，底部一般是不动的。栈就是一种类似桶堆积物品的数据结构，进行删除和插入的一端称栈顶，另一端称栈底。插入一般称为进栈，删除则称为退栈。 栈也称为后进先出表。
————百科

———维基百科
###栈堆的操作
pop
// 如果栈不为空，移除最后进栈的元素，即为
push
// 如果栈满，则不做操作

栈堆的实现(数组)

#include <iostream>
#include <string>
#include <cstring>
using namespace std;
class Sequence {
 public:
  Sequence();
  ~Sequence();
  int size();
  bool empty();
  bool find(int value);//能否找到这个value这个元素
  int &at(int pos);//返回第pos个元素
  int front(); //返回第一个字符
  int back(); //返回最后一个字符
  void insert(int value); //插入元素 value
  void insert(int pos, int value); //在pos之后插入元素value
  void clear();//变空
  void reverse(); //全部翻转
  void reverse(int fir, int las); //从哪里到哪里反转
  void replace(int value1, int value2);
  void swap(Sequence &seq2);//将类本身的序列和seq2交换
  int *a;
  int msize;
  bool mempty;
};
Sequence::Sequence() {
 a = new int[1000];
 msize = 0;
 mempty = true;
}
Sequence::~Sequence() {
  delete []a;
}

int Sequence::size() {
 return msize;
}

bool Sequence::empty() {
 return mempty;
}

bool Sequence::find(int value) {
 int i;
 for (i = 0; i < msize; i++) {
  if (a[i] == value) {
   return true;
  }
 }
 return false;
}

int &Sequence::at(int pos) {
 return a[pos];
}

int Sequence::front() {
 return a[0];
}

int Sequence::back() {
 return a[msize - 1];
}

void Sequence::insert(int value) {
 a[msize] = value;
 msize ++;
 mempty = false;
}

void Sequence::insert(int pos, int value) {
 int i;
 for (i = msize; i > pos; i--) {
  a[i] = a[i - 1];
 }
 a[pos] = value;
 msize++;
 mempty = false;
}

void Sequence::clear() {
 delete []a;
 a = new int[1000];
 msize = 0;
 mempty = true;
}

void Sequence::reverse() { 
 int i, temp;
 for (i = 0; i<= msize / 2 - 1; i++) {
  temp = a[i];
  a[i] = a[msize - 1 - i];
  a[msize - 1 - i] = temp;
 }
}
void Sequence::reverse(int fir, int las) { 
 int i, temp, j;
 for (i = fir, j = las - 1; i< fir + (las-fir)/ 2; i++,j--) {
  temp = a[i];
  a[i] = a[j];
  a[j] = temp;
 }
}
void Sequence::replace(int value1, int value2) {
 int i;
 for (i = 0; i < msize; i++) {
  if(a[i] == value1) {
   a[i] = value2;
  }
 }
}
void Sequence::swap(Sequence &seq2) {
 int  *b;
 b = a;
 int temp = msize;
 bool temp2 = mempty;
 a = seq2.a;
 seq2.a = b;
 msize = seq2.msize;
 mempty = seq2.mempty;
 seq2.msize = temp;
 seq2.mempty = temp2;
}

栈堆的实现(链表)

#include <iostream>
#include <cstdio>
using namespace std;
struct Node {
 int number;
 Node *next;
};

class myStack {
private:
 Node *mtop;
 int _size;
public:
 myStack();
 myStack(const myStack &stack);
 myStack(const int *arr, const int _size);
 ~myStack();
 bool empty() const;
 int top() const;
 bool pop();  
 bool push(int _number);
 int size() const;

 myStack& operator=(const myStack& stack);
 friend ostream& operator<<(ostream& out, const myStack& stack) {
  Node *t = stack.mtop;
 if (t == NULL) {
  out << "The stack is empty!";
  return out;
 }
 while (t != NULL) {
  out << t->number << ' ';
  t = t->next;
 }
 return out;
 };
};
myStack::myStack() {
    mtop = NULL;
    _size = 0;
}
myStack::myStack(const myStack &stack) {
    mtop = NULL;
    _size = 0;
    for (int i = 0; i < stack._size; ++i) {
        Node * p = stack.mtop;
        int temp = stack._size - i;
        for (int j = 0; j < temp - 1; --temp) {
            p = p->next;
        }
        push(p->number);
    }
}
myStack::myStack(const int *arr, const int _size) {
    mtop = NULL;
    this->_size = 0;
    for (int i = 0; i < _size; ++i) {
        push(arr[i]);
    }
}
myStack::~myStack() {
    Node * p;
    while (mtop != NULL) {
        p = mtop;
        mtop = mtop->next;
        delete p;
    }
}
bool myStack::empty() const {
    if (_size == 0) {
        return true;
    } else return false;
}
int myStack::top() const {
    if (mtop != NULL) {
        return mtop->number;
    }
}
bool myStack::pop() {
    Node * p;
    if (!empty()) {
        p = mtop;
        mtop = mtop->next;
        delete p;
        --_size;
    }
    return true;
}
bool myStack::push(int _number) {
    Node * temp = new Node;
    Node * p = mtop;
    if (temp == NULL) return false;
    temp->number = _number;
    temp->next = mtop;
    mtop = temp;
    ++_size;
    return true;
}
int myStack::size() const {
    return _size;
}
myStack& myStack::operator=(const myStack& stack) {
    mtop = NULL;
    _size = 0;
    for (int i = 0; i < stack._size; ++i) {
        Node * p = stack.mtop;
        int temp = stack._size - i;
        for (int j = 0; j < temp - 1; --temp) {
            p = p->next;
        }
        push(p->number);
    }
}

注意list对于赋值运算的重载