c/c++数据结构 栈和队列

       栈的特性就是先进后出只能在一端操作，好多应用场合 比如浏览器的后退呀、敲代码时编辑器Ctrl+z 返回上一步呀 等等 ，队列的话是先进先出 两边操作，首先C我们用数组来实现一个栈和队列 然后C++在用链表实现栈和队列

定义一些宏变量 以便修改方便

#define  ElemType int //栈元素这里使用int类型
#define MAX_SIZE 10 //初始化栈的大小
#define ADD_SIZE 10// 增量大小

定义一个栈的属性 包含一个数组和栈当前的长度

typedef struct _Node{
    int len;
    ElemType array[MAX_SIZE];
    
}ArrayList;

创建一个栈

//初始化一个栈或者一个队列
ArrayList* init(){
    ArrayList* list=(ArrayList*)malloc(sizeof(ArrayList));
    list->len=0;
    return list;
}

入栈或者入队列的方法

//入栈 入队列
int push(ArrayList* list,ElemType data){
    //动态增加栈空间
    if (list->len>=MAX_SIZE) {
        list=realloc(list,ADD_SIZE);
    }
    list->array[list->len]=data;
    
    list->len++;
    return 0;
}

出栈方法

//弹栈
ElemType pop(ArrayList* list){
    int data=list->array[list->len-1];
    list->len--;
    return data;
    
}

出队列方法

//出队列
ElemType queuepop(ArrayList* list){
    int data=list->array[0];
    list->len--;
    return data;
    
}

销毁一个栈

//销毁栈
int destory(ArrayList* list){
    if (list!=NULL) {
        free(list);
    }
    return 0;
}

下面是完整代码：

#include <stdio.h>
#include<stdlib.h>

#define  ElemType int //栈元素这里使用int类型
#define MAX_SIZE 10 //初始化栈的大小
#define ADD_SIZE 10// 增量大小
typedef struct _Node{
    int len;
    ElemType array[MAX_SIZE];
    
}ArrayList;
//初始化一个栈或者队列
ArrayList* init(){
    ArrayList* list=(ArrayList*)malloc(sizeof(ArrayList));
    list->len=0;
    return list;
}
//入栈或者入队列
int push(ArrayList* list,ElemType data){
    //动态增加栈或者队列空间
    if (list->len>=MAX_SIZE) {
        list=realloc(list,ADD_SIZE);
    }
    list->array[list->len]=data;
    
    list->len++;
    return 0;
}
//弹栈
ElemType pop(ArrayList* list){
    int data=list->array[list->len-1];
    list->len--;
    return data;
    
}

int getLen(ArrayList* list){
    return list->len;}

ElemType getNoded(ArrayList* list,int index){
    ElemType da=list->array[index];
    
    return da;
}
//销毁栈
int destory(ArrayList* list){
    if (list!=NULL) {
        free(list);
    }
    return 0;
}
int cleal(ArrayList* list){
    list->len=0;
    return 0;
}

int main(){
    int i1=1;
    int i2=2;
    int i3=3;
    int i4=4;
    int i5=5;
    int i=0;
    ArrayList* list=init();
    push(list, i1);
    push(list, i2);
    push(list, i3);
    push(list, i4);
    push(list, i5);
    for(i=0;i<getLen(list);i++){
        int data= getNoded(list, i);
        
        printf("%d\n",data);
    }
    pop(list);
    printf("-----------\n");
    for(i=0;i<getLen(list);i++){
        int data= getNoded(list, i);
        
        printf("%d\n",data);
    }
    pop(list);
    printf("-----------\n");
    for(i=0;i<getLen(list);i++){
        int data= getNoded(list, i);
        
        printf("%d\n",data);
    }
    destory(list);
    
    return 0;
}

再用C++来实现栈 队列以及链表

#ifndef _______Stack2__
#define _______Stack2__

#include <stdio.h>
#include <stdlib.h>
template <typename T>
 struct Node{
    T data;
    Node *next;

};
template <typename T>
class Stack{
public:
    Node<T> *heard;
    int len;
public:
    Stack<T>();
    ~Stack<T>();
    bool add(T t,int index);
    T get(int index);
    T remove(int index);
    T pop();
    T quepop();
    bool push(T t);
    
};





#endif /* defined(_______Stack2__) */

#include "Stack2.h"
template <typename T>

Stack<T>::Stack(){
    heard=nullptr;
    len=0;
    
}
template <typename T>
Stack<T>::~Stack<T>(){
    
    
}
//链表---在指定位置添加元素
template <typename T>
bool Stack<T>::add(T t,int index){
    Node<T> *p=heard;
    Node<T> *node=new Node<T>();
    node->data=t;
    node->next=nullptr;
    if (index==0) {
        node->next=heard;
        heard=node;
    }else {
        int i=1;
        while(p->next!=nullptr&&i<index){
            p=p->next;
            i++;
        }
        node->next= p->next;
        p->next=node;
    }
    len++;
    return true;
}
//链表--删除指定位置的元素
template <typename T>
T Stack<T>::remove(int index){
     Node<T> *p=heard;
    Node<T> *tmp;
    if (index==0) {
        tmp=heard;
        heard=tmp->next;
    }else{
    int i=1;
    while(p->next!=nullptr&&i<index){
        p=p->next;
        i++;
    }
    tmp=p->next;
    p->next= tmp->next;
    }
    len--;

    return tmp->data;

}
//队列---出队列
template <typename T>
T Stack<T>::quepop(){
    Node<T> *p=heard;
    int i=0;
    while (p->next!=nullptr&&i<len) {
        p=p->next;
        i++;
    }
    len--;
    return p->data;
}
//栈---出栈
template <typename T>
T Stack<T>::pop(){
    Node<T> *p=heard;
    heard=p->next;
       len--;
    return p->data;
}
//栈----进栈 或者 队列--进队列
template <typename T>
bool Stack<T>::push(T t){
  Node<T> *node=new Node<T>();
    node->data=t;
    node->next=heard;
    heard=node;
    len++;
    return true;
}
//链表---获取指定位置的元素
template <typename T>
T Stack<T>::get(int index){
    Node<T> *p=heard;
    int i=0;
    while (p->next!=nullptr&&i<index) {
        p=p->next;
        i++;
    }
    
    return p->data;
}