数据结构C++代码超详细实例（持续更新，欢迎收藏）

简介

该文章主要为数据结构的基础代码，新手和小白课可放心食用。
后续持续更新，欢迎收藏~

基础

结构体

// 定义结构体
struct Human
{
    string name;
    int age;
    string sex;
};


int main(int argc, char const *argv[])
{
    /* code */
    // 声明结构体
    Human human1;
    Human human2;

    // 给结构体里的元素赋值
    human1.name = "张三";
    human1.age = 25;
    human1.sex = "男";

    human2.name = "李四";
    human2.age = 23;
    human2.sex = "女";

    cout<<"第一个人的名字是:"<<human1.name<<endl;
    cout<<"第一个人的年龄:"<<human1.age<<endl;
    cout<<"第二个人的名字是:"<<human2.name<<endl;
}

指针

int main()
{
    // 定义变量
    int  i = 1;
    // 定义指针
    int *j;
    // 指针指向变量
    j = &i;
    cout<<"正常输出"<<i<<endl;
    cout<<"指针地址"<<j<<endl;
    cout<<"指针指向的值"<<*j<<endl;
}

顺序表

动态分配

# include 
using namespace std;

// 默认表内存
# define InitSize 10

// 定义一个结构体
struct Seqlist
{
    /* data */
    int *data;
    int MaxSize;
    int length;
};

// 初始化顺序表
void InitList(Seqlist &L)
{
    // 开辟一段内存空间
    L.data = new int[InitSize];
    // 初始化表长
    L.length = 0;
    // 表内存大小
    L.MaxSize = InitSize;
    cout<<"初始化顺序表内存空间:"<<L.MaxSize<<endl;
}

// 增加顺序表内存空间
void IncreaseSize(Seqlist &L, int len)
{
    // 定义指针指向原表起点
    int *p = L.data;
    // 开辟一段更长的内存空间
    L.data = new int[InitSize + len];
    // 将原表数据存入新表
    for(int i = 0; i<L.MaxSize; i++)
    {
        L.data[i] = p[i]; 
    }
    L.MaxSize = L.MaxSize + len;
    // 销毁旧表，释放内存空间
    delete(p);
    cout<<"增加内存后空间大小："<<L.MaxSize<<endl;
}

int main(int argc, char const *argv[])
{
    /* code */
    // 生成一个结构体
    Seqlist L;
    // 初始化结构体
    InitList(L);
    // 插入元素
    for (int i = 0; i < L.MaxSize; i++)
    {
        /* code */
        L.data[i] = i;
        cout<<"插入元素："<<L.data[i]<<endl;
        L.length++;
    }
    // 增加内存空间
    IncreaseSize(L,5);
    cout<<"开始输出顺序表元素"<<endl;
    for (int i = 0; i < L.length; i++)
    {     
        cout<<L.data[i]<<endl;
    }
    
    return 0;
}

顺序表插入元素

# include 
using namespace std;
# define InitSize 15

// 定义一个结构体
struct Seqlist
{
    /* data */
    int *data;
    int MaxSize;
    int length;
};

// 初始化顺序表
void InitList(Seqlist &L)
{
    // 开辟一段内存空间
    L.data = new int[InitSize];
    L.length = 0;
    L.MaxSize = InitSize;
}

// 插入元素
bool ListInsert(Seqlist &L, int i, int e)
{
    // 判断插入位置是否合理
    if(i<1||i>L.length+1)
        return false;
    if(L.length>=L.MaxSize)
        return false;
    // 将插入元素位置后的元素都往后移一位
    for (int j = L.length; j >= i; j--)
    {
        /* code */
        L.data[j] = L.data[j-1];
    }
    // 找到插入位置后，将元素插入该位置
    L.data[i-1] = e;
    // 表长+1
    L.length++;
    return true;
}

int main(int argc, char const *argv[])
{
    /* code */
    // 生成一个结构体
    Seqlist L;
    // 初始化结构体
    InitList(L);
    // 初始化元素
    for (int i = 0; i < 10; i++)
    {
        L.data[i] = i;
        L.length++;
    }

    // 插入元素
    ListInsert(L,3,100);
    // 输出顺序表
    cout<<"开始输出顺序表元素"<<endl;
    for (int i = 0; i < L.length; i++)
    {     
        cout<<L.data[i]<<endl;
        /* code */
    }
    
    return 0;
}

