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

原创 已于 2022-10-27 17:52:27 修改 · 6.1k 阅读 · 117 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构 #c++ #算法 #考研

于 2022-10-18 16:13:49 首次发布
本文详细介绍了数据结构中的基础概念，包括结构体、指针、动态分配顺序表的创建与扩展、插入、删除元素。此外，还涵盖了单链表和双链表的初始化、插入、删除操作。内容适合初学者学习，逐步理解数据结构的基本操作。

目录

简介

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

基础

结构体

// 定义结构体
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 <iostream>
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 <iostream>
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 <iostream>
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 <iostream>
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<<"开始输出顺序表元素"<<endl;
    // for (int i = 0; i < L.length; i++)
    // {     
    //     cout<<L.data[i]<<endl;
    //     /* code */
    // }
    
    return 0;
}

链表

单链表的初始化

# include <iostream>
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 <iostream>
#include <windows.h>
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<iostream>
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 <iostream>
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 <iostream>
#include <windows.h>
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 <iostream>
    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 <iostream>
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 <iostream>
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 <iostream>
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 <iostream>
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 <iostream>
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 <iostream>
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<iostream>
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;
}

队列

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

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

程序Long
关注
基于C++的零食销售管理系统设计与实现的详细项目实例（含完整的程序，数据库和GUI设计，代码详解）
08-05
通过高效的数据结构和算法优化，实现了实时库存预警和销售数据快速处理，为企业决策提供了强有力的数据支持。系统部署在兼容多操作系统的环境中，设计考虑了性能优化和安全性保障，结合自动化运维与监控机制，确保...
【C++景区一体化综合平台】 基于C++的景区一体化综合平台设计和实现的详细项目实例（含完整的程序，数据库和GUI设计，代码详解）
04-17
该平台旨在通过信息化手段提升景区管理效率、优化游客体验、实现资源智能调度、提高数据处理能力和实时响应、推动景区数字化转型、提升景区竞争力、加强数据分析和决策支持以及推动旅游产业的可持续发展。...
C++例子代码
03-06
本资源转载自网络，供学习研究之用，如用于商业用途，请购买正版，如有侵权，请联系我或优快云删除。
C++示例代码
04-17
任意两年的天数只差 代码可以继续优化 提升初学者的能力
【C++面向对象设计模式实战】：23个经典案例揭秘高效代码设计背后的核心逻辑
最新发布
LogicNest的博客
10-28 813
掌握C++面向对象设计精髓，解决复杂系统设计难题。通过23个经典实战案例，深入解析创建型、结构型与行为型模式的应用场景与实现方法，提升代码复用性与可维护性。涵盖工厂、单例、观察者等核心模式，助力高效软件设计。C++ 面向对象设计模式实战案例解析，值得收藏。
C++代码案例
weixin_30498807的博客
03-10 161
《深入体验C语言项目开发》 配书光盘 版权所有，侵权必究 2011年5月 ___________________________...
C++常用代码案例
老人头的博客
08-31 2109
目录 目录 1、读取market.txt配置文件，取出其中逗号分割的字符串，并输出到新的文件中。 2、从内存中写输出到文件中。 1、读取market.txt配置文件，取出其中逗号分割的字符串，并输出到新的文件中。 #include <iostream> #include <string> #include <fstream> #include ...
C++案例
hjl011006的博客
06-14 5007
一、输出 1.用for循环写一个爱心代码 2.在爱心的基础上，做一些高级的表白爱心 3.蛇形矩阵 4.杨辉三角 5.9×9乘法表 6. 水仙花数 7. 递归--斐波那契数列编辑 8. 递归--数的阶乘 9. 进制转化 10. 输出菱形 二、循环＋数组 1. while循环猜数组 2. for循环敲桌子游戏 3. 一维数组--元素逆置 4. 冒泡排序 三、字符--字符串 1.字符的大小写转化（c语言版） 四、函数 1.封装一个函数--利用冒泡排序，实现实现对整型数组的升序排序
分析C++软件问题的实用软件与高效工具实战案例集锦汇总
dvlinker的技术专栏
06-26 16万+
C++软件分析工具案例分析集锦！根据近几年C++软件异常排查的项目实践，详细地讲述如何使用PE工具、Dependency Walker、GDIView、Process Explorer、Process Monitor、API Monitor、Clumsy、DebugDiag、Windbg、IDA Pro等常用分析工具，以及如何使用这些工具去巧妙地分析和解决日常工作中遇到的问题，有很强的实战参考价值！
C++数据结构与算法之双缓存队列实现方法详解
08-29
本文主要介绍了C++数据结构与算法之双缓存队列实现方法，结合实例形式分析了双缓存队列的原理、实现方法与相关注意事项。 知识点一：双缓存队列的定义 双缓存队列是一种特殊的队列结构，它可以解决在发送端持续向...
【C++软件调试技术】C++软件开发维护过程中典型软件异常问题的排查与总结
热门推荐
dvlinker的技术专栏
04-15 17万+
本文以问答的方式进行展开，罗列了C++软件日常开发和维护中遇到的多个软件调试问题及有代表性的场景，给出详细的处置思路和处理办法，以供大家借鉴和参考。
C++最简单代码示例1
10-25
C++最简单代码示例1 构造顺序 一个示例代码
C++入门学习——模板示例代码
06-24
C++入门学习——模板，相关教程链接如下： http://blog.youkuaiyun.com/tennysonsky/article/details/46625115
数据结构实现（C++版）
11-28
内含资源如下： 1.基本数据结构 1.1.Array ........... 动态数组 1.2.LinkedList ... 链表 1.3.BST .............. 二分搜索树 1.4.MapBST ..... 二分搜索树（用于实现映射） 1.5.AVLTree ...... AVL树 2.接口 2.1.Queue ........... 队列接口 2.2.Stack .............. 栈接口 2.3.Set .................. 集合接口 2.4.Map ............... 映射接口 2.5.Merger .......... 自定义函数接口 2.6.UnionFind ..... 并查集接口 3.高级数据结构 3.1.ArrayQueue .......................... 队列_基于动态数组实现 3.2.LinkedListQueue .................. 队列__基于链表实现 3.3.LoopQueue ........................... 循环队列_基于动态数组实现 3.4.PriorityQueue ....................... 优先队列_基于最大二叉堆实现 3.5.ArrayPriorityQueue ............. 优先队列_基于动态数组实现 3.6.LinkedListPriorityQueue ..... 优先队列_基于链表实现 3.7.ArrayStack ............................. 栈_基于动态数组实现 3.8.LinkedListStack ..................... 栈_基于链表实现 3.9.BSTSet ..................................... 集合_基于二分搜索树实现 3.10.LinkedListSet ....................... 集合_基于链表实现 3.11.BSTMap ................................ 映射_基于二分搜索树实现 3.12.AVLTreeMap ....................... 映射_ 基于AVL树实现 3.13.LinkedListMap .................... 映射_基于链表实现 3.14.MaxHeap ............................. 最大二叉堆 3.15.SegmentTree ...................... 线段树 3.16.Trie ......................................... 字典树 3.17.QuickFind ............................ 并查集_基于数组实现 3.18.QuickUnion ......................... 并查集_基于树思想实现
C++实例源代码（每一个代码都测试可用）
12-05
C++实例代码，从书上操下来的，经VC++6.0测试可用，希望可以帮到初学者。
C++编程实例100篇
08-28
C++编程实例100篇，里面有很多很基础的编程实例，可以作为参考。
C++学习013多态
DreamLife
08-13 1000
何为多态 面向对象最要的特征之一就是多态，而纯虚函数是实现多态的主要方式。它可以提供一个通过用的接口，同样调用一个方法， 由于运算对象不同，方法也不同，这也就是所谓的动态绑定。 #include #include using namespace std; class Animal { public: virtual void Cry()=0; }; /* void A
经典c++编程代码实例
05-05 3589
一.冒泡法： 这是最原初，也是众所周知的最慢的算法了。他的名字的由来因为它的工作看来象是冒泡： #include //统计substr在str中的个数 int fun(char *str,char *substr) {  int n=0;  char *q;  q=substr;  while(*str!='\0')  {   if(*str==*substr)    {
数据结构C++代码(大部分)—入门必看—代码大全。haut2020计科
m0_53321597的博客
03-01 3047
课设，数据结构，链表，树，图，排序
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值