栈 stack 用数组实现

最新推荐文章于 2022-05-29 20:45:49 发布

原创最新推荐文章于 2022-05-29 20:45:49 发布 · 1.2k 阅读

2 ·

CC 4.0 BY-SA版权

数据结构_基础篇专栏收录该内容

12 篇文章

订阅专栏

本文详细介绍了如何使用数组来实现栈数据结构，重点讨论了栈的基本操作，包括压入元素、弹出元素和查看栈顶元素。通过实例展示了整数操作在栈中的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

整数：

#ifndef STACK_H
#define STACK_H

class StackOfIntegers{
public:
    StackOfIntegers();
    bool empty();
    int peek();
    void push(int value);
    int pop();
    int getSize();
private:
    int elements[100];
    int size;
};

StackOfIntegers::StackOfIntegers(){
    size = 0;
}

bool StackOfIntegers::empty(){
    return (size == 0);
}

int StackOfIntegers::peek(){
    return elements[size - 1];
}

void StackOfIntegers::push(int value){
    elements[size++] = value;
}

int StackOfIntegers::pop(){
    return elements[--size];
}

int StackOfIntegers::getSize(){
    return size;
}

#endif // STACK_H_INCLUDED

使用模板

#ifndef STACK_H
#define STACK_H

template <typename T>
class Stack{
public:
    Stack();
    bool empty();
    T peek();
    void push(T value);
    T pop();
    int getSize();
private:
    T elements[100];
    int size;
};

template <typename T>
Stack<T>::Stack(){
    size = 0;
}

template <typename T>
bool Stack<T>::empty(){
    return (size == 0);
}

template <typename T>
T Stack<T>::peek(){
    return elements[size - 1];
}

template <typename T>
void Stack<T>::push(T value){
    elements[size++] = value;
}

template <typename T>
T Stack<T>::pop(){
    return elements[--size];
}

template <typename T>
int Stack<T>::getSize(){
    return size;
}


#endif // STACK_H

stack例子

#include <iostream>
#include <string>
#include "GenericStack.h"

using namespace std;

template<typename T>
void printStack(Stack<T> &stack){ //定义了一个打印Stack的函数
    while(!stack.empty())
        cout << stack.pop() <<" ";
    cout << endl;
}
int main(){
    //Create a stack of int values
    Stack<int> intStack;
    for(int i = 0; i < 10; i++)
        intStack.push(i);

    printStack(intStack);

    //Create a stack of strings
    Stack<string> stringStack;
    stringStack.push("Chicago");
    stringStack.push("Los Angeles");
    stringStack.push("London");

    printStack(stringStack);

    return 0;
}

改进的stack类

#ifndef IMPROVEDSTACK_H_INCLUDED
#define IMPROVEDSTACK_H_INCLUDED

/*
 *Stack<T>类的size属性表示栈中元素的数目，capacity保存元素数组的当前容纳能力
 *Stack<T>类的无参构造函数创建一个容量为16的数组
 *当容量满后，我们可以创建一个新的、更大的数组，将旧数组中的内容复制到新数组，并且删除掉旧数组
 */
template <typename T>
class Stack{
public:
    Stack();
    bool empty();
    T peek();
    void push(T value);
    T pop();
    int getSize();
private:
    T elements[100];
    int size;
    int capacity;
    void ensureCapacity();
};

template <typename T>
Stack<T>::Stack():size(0),capacity(16){
    elements = new T[capacity];
}

template <typename T>
bool Stack<T>::empty(){
    return (size == 0);
}

template <typename T>
T Stack<T>::peek(){
    return elements[size - 1];
}

template <typename T>
void Stack<T>::push(T value){
    ensureCapacity();
    elements[size++] = value;
}

template <typename T>
void Stack<T>::ensureCapacity(){
    if(size >= capacity){
        T *old =elements;
        capacity = 2 * size;
        elements = new T[size * 2];

        for(int i = 0; i < size; i++)
            elements[i] = old[i];

        delete old;       //释放内存
    }
}

template <typename T>
T Stack<T>::pop(){
    return elements[--size];
}

template <typename T>
int Stack<T>::getSize(){
    return size;
}



#endif // IMPROVEDSTACK_H_INCLUDED