顺序表删除元素

# include 
using namespace std;

# define InitSize 15
// 定义一个结构体
struct Seqlist
{
    /* data */
    int *data;
    int MaxSize;
    int length;
};

// 初始化顺序表
void InitList(Seqlist &L)
{
    // 开辟一段内存空间
    L.data = new int[InitSize];
    L.length = 0;
    L.MaxSize = InitSize;
}

// 删除元素
bool ListDelete(Seqlist &L, int i, int &e)
{
    if(i<1||i>L.length+1)
        return false;
    if(L.length==0)
        return false;
    // 将指定位置的元素传给e带出来
    e = L.data[i-1];
    // 删除元素位置之后的元素向前覆盖一位
    for (int j = i; j <= L.length; j++)
    {
        L.data[j-1] = L.data[j];
    }
    L.length--;
    return true;
}

int main(int argc, char const *argv[])
{
    /* code */
    // 生成一个结构体
    Seqlist L;
    // 初始化结构体
    InitList(L);
    // 初始化元素
    for (int i = 0; i < 10; i++)
    {
        L.data[i] = i;
        L.length++;
    }

    // 删除元素
    int e = -1;
    if (ListDelete(L, 3, e))
    {
        printf("已经删除第三个元素，元素值为%d\n",e);
    }
    else{
        printf("删除有误，请检查\n");
    }
    
    // 输出顺序表
    cout<<"开始输出顺序表元素"<<endl;
    for (int i = 0; i < L.length; i++)
    {     
        cout<<L.data[i]<<endl;
    }
    
    return 0;
}

顺序表查找

# include 
using namespace std;

# define InitSize 15
// 定义一个结构体
struct Seqlist
{
    /* data */
    int *data;
    int MaxSize;
    int length;
};

// 初始化顺序表
void InitList(Seqlist &L)
{
    // 开辟一段内存空间
    L.data = new int[InitSize];
    L.length = 0;
    L.MaxSize = InitSize;
}

// 按值查找元素
int ListFind_value(Seqlist &L,  int e)
{
    for (int j = 0; j <= L.length; j++)
    {
        if(L.data[j] == e)
        return j+1;
    }
    return 0;
}

// 按位查找元素
int ListFind_position(Seqlist &L, int i)
{
    return L.data[i-1];
}

int main(int argc, char const *argv[])
{
    /* code */
    // 生成一个结构体
    Seqlist L;
    // 初始化结构体
    InitList(L);
    // 初始化元素
    for (int i = 0; i < 10; i++)
    {
        /* code */
        L.data[i] = i;
        L.length++;
    }

    // 按位查找元素
    printf("按位查找元素的值为%d\n",ListFind_position(L, 5));
    

    // 按值查找元素
    printf("按值查找元素在表的第%d位\n",ListFind_value(L, 8));
    
    
    // 输出顺序表
    // cout<<"开始输出顺序表元素"<
    // for (int i = 0; i < L.length; i++)
    // {     
    //     cout<
    //     /* code */
    // }
    
    return 0;
}

链表

单链表的初始化

# include 
using namespace std;

// 重命名结构体数据类型以及指向改数据类型的指针
typedef struct LNode LNode;
typedef struct LNode *Linklist;

// 定义结构体表示节点
struct LNode
{
    int data;
    LNode *next;
};

// 初始化一个不带头指针的单链表
bool InitLinkList_NoHead(Linklist &L)
{
    L = NULL;
    printf("初始化不带头指针单链表成功\n");
    return true;
}

// 初始化一个带头指针的单链表
bool InitLinkList_Head(Linklist &L)
{
    // 分配一个头节点
    L = new LNode;
    if (L == NULL)
    {
        return false;
    }
    L->next = NULL;
    printf("初始化带头指针单链表成功\n");
    return true;
    
}

int main(int argc, char const *argv[])
{
    // 声明一个指向带链表的指针
    Linklist L;
    // 初始化不带头节点单链表
    InitLinkList_NoHead(L);
    // 初始化带头结点单链表
    InitLinkList_Head(L);
    return 0;
}

