C/C++基本数据结构：顺序表/链表堆栈

堆栈

一、基础数据结构

1.顺序表：数组，存储在连续的空间中，随机访问方便，空间要求高，插入删除效率低。

2.链表：数据存储在不连续的节点中，各节点彼此关联，空间利用率高，插入删除效率高，随机访问不方便。

二、堆栈

1.基本特征：后进先出。
2.基本操作：压入（push），弹出（pop）

3.实现要点：初始空间，栈顶指针，判空判满。

代码实现：

// 顺序表堆栈

#include <iostream>

using namespace std;

// 堆栈

class Stack {

public:

  // 构造函数

  Stack (size_t size = 10) : m_data (new int[size]), m_top (0), m_size (size) {}

  // 析构函数

  ~Stack (void) {

    if (m_data) {

      delete m_data;

      m_data = NULL;

    }

  }

  // 压入

  void push (int data) {

    if (m_top >= m_size)

      throw OverFlow ();

    m_data[m_top++] = data;

  }

  // 弹出

  int pop (void) {

    if (! m_top)

      throw UnderFlow ();

    return m_data[--m_top];

  }

  // 空否

  bool empty (void) {

    return ! m_top;

  }

private:

  // 上溢异常

  class OverFlow : public exception {

  public:

    const char* what (void) const throw () {

      return "堆栈上溢！";

    }

  };

  // 下溢异常

  class UnderFlow : public exception {

  public:

    const char* what (void) const throw () {

      return "堆栈下溢！";

    }

  };

  int* m_data; // 数组

  size_t m_top; // 栈顶

  size_t m_size; // 容量

};

int main (void) {

  try {

    Stack stack;

    for (size_t i = 0; i < 10; i++)

      stack.push (i);

    //stack.push (10);

    while (! stack.empty ())

      cout << stack.pop () << endl;

    //stack.pop ();

  }

  catch (exception& ex) {

    cout << ex.what () << endl;

    return -1;

  }

  return 0;

}

// 链表堆栈

#include <iostream>

using namespace std;

// 堆栈

class Stack {

public:

  // 构造函数

  Stack (void) : m_top (NULL) {}

  // 析构函数

  ~Stack (void) {

    for (Node* next; m_top; m_top = next) {

      next = m_top -> m_next;

      delete m_top;

    }

  }

  // 压入

  void push (int data) {

    m_top = new Node (data, m_top);

  }

  // 弹出

  int pop (void) {

    if (! m_top)

      throw UnderFlow ();

    int data = m_top -> m_data;

    Node* next = m_top -> m_next;

    delete m_top;

    m_top = next;

    return data;

  }

  // 空否

  bool empty (void) {

    return ! m_top;

  }

private:

  // 下溢异常

  class UnderFlow : public exception {

  public:

    const char* what (void) const throw () {

      return "堆栈下溢！";

    }

  };

  // 节点

  class Node {

  public:

    Node (int data = 0, Node* next = NULL) : m_data (data), m_next (next) {}

    int m_data;

    Node* m_next;

  };

  Node* m_top; // 栈顶

};

int main (void) {

  try {

    Stack stack;

    for (size_t i = 0; i < 10; i++)

      stack.push (i);

    //stack.push (10);

    while (! stack.empty ())

      cout << stack.pop () << endl;

    //stack.pop ();

  }

  catch (exception& ex) {

    cout << ex.what () << endl;

    return -1;

  }

  return 0;

}