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

已于 2022-10-27 17:52:27 修改
阅读量5.2k 收藏 97
点赞数 13
文章标签： 数据结构 c++ 算法 考研
于 2022-10-18 16:13:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DDDBOOM/article/details/127280185
版权

目录

简介

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

基础

结构体

// 定义结构体
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
关注
  • 13
    点赞
  • 踩
  • 97
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
C++最简单代码示例1
10-25
C++最简单代码示例1 构造顺序 一个示例代码
c++ 初学者10个练习代码
m0_70215122的博客
10-22 849
运行结果。
c++常用代码（持续更新）
进击的菜鸟
06-29 1万+
#include <iostream> #include <string> #include <chrono> void Run() { for (int i = 0; i < 1000000000; ++i) { } } int main() { auto beforeTime = std::chrono::steady_clock::now(); Run(); auto afterTime = std::chrono::steady_.
C++基础编程总结（代码实例）
马上到我碗里来的博客
02-20 2053
数据类型 数组名[ 数组长度 ];数据类型 数组名[ 数组长度 ] = { 值1，值2 ...};数据类型 数组名[ ] = { 值1，值2 ...};//定义方式1//数据类型 数组名[元素个数];//利用下标赋值//利用下标输出//第二种定义方式//数据类型 数组名[元素个数] = {值1，值2 ，值3 ...};//如果{}内不足10个数据，剩余数据用0补全//逐个输出//一个一个输出太麻烦，因此可以利用循环进行输出i < 10;i++)
C++的各种内部库与功能（附源代码）
kivyp的博客
08-05 1699
嗨大家好！今天给大家带来一篇简介C++/C里的内置模块的功能及示例代码！
C++代码大全
Edidaughter的博客
09-22 3895
string::npos
c++（基础）
qq_56618414的博客
08-09 9898
所谓数组，就是一个集合，里面存放了相同类型的数据元素数组中的每个==数据元素都是相同的数据类型==数组是由连续的内存位置组成的将一段经常使用的代码封装起来，减少重复代码一个较大的程序，一般分为若干个程序块，每个模块实现特定的功能。函数的定义一般主要有5个步骤：1、返回值类型2、函数名3、参数表列4、函数体语句5、return 表达式返回值类型 函数名 （参数列表）{函数体语句return表达式}返回值类型 ：一个函数可以返回一个值。在函数定义中函数名：给函数起个名称。...
经典c++编程代码实例
05-05 3362
一.冒泡法： 这是最原初，也是众所周知的最慢的算法了。他的名字的由来因为它的工作看来象是冒泡： #include //统计substr在str中的个数 int fun(char *str,char *substr) {  int n=0;  char *q;  q=substr;  while(*str!='\0')  {   if(*str==*substr)    {
C++经典程序代码大全
热门推荐
zhusg的专栏
04-14 15万+
//根据半径计算圆的周长和面积 #include const float PI=3.1416; //声明常量(只读变量)PI为3.1416 float fCir_L(float); //声明自定义函数fCir_L()的原型 float fCir_S(float); //声明自定义函数fCir_S()的原型 //以下是main()函数
C++小例子【未更新完】
海到无边天作岸 山登绝顶我为峰
04-21 3830
题目1 全排列 用1、2、3三个数字 可以组成多少个没有重复数字的三位数？ 打印出所有的可能 解答 参考Demo - C++ #include <iostream> #include <vector> using namespace std; vector<int> temp; // 临时保存已经选择的数 // backtracking：回溯 void backtracking(vector<vector<int> > &res, ve
C++类与对象超详细附代码例子讲解，入门必看
m0_73421035的博客
03-27 1598
构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用。C++中的面向对象来源于生活，每个对象也都会有初始设置以及 对象销毁前的清理数据的设置。人可以作为对象，属性有姓名、年龄、身高、体重...，行为有走、跑、跳、吃饭、唱歌...设计一个学生类，属性有姓名和学号，可以给姓名和学号赋值，可以显示学生的姓名和学号。总结：如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题。C++类中的成员可以是另一个类的对象，我们称该成员为 对象成员。
C++学习代码（实例）
06-03
++内存管理详解 伟大的Bill Gates 曾经失言： 　　640K ought to be enough for everybody — Bill Gates 1981 　　程序员们经常编写内存管理程序，往往提心吊胆。如果不想触雷，唯一的解决办法就是发现所有潜伏的地雷并且排除它们，躲是躲不了的。本文的内容比一般教科书的要深入得多，读者需细心阅读，做到真正地通晓内存管理。 　　1、内存分配方式 　　内存分配方式有三种： 　　（1）从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，static变量。 　　（2）在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。 　　（3） 从堆上分配，亦称动态内存分配。程序在运行的时候用malloc或new申请任意多少的内存，程序员自己负责在何时用free或delete释放内存。动态内存的生存期由我们决定，使用非常灵活，但问题也最多。
新手学习C++入门资料
12-28
C++是C的超集，也可以说C是C++的子集，因为C先出现。按常理说，C++编译器能够编译任何C程序，但是C和C++还是有一些小差别。 例如C++增加了C不具有的关键字。这些关键字能作为函数和变量的标识符在C程序中使用，...
Visual C++实践与提高-COM和COM+篇『PDF』
05-22
5.4 在Visual C＋＋中使用代码组件 5.4.1 利用OLE／COM Object Viewer查看组件信息 5.4.2 利用COM库函数使用代码组件——例程VCAuotCom 5.4.3 通过ClassWizard使用代码组件——例程VCAuotClw 5.4.4 利用＃import指令...
精通Windows.API-函数、接口、编程实例.pdf
01-27
2.1.4　Windows中的数据结构　15 2.2　Windows API的功能分类　15 2.2.1　系统基本服务　15 2.2.2　系统管理　17 2.2.3　用户界面　17 2.2.4　图像和多媒体　20 2.2.5　网络　20 2.2.6　系统安全　20 2.2.7　其他...
精通WindowsAPI 函数 接口 编程实例
01-08
2.1.4　Windows中的数据结构　15 2.2　Windows API的功能分类　15 2.2.1　系统基本服务　15 2.2.2　系统管理　17 2.2.3　用户界面　17 2.2.4　图像和多媒体　20 2.2.5　网络　20 2.2.6　系统安全　20 2.2.7　其他...
数据结构七：线性表之链式栈的设计
weixin_47040031的博客
04-27 604
从以上分析，我们可以知道链式栈只是单链表的一种特殊情况，限定了数据元素的插入和删除位置，链式栈是一种基于单链表实现的栈，在空间复杂度上，顺序栈在创建时就申请了数组空间，若栈经常处于不满状态将造成存储空间的浪费；链式栈所需空间是根据需要随时申请的，比之顺序栈仅仅是其每个结点需要额外的空间以存储其next指针域。在时间复杂度上，对于针对栈顶的基本操作（压入、弹出和栈顶元素存取），容易看出，顺序栈和链式栈的时间复杂性均为O(1)。
【数据结构】图的应用（最小生成树、拓扑排序、最短路径等）
最新发布
2201_75475240的博客
04-27 720
本文章介绍数据结构中的图的应用，包括最小生成树的Prim算法和Kruskal算法，拓扑排序和最短路径，且还包含408习题（附有解析）。此外，含有关于Prim算法，Kruskal算法和Dijkstra算法全部具体实现代码。
数据结构––复杂度
2301_80190473的博客
04-27 669
是一个数学表达式，是对一个算法在运行过程中临时占用额外存储空间大小的量度空间复杂度不是程序占用了多少bytes的空间，因为这个也没太大意义，所以空间复杂度算的是变量的个数。空间复杂度计算规则基本跟时间复杂度类似，也使用大O渐进表示法。注意：函数运行时所需要的栈空间(存储参数、局部变量、一些寄存器信息等)在编译期间已经确定好了，因此空间复杂度主要通过函数在运行时候显式申请的额外空间来确定。
数据结构 C++ 代码
09-01
当然，我可以为您提供一些常见的数据结构的C代码示例。以下是几个常见的数据结构及其对应的C代码示例： 1. 数组（Array）： ``` #include <stdio.h> int main() { int arr[5] = {1, 2, 3, 4, 5}; // 访问数组元素 for (int i = 0; i < 5; i++) { printf("%d ", arr[i]); } printf("\n"); return 0; } ``` 2. 链表（Linked List）： ``` #include <stdio.h> #include <stdlib.h> // 定义链表结点 struct Node { int data; struct Node* next; }; // 打印链表 void printLinkedList(struct Node* head) { while (head != NULL) { printf("%d ", head->data); head = head->next; } printf("\n"); } int main() { // 创建链表结点 struct Node* head = NULL; struct Node* second = NULL; struct Node* third = NULL; head = (struct Node*)malloc(sizeof(struct Node)); second = (struct Node*)malloc(sizeof(struct Node)); third = (struct Node*)malloc(sizeof(struct Node)); head->data = 1; head->next = second; second->data = 2; second->next = third; third->data = 3; third->next = NULL; // 打印链表 printLinkedList(head); return 0; } ``` 3. 栈（Stack）： ``` #include <stdio.h> #define MAX_SIZE 100 int stack[MAX_SIZE]; int top = -1; // 入栈 void push(int item) { if (top >= MAX_SIZE - 1) { printf("Stack Overflow\n"); } else { stack[++top] = item; } } // 出栈 int pop() { if (top < 0) { printf("Stack Underflow\n"); return -1; } else { return stack[top--]; } } // 打印栈顶元素 int peek() { if (top < 0) { printf("Stack is empty\n"); return -1; } else { return stack[top]; } } // 判断栈是否为空 int isEmpty() { return top < 0; } int main() { push(1); push(2); push(3); printf("Top element: %d\n", peek()); printf("Elements: "); while (!isEmpty()) { printf("%d ", pop()); } printf("\n"); return 0; } ``` 这些是常见的数据结构的C代码示例。希望对您有所帮助！如果你需要其他数据结构或更多代码示例，请告诉我。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值