单链表的几种插入方式

#include 
#include 
using namespace std;

// 重命名结构体数据类型以及指向改数据类型的指针
typedef struct LNode LNode;
typedef struct LNode *Linklist;

// 定义结构体表示结点
struct LNode
{
    int data;
    LNode *next;
};

// 初始化一个不带头指针的单链表
bool InitLinkList_NoHead(Linklist &L)
{
    L = NULL;
    printf("初始化不带头指针单链表成功\n");
    return true;
}

// 初始化一个带头指针的多结点单链表
bool InitLinkList_Head(Linklist &L)
{
    // 分配一个头结点
    L = new LNode; 
    if (L == NULL)
    {
        return false;
    }
    // 创建指针p用于加入元素，以及尾指针r
    LNode *p,*r = L;
    // 依次给单链表加入新元素
    for (int i = 1; i < 10; i++)
    {
        // 赋值
        p = new LNode;
        p->data = i;
        printf("加入元素%d,",p->data);
        // 指针指向下一位置
        r->next = p;
        r = p;
    }
    p->next = NULL;
    printf("初始化带头指针单链表成功\n");
    return true;
}

// 按位序插入（带头结点）
// 在第i个节点插入元素e(后插操作)
bool LinkList_Insert_one(Linklist &L, int i, int e)
{
    // 插入位置要在头结点之后
    if (i<1)
        return false;
    // 创建指针p指向头结点后一位
    LNode *p = L->next;
    // 当前p指针指向第j个节点
    int j = 0;
    // 循环找到第i个位置（即i-1个结点）
    while (p != NULL && j < i-1)
    {
        p = p->next;
        j++;
    }
    if(p == NULL)
        return false;
    // 创建新结点
    LNode *s = new LNode;
    // 将传入的值赋给新结点的数据域
    s->data = e;
    // 新结点的指针域指向当前结点的下一结点
    s->next = p->next;
    // 当前结点的指针域指向新结点
    p->next = s;
    return true;
}

bool bianli(Linklist &L)
{
    // 创建指针指向头结点的下一位置
    LNode *t = new LNode;
    t = L->next;
    // 遍历该单链表
    while (1 == 1)
    {
        if(t->next == NULL)
        {
            printf("遍历元素%d,",t->data);
            break;
        }
        else
        {
            printf("遍历元素%d,",t->data);
            t = t->next;
        }
    }
    return true;
}


// 在第i个节点插入元素e(前插操作)
bool LinkList_Insert_three(Linklist &L, int i, int e)
{
    // 插入位置在头结点之后
    if (i<1)
        return false;
    // 创建指针p指向头结点的下一结点
    LNode *p = L->next;
    // 当前p指针指向第j个节点
    int j = 0;
    // 循环找到第i个位置（即i-1个结点）
    while (p != NULL && j<i-1)
    {
        p = p->next;
        j++;
    }
    if(p == NULL)
        return false;
    LNode *s = new LNode;
    // 将当前结点的数据赋给新结点
    s->data = p->data;
    // 将插入数据赋给当前结点
    p->data = e;
    // 新结点指针域指向当前结点的下一结点
    s->next = p->next;
    // 当前结点的下一结点指向新结点
    p->next = s;
    return true;
}

// 不带头节点插入元素
bool LinkList_Insert_two(Linklist &L, int i, int e)
{
    if (i<1)
    {
        return false;
    }
    // 无头结点时插入第一个结点的操作
    if (i == 1)
    {
        // 创建新结点
        LNode *s = new LNode;
        // 将插入值赋给新结点数据域
        s->data = e;
        // 新结点指针域指向链表
        s->next = L;
        // 头指针指向新结点
        L = s;
        return true;
    }
    // 创建指针p指向节点
    LNode *p;
    // 当前p指针指向第j个节点
    int j = 1;
    // L指向头节点
    p = L;
    // 循环找到第i个位置（即i-1个结点）
    while (p != NULL && j<i-1)
    {
        p = p->next;
        j++;
    }
    if(p == NULL)
        return false;
    LNode *s = new LNode;
    s->data = e;
    s->next = p->next;
    p->next = s;
    return true;
}

int main(int argc, char const *argv[])
{
    // 声明一个指向带链表的指针
    Linklist L;
    int num;
    printf("请输入你要选择的操作:0.结束程序;1.不带头结点的插入操作;2.带头结点的后插;3.带头结点的前插\n");     
    cin >> num;
    if (num == 0)
    {
        printf("程序结束,谢谢使用!\n");
    }
    else if(num == 1)
    {
        // 不带头指针初始化
        InitLinkList_NoHead(L);
        LinkList_Insert_two(L, 1, 200);
        printf("1");
        Linklist p = L;
        printf("无头结点单链表的第一个元素是%d\n",p->data);
    }
    else if (num == 2)
    {
        // 带头指针初始化
        InitLinkList_Head(L);      
        LinkList_Insert_one(L, 2, 100);
        bianli(L);
        Linklist p = L->next;
        printf("有头结点单链表的第一个元素是%d\n",p->data);
        for (int i = 0; i >-1; i++)
        {
            p = p->next; 
            if (i == 1) 
                printf("插入的元素为%d\n",p->data);
                break;
        }          
    }else if (num == 3)
    {
        // 带头指针初始化
        InitLinkList_Head(L);
        LinkList_Insert_three(L, 2, 300);
        bianli(L);
        Linklist p = L->next;
        printf("有头结点单链表的第一个元素是%d\n",p->data); 
    }
    return 0;
}

单链表的删除操作

# include
using namespace std;

typedef struct LNode LNode;
typedef struct LNode *Linklist;

struct LNode
{
    int data;
    LNode *next;
};

// 初始化单链表
bool InitLinkList(Linklist &L)
{
    // 创建头结点
    L = new LNode;
    if(L == NULL)
    {
        return false;
    }
    // 创建指针p用于加入元素，以及尾指针r。
    LNode *p,*r = L;
    // 往链表中加入元素
    for (int i = 1; i < 10; i++)
    {
        p = new LNode;
        p->data = i;
        printf("加入数据%d",p->data);
        r->next = p;
        r = p;     
    }
    r->next = NULL;
    printf("单链表初始化完成\n");
    return true;
}

// 按位删除元素
bool DeleteList_one(Linklist &L, int i, int &e)
{
    printf("即将删除第%d个元素\n", i);
    if(i<1)
        return false;
    // 创建指针指向头结点的下一位置
    LNode *t = L;
    int j = 0;
    // 遍历该单链表找到指定位置
    while (t != NULL && j < i-1)
    {
        t = t->next;    
        j++;
    }
    // 避免异常情况
    if(t == NULL)
        return false;
    if(t->next == NULL)
        return false;
    // 创建结点指向删除结点位置
    LNode *d = t->next;
    // 删除的值传出
    e = d->data;
    // 将要删除的结点从链表中跳过
    t->next = d->next;
    // 释放删除结点内存
    free(d);
    return true;
}

// 按值删除元素
bool DeleteList_two(Linklist &L, int i, int &e)
{
    printf("即将按值删除元素%d\n", i);
    if(i<1)
        return false;
    // 创建指针指向头结点的下一位置
    LNode *t = L;           
    // 遍历该单链表找到指定位置
    while (t->data != i && t->next != NULL)
    {
        t = t->next;    
    }
    // 避免异常情况
    if(t == NULL)
        return false;
    if(t->next == NULL)
        return false;
    // 创建结点指向删除结点位置
    LNode *d = t->next;
    // 删除的值传出
    e = t->data;
    // 后继结点覆盖当前结点的数据域
    t->data = t->next->data;
    // 将要删除的结点从链表中跳过
    t->next = d->next;
    // 释放删除结点内存
    free(d);
    return true;
}


int main(int argc, char const *argv[])
{
    Linklist L;
    int e;
    InitLinkList(L);
    DeleteList_one(L, 2, e);
    printf("按位删除元素为%d\n",e);
    DeleteList_two(L, 3, e);
    printf("按值删除元素为%d",e);
    return 0;
}

双链表的初始化

#include 
using namespace std;

typedef struct DNode DNode;
typedef struct DNode *DLinkList;

// 定义双链表结点
struct DNode
{
    int data;
    DNode *prior, *next;
};

// 初始化双链表
bool InitDLinkList(DLinkList &L){
    L = new DNode;
    // 内存分配失败
    if(L == NULL)
    {
        return false;
    }
    // 双链表中头结点的prior结点永远指向NULL
    L->prior == NULL;
    // 头结点的next结点暂时指向NULL
    L->next == NULL;
    // 双链表中加入新元素
    DNode *p, *r = L;
    for (int i = 0; i < 10; i++)
    {
        p = new DNode;
        p->data = i;
        printf("添加%d\n",p->data);
        p->prior = r;
        r->next = p;
        r = p;
    }
    r->next == NULL;    
    return true;
}

// 遍历双链表
bool bianli(DLinkList &L)
{
    DNode *t = new DNode;
    t = L->next;
    while ( 1 == 1)
    {
        if(t->next == NULL)
        {
            printf("遍历元素%d,",t->data);
            break;
        }
        else
        {
            printf("遍历元素%d,",t->data);
            t = t->next;
        }
    }   
    return true;
}


int main(int argc, char const *argv[])
{
    DLinkList L;
    InitDLinkList(L);
    bianli(L);
    return 0;
}

双链表后插

#include 
#include 
using namespace std;

typedef struct DNode DNode;
typedef struct DNode *DLinkList;

// 定义双链表结点
struct DNode
{
    int data;
    DNode *prior, *next;
};

// 初始化双链表
bool InitDLinkList(DLinkList &L){
    L = new DNode;
    // 内存分配失败
    if(L == NULL)
    {
        return false;
    }
    // 双链表中头结点的prior结点永远指向NULL
    L->prior == NULL;
    // 头结点的next结点暂时指向NULL
    L->next == NULL;
    // 双链表中加入新元素
    DNode *p, *r = L;
    for (int i = 0; i < 10; i++)
    {
        p = new DNode;
        p->data = i;
        printf("添加%d\n",p->data);
        p->prior = r;
        r->next = p;
        r = p;
    }
    r->next = NULL;    
    return true;
}

// 在指定位置后插新数据
bool InsertDLinlLikst(DLinkList &L, int i, int e)
{
    // 创建新结点用于完成插入操作
    DNode *s,*p = new DNode;
    s, p = L;
    // 用于定位
    int j = 0;
    // 遍历找到指定位置
    while (p->next != NULL && j < i)
    {
        p = p->next;
        j++;
    }    
    // 新数据传给s结点
    s->data = e;
    // s结点的后指针指向
    s->next = p->next;
    // 如果指定结点有后继结点
    if (p->next != NULL)
    {
        // 指定结点的后继结点的前指针指向插入结点
        p->next->prior = s;
    }
    // 插入结点的前指针指向指定节点
    s->prior = p;
    // 指定节点的后指针指向插入结点
    p->next = s;
    printf("后插数据成功\n");
    return true;    
}  

// 遍历双链表
bool bianli(DLinkList &L)
{
    DNode *t;
    t = L->next;
    while (1 == 1)
    {
        printf("\n");
        if(t->next == NULL)
        {
            printf("遍历最后一个元素%d\n",t->data);
            break;
        }
        else
        {
            printf("遍历元素%d\n",t->data);
            Sleep(300);
            t = t->next;
        }
    }   
    return true;
}


int main(int argc, char const *argv[])
{
    DLinkList L;
    InitDLinkList(L);
    bianli(L);
    InsertDLinlLikst(L, 5, 100);
    bianli(L);
    printf("程序结束");
    return 0;
}

双链表删除结点

    #include 
    using namespace std;

    typedef struct DNode DNode;
    typedef struct DNode *DLinkList;

    // 定义双链表结点
    struct DNode
    {
        int data;
        DNode *prior, *next;
    };

    // 初始化双链表
    bool InitDLinkList(DLinkList &L){
        L = new DNode;
        // 内存分配失败
        if(L == NULL)
        {
            return false;
        }
        // 双链表中头结点的prior结点永远指向NULL
        L->prior = NULL;
        // 头结点的next结点暂时指向NULL
        L->next = NULL;
        // 双链表中加入新元素
        DNode *p, *r = L;
        for (int i = 0; i < 10; i++)
        {
            p = new DNode;
            p->data = i;
            printf("添加%d\n",p->data);
            p->prior = r;
            r->next = p;
            r = p;
        }
        r->next = NULL;    
        return true;
    }

    // 删除指定位置的后继结点
    bool DeleteDLinkList(DLinkList &L, int i, int &e)
    {
        printf("删除开始\n");
        DNode *s, *p = new DNode;
        s, p = L;
        int j = 0;
        while (p->next != NULL && j < i)
        {
            p = p->next;
            j++;
        }
        printf("找到结点\n");
        s = p->next;
        // 删除的数据带出
        e = s->data;
        if(s == NULL)
        {
            return false;
        }
        p->next = s->next;
        s->next->prior = p;
        free(s);
        printf("结点删除完成\n");
        return false;
    }

    // 遍历双链表
    bool bianli(DLinkList &L)
    {
        // 创建临时结点指向链表
        DNode *t = L->next;
        while (1 == 1)
        {
            if(t->next == NULL)
            {
                printf("遍历元素%d,",t->data);
                break;
            }
            else
            {
                printf("遍历元素%d,",t->data);
                t = t->next;
            }
        }
        return true;
    }

    int main(int argc, char const *argv[])
    {
        DLinkList L;
        int e = -1;
        InitDLinkList(L);
        printf("暂停\n");
        bianli(L);
        DeleteDLinkList(L, 2, e);  
        bianli(L);
        printf("结束");
        return 0;
    }

循环链表

#include 
using namespace std;

typedef struct LNode LNode;
typedef struct LNode *LinkList;

struct LNode
{
    int data;
    LNode *next;
};

// 初始化循环单链表
bool InitList(LinkList &L)
{
    L = new LNode;
    if(L == NULL)
    {
        return false;
    }
    // 创建指针p用于加入元素，以及尾指针r。
    LNode *p,*r = L;
    // 往链表中加入元素
    for (int i = 1; i < 10; i++)
    {
        p = new LNode;
        p->data = i;
        printf("加入数据%d",p->data);
        r->next = p;
        r = p;
    }
    r->next = L;
    printf("单链表初始化完成\n");
    return true;
}

//遍历 
bool bianli(LinkList &L)
{
    // 创建指针指向头结点的下一位置
    LNode *t = new LNode;
    t = L->next;
    // 遍历该单链表
    while (1 == 1)
    {
        if(t->next == NULL)
        {
            printf("遍历元素%d,",t->data);
            break;
        }
        else
        {
            printf("遍历元素%d,",t->data);
            t = t->next;
        }
    }
    return true;
}

int main(int argc, char const *argv[])
{
    LinkList L;
    InitList(L);
    bianli(L);
    return 0;
}

栈

栈的顺序存储实现——初始化

#include 
using namespace std;
/*
    栈的顺序存储实现——初始化
*/

// 设置默认最大空间
#define MaxSixe 10;

typedef struct SqStack SqStack;

// 定义栈的结构体
struct SqStack
{
    int data[10];
    int top;
};

// 初始化栈
void InitSqStack(SqStack &S)
{
    S.top = -1;
}

// 判断栈是否为空
bool JudgeStack(SqStack &S)
{
    if(S.top == -1)
    {
        return true;
    }
    else{
        return false;
    }
}  

int main(int argc, char const *argv[])
{
    SqStack S;
    InitSqStack(S);
    if (JudgeStack(S))
    {
        printf("该栈为空");
    }
    else{
        printf("该栈不为空");
    }
     
    return 0;
}

栈的顺序存储实现——入栈

#include 
using namespace std;
/*
    栈的顺序存储实现——进栈
*/

// 设置默认最大空间
#define MaxSize 10;
typedef struct SqStack SqStack;
int s = MaxSize;
// 定义栈的结构体
struct SqStack
{
    int data[10];
    int top;
    int lenth;
};

// 初始化栈
void InitSqStack(SqStack &S)
{
    S.lenth = 0;
    S.top = -1;
    for (int i = 0; i < 5; i++)
    {
        S.top++;
        S.data[S.top] = i;
        S.lenth++;
    }
    printf("初始化完成\n");
}

//入栈
bool Push(SqStack &S, int &e)
{
    // 判断栈是否已满
    if(S.top == s-1)
    {   
       return false;
    }
    // 入栈
    S.data[++S.top] = e;
    S.lenth++;
    printf("入栈操作完成\n");
    return true;   
}

bool BianLi(SqStack &S)
{
    int i =0;
    while (i < S.lenth)
    {
        printf("%d\n",S.data[i]);
        i++;
    }
    printf("遍历完成");
    return true;
}

int main(int argc, char const *argv[])
{
    SqStack S;
    int e = 100;
    InitSqStack(S);
    BianLi(S);
    Push(S, e);
    BianLi(S);
    return 0;
}

栈的顺序存储实现——出栈

#include 
using namespace std;
/*
    栈的顺序存储实现——进栈
*/

// 设置默认最大空间
#define MaxSize 10;
typedef struct SqStack SqStack;
int s = MaxSize;
// 定义栈的结构体
struct SqStack
{
    int data[10];
    int top;
    int lenth;
};

// 初始化栈
void InitSqStack(SqStack &S)
{
    S.lenth = 0;
    S.top = -1;
    for (int i = 0; i < 5; i++)
    {
        S.top++;
        S.data[S.top] = i;
        S.lenth++;
    }
    printf("初始化完成\n");
}

//出栈
bool Pop(SqStack &S, int &e)
{
    // 判断栈是否为空
    if(S.top == -1)
    {   
       return false;
    }
    // 出栈
    e = S.data[S.top];
    S.top--;
    S.lenth--;
    printf("出栈操作完成\n");
    return true;   
}

bool BianLi(SqStack &S)
{
    int i =0;
    while (i < S.lenth)
    {
        printf("%d\n",S.data[i]);
        i++;
    }
    printf("遍历完成\n");
    return true;
}

int main(int argc, char const *argv[])
{
    SqStack S;
    int e = 100;
    InitSqStack(S);
    BianLi(S);
    Pop(S, e);
    printf("出栈的数据为%d\n",e);
    BianLi(S);
    return 0;
}

栈的链式存储实现——初始化

等同于单链表的初始化

# include 
using namespace std;

// 重命名结构体数据类型以及指向改数据类型的指针
typedef struct LNode LNode;
typedef struct LNode *Linklist;

// 定义结构体表示节点
struct LNode
{
    int data;
    LNode *next;
};

// 初始化一个不带头指针的栈
bool InitLinkList_NoHead(Linklist &L)
{
    L = NULL;
    printf("初始化不带头指针栈成功\n");
    return true;
}

// 初始化一个带头指针的栈
bool InitLinkList_Head(Linklist &L)
{
    // 分配一个头节点
    L = new LNode;
    if (L == NULL)
    {
        return false;
    }
    L->next = NULL;
    printf("初始化带头指针栈成功\n");
    return true;
    
}

int main(int argc, char const *argv[])
{
    // 声明一个指向栈的指针
    Linklist L;
    // 初始化不带头节点栈
    InitLinkList_NoHead(L);
    // 初始化带头结点栈
    InitLinkList_Head(L);
    return 0;
}

栈的链式存储实现——入栈

等同于单链表的头结点后插操作

#include 
using namespace std;

/*
    栈的链表实现的入栈操作相当于单链表的头结点后插操作
*/

// 重命名结构体数据类型以及指向改数据类型的指针
typedef struct LNode LNode;
typedef struct LNode *Linklist;

// 定义结构体表示结点
struct LNode
{
    int data;
    LNode *next;
};

// 初始化一个不带头指针的栈
bool InitLinkList_NoHead(Linklist &L)
{
    L = NULL;
    printf("初始化不带头指针栈成功\n");
    return true;
}

// 初始化一个带头指针的多结点栈
bool InitLinkList_Head(Linklist &L)
{
    // 分配一个头结点
    L = new LNode; 
    if (L == NULL)
    {
        return false;
    }
    // 创建指针p用于加入元素，以及尾指针r
    LNode *p,*r = L;
    // 依次给栈加入新元素
    for (int i = 1; i < 10; i++)
    {
        // 赋值
        p = new LNode;
        p->data = i;
        printf("加入元素%d,",p->data);
        // 指针指向下一位置
        r->next = p;
        r = p;
    }
    p->next = NULL;
    printf("初始化带头指针栈成功\n");
    return true;
}

// 入栈（等同于链表的头结点后插)
bool LinkList_Insert_one(Linklist &L,  int e)
{
    // 创建指针p指向头结点
    LNode *p = L;
    // 创建新结点
    LNode *s = new LNode;
    // 将传入的值赋给新结点的数据域
    s->data = e;
    // 新结点的指针域指向当前结点的下一结点
    s->next = p->next;
    // 当前结点的指针域指向新结点
    p->next = s;
    return true;
}

bool bianli(Linklist &L)
{
    // 创建指针指向头结点的下一位置
    LNode *t = new LNode;
    t = L->next;
    // 遍历该栈
    while (1 == 1)
    {
        if(t->next == NULL)
        {
            printf("遍历元素%d,",t->data);
            break;
        }
        else
        {
            printf("遍历元素%d,",t->data);
            t = t->next;
        }
    }
    return true;
}


// 不带头节点入栈
bool LinkList_Insert_two(Linklist &L, int e)
{
    // 创建新结点
    LNode *s = new LNode;
    // 将插入值赋给新结点数据域
    s->data = e;
    // 新结点指针域指向栈
    s->next = L;
    // 头指针指向新结点
    L = s;
    return true;
}

int main(int argc, char const *argv[])
{
    // 声明一个指向栈的指针
    Linklist L;
    int num;
    printf("请输入你要选择的操作:0.结束程序;1.不带头结点的入栈;2.带头结点的入栈;\n");     
    cin >> num;
    if (num == 0)
    {
        printf("程序结束,谢谢使用!\n");
    }
    else if(num == 1)
    {
        // 不带头指针初始化
        InitLinkList_NoHead(L);
        LinkList_Insert_two(L, 200);
        printf("1");
        Linklist p = L;
        printf("无头结点栈的第一个元素是%d\n",p->data);
    }
    else if (num == 2)
    {
        // 带头指针初始化
        InitLinkList_Head(L);      
        LinkList_Insert_one(L, 100);
        bianli(L);
        Linklist p = L->next;
        printf("有头结点栈的第一个元素是%d\n",p->data);
        for (int i = 0; i >-1; i++)
        {
            p = p->next; 
            if (i == 1) 
                printf("插入的元素为%d\n",p->data);
                break;
        }          
    }
    return 0;
}

栈的链式存储实现——出栈

等同于单链表的头结点后删操作

# include
using namespace std;

/*
    栈的栈实现的入栈操作相当于栈的头结点后删操作
*/

typedef struct LNode LNode;
typedef struct LNode *Linklist;

struct LNode
{
    int data;
    LNode *next;
};

// 初始化栈
bool InitLinkList(Linklist &L)
{
    // 创建头结点
    L = new LNode;
    if(L == NULL)
    {
        return false;
    }
    // 创建指针p用于加入元素，以及尾指针r。
    LNode *p,*r = L;
    // 往栈中加入元素
    for (int i = 1; i < 10; i++)
    {
        p = new LNode;
        p->data = i;
        printf("加入数据%d",p->data);
        r->next = p;
        r = p;     
    }
    printf("\n");
    r->next = NULL;
    printf("栈初始化完成\n");
    return true;
}

// 按位删除元素
bool DeleteList_one(Linklist &L,  int &e)
{
    // 创建指针指向头结点
    LNode *t = L;
    // 避免异常情况
    if(t == NULL)
        return false;
    if(t->next == NULL)
        return false;
    // 创建结点指向删除结点位置
    LNode *d = t->next;
    // 删除的值传出
    e = d->data;
    // 将要删除的结点从栈中跳过
    t->next = d->next;
    // 释放删除结点内存
    free(d);
    return true;
}


int main(int argc, char const *argv[])
{
    Linklist L;
    int e;
    InitLinkList(L);
    DeleteList_one(L, e);
    printf("出栈元素为%d\n",e);
    return 0;
}

队列

队列的顺序存储实现——初始化队列

未完待续。。。欢迎收藏交流