【数据结构】链表的十三种操作

最新推荐文章于 2023-12-04 14:19:54 发布
最新推荐文章于 2023-12-04 14:19:54 发布
阅读量1.3k 收藏 14
点赞数 14
分类专栏： 数据结构 文章标签： 数据结构 链表 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/littlegengjie/article/details/134039810
版权

菜单 

//0、显示菜单
void menu()
{
    cout << "菜单：" << endl;
    cout << "1.初始化或重置链表" << endl;
    cout << "2.销毁链表" << endl;
    cout << "3.清空链表" << endl;
    cout << "4.链表长度" << endl;
    cout << "5.指定位置的元素值" << endl;
    cout << "6.链表已存在元素的位序" << endl;
    cout << "7.求输入元素的直接前驱" << endl;
    cout << "8.求输入元素的直接后继" << endl;
    cout << "9.在第i个位置插入一个元素" << endl;
    cout << "10.删除第i个元素" << endl;
    cout << "11.输出有的链表元素" << endl;
    cout << "12.初始化并用头插法（或尾插法）输入元素" << endl;
    cout << "13.实现单链表的逆序存放" << endl;
    cout << "-1.退出程序" << endl;
}

定义结构体 

// 定义结构体
typedef struct DNode
{
    EleType data;
    struct DNode *prior,*next;
}Dnode,*DLinkList;

1.初始化或重置链表


// 1、初始化双向链表
bool Init_linkList(DLinkList& L)
{
    L = (DNode*) malloc(sizeof(DNode));
    if(L == nullptr)
        return false;
    else
    {
        L->prior = nullptr;
        L->next = nullptr;
        return true;
    }
}

2.销毁链表

注：销毁链表时需要循环释放每个结点所占用的空间。


// 2、销毁链表
void DestroyLink(DNode *L){//为了避免内存泄露，每次创建链表运行完程序应将创建的链表销毁，避免内存泄露
    DNode *temp;
    DNode *pre;
    temp= L->next;
    while(temp != nullptr){
        pre = temp;
        temp = temp->next;
        free(pre);
    }
    free(L);
}

3.清空链表


// 3、清空双链表
bool ClearDLink(DNode* L)
{
    DNode *temp;
    DNode *pre;
    temp= L->next;
    while(temp != nullptr){
        pre = temp;
        temp = temp->next;
        free(pre);
    }
    L->next = nullptr;
    L->prior = nullptr;
    if(L->next == nullptr)
        return true;
    else
        return false;
}

4.链表长度


// 4、求双链表长度
int LengthLink(Dnode*L)
{
    int cnt = 0;
    DNode *temp;
    temp= L->next;
    while(temp != nullptr){
        temp = temp->next;
        cnt ++;
    }
    return cnt;
}

5.指定位置的元素值


// 5、指定位置元素
int elem_check(Dnode*L,int address)// 判断这个位置是否合法
{
    int cnt = LengthLink(L);
    if(address <= 0 || address > cnt) return false;
    return true;
}

EleType ElemLink(Dnode *L,int address)// 如果这个位置合法，则进行查找
{
    int cnt = 0;
    EleType flag;
    DNode *temp;
    DNode *pre;
    temp= L->next;
    while(temp != nullptr){
        pre = temp;
        temp = temp->next;
        if(++ cnt == address) flag = pre->data;
    }
    return flag;
}

6.链表已存在元素的位序


// 6.链表已存在元素的位序

bool judge_address(Dnode *L,EleType elem)
{
    DNode *temp;
    temp= L->next;
    while(temp != nullptr){
        if(temp->data == elem) return true;
        temp = temp->next;
    }
    return false;
}

int AddressLink(Dnode *L,EleType elem)
{
    int address = 0;
    int cnt = 0;
    DNode *temp;
    temp= L->next;
    while(temp != nullptr){
        cnt ++;
        if(temp->data == elem) address = cnt;
        temp = temp->next;
    }
    return address;
}

7.求输入元素的直接前驱


// 7.求输入元素的直接前驱

bool judge_before(Dnode *L,EleType elem)
{
    DNode *temp;
    temp= L->next;
    while(temp != nullptr){
        if(temp->data == elem)
        {
            if(temp->prior == L) return false;
            else return true;
        }
        temp = temp->next;
    }
    return false;
}

EleType BeforeLink(Dnode *L,EleType elem)
{
    EleType flag;
    DNode *temp;
    temp= L->next;
    while(temp != nullptr){
        if(temp->data == elem)
        {
            flag = temp->prior->data;
        }
        temp = temp->next;
    }
    return flag;
}

求前驱是指，输入一个元素值（而不是位置），求该元素在顺序表中的直接前驱元素值。

8.求输入元素的直接后继


// 8.求输入元素的直接后继
bool judge_after(Dnode *L,EleType elem)
{
    DNode *temp;
    temp= L->next;
    while(temp != nullptr){
        if(temp->data == elem)
        {
            if(temp->next == nullptr) return false;
            else return true;
        }
        temp = temp->next;
    }
    return false;
}

EleType AfterLink(Dnode *L,EleType elem)
{
    EleType flag;
    DNode *temp;
    temp= L->next;
    while(true){
        if(temp->data == elem)
        {
            flag = temp->next->data;
            break;
        }
        temp = temp->next;
    }
    return flag;
}

求后继是指：输入一个元素值（而不是位置），求该元素在顺序表中的直接后继元素值。

9.在第i个位置插入一个元素


// 9.在第i个位置插入一个元素

void LinkListInit(Dnode* L,int address,EleType elem)
{
    Dnode* l;
    l = (DNode*) malloc(sizeof(DNode));
    l->data = elem;
    int cnt = 0;
    DNode *temp;
    temp= L->next;
    int len = LengthLink(L);
    if(address == len + 1)
    {
        temp = L;
        while(true)
        {
            if(temp->next == nullptr)
            {
                l->next = nullptr;
                l->prior = temp;
                temp->next = l;
                return;
            }
            temp = temp->next;
        }
    }
    else
    {
        while(temp != nullptr){
            cnt ++;
            if(cnt == address)
            {
                l->next = temp;
                l->prior = temp->prior;
                temp->prior->next = l;
                temp->prior = l;
                return;
            }
            temp = temp->next;
        }
    }
}

10.删除第i个元素


// 10.删除第i个元素
void drop(Dnode* L,int address)
{
    int cnt = 0;
    DNode *temp;
    temp= L->next;
    int len = LengthLink(L);
    if(len == address)
    {
        while(true)
        {
            if(temp->next == nullptr)
            {
                temp->prior->next = nullptr;
                free(temp);
                return;
            }
            temp = temp->next;
        }
    }
    while(temp != nullptr){
        cnt ++;
        if(cnt == address)
        {
            temp->prior->next = temp->next;
            temp->next->prior = temp->prior;
            free(temp);
            return;
        }
        temp = temp->next;
    }
}

11.输出有的链表元素


// 11.输出有的链表元素
void show(Dnode* L)
{
    DNode *temp;
    temp= L->next;
    while(temp != nullptr){
        cout << temp->data << "  ";
        temp = temp->next;
    }
    cout << endl;
}

12.清空链表并用头插法（或尾插法）输入元素


// 12.清空并用头插法（或尾插法）输入元素
void show12(Dnode* L,int sum)
{
    ClearDLink(L);
    for(int i = 0; i < sum; i ++)
    {
        Dnode* l;
        l = (DNode*) malloc(sizeof(DNode));
        EleType num;
        cin >> num;
        l->data = num;
        l->next = L->next;
        l->prior = L;
        if(L->next != nullptr)
        {
            L->next->prior = l;
        }
        L->next = l;
    }
    show(L);
}

13.实现单链表的逆序存放


void show13(Dnode* L)
{
    queue<EleType> q;
    DNode *temp;
    DNode *p;
    temp= L->next;
    while(temp != nullptr){
        q.push(temp->data);
        p = temp;
        temp = temp->next;
        free(p);
    }
    L->next = nullptr;
    L->prior = nullptr;
    while(!q.empty())
    {
        EleType s;
        s = q.front();
        q.pop();
        DNode* l;
        l = (Dnode*) malloc(sizeof(DNode));
        l->data = s;
        l->next = L->next;
        l->prior = L;
        if(L->next != nullptr)
        {
            L->next->prior = l;
        }
        L->next = l;
    }
}

要求：所有的提示语和输出语句不允许出现在自定义的函数中(输出函数除外)，只能在main函数中出现提示语。

注意，每个功能模块一定要考虑非法的情况，并作出相应的提示，例如：求前驱，要分别能够测试第一个元素的前驱、其他正常的元素的前驱、输入一个在表中不存在的元素求其前驱，这三种情况应给出相应的提示语和结果值；插入和删除时要考虑插入或删除的位置是否合法等。

代码 

#include<bits/stdc++.h>
using namespace std;
typedef int EleType;

// 定义结构体
typedef struct DNode
{
    EleType data;
    struct DNode *prior,*next;
}Dnode,*DLinkList;

//0、显示菜单
void menu()
{
    cout << "菜单：" << endl;
    cout << "1.初始化或重置链表" << endl;
    cout << "2.销毁链表" << endl;
    cout << "3.清空链表" << endl;
    cout << "4.链表长度" << endl;
    cout << "5.指定位置的元素值" << endl;
    cout << "6.链表已存在元素的位序" << endl;
    cout << "7.求输入元素的直接前驱" << endl;
    cout << "8.求输入元素的直接后继" << endl;
    cout << "9.在第i个位置插入一个元素" << endl;
    cout << "10.删除第i个元素" << endl;
    cout << "11.输出有的链表元素" << endl;
    cout << "12.初始化并用头插法（或尾插法）输入元素" << endl;
    cout << "13.实现单链表的逆序存放" << endl;
    cout << "-1.退出程序" << endl;
}

// 1、初始化双向链表
bool Init_linkList(DLinkList& L)
{
    L = (DNode*) malloc(sizeof(DNode));
    if(L == nullptr)
        return false;
    else
    {
        L->prior = nullptr;
        L->next = nullptr;
        return true;
    }
}

// 2、销毁链表
void DestroyLink(DNode *L){//为了避免内存泄露，每次创建链表运行完程序应将创建的链表销毁，避免内存泄露
    DNode *temp;
    DNode *pre;
    temp= L->next;
    while(temp != nullptr){
        pre = temp;
        temp = temp->next;
        free(pre);
    }
    free(L);
}


// 3、清空双链表
bool ClearDLink(DNode* L)
{
    DNode *temp;
    DNode *pre;
    temp= L->next;
    while(temp != nullptr){
        pre = temp;
        temp = temp->next;
        free(pre);
    }
    L->next = nullptr;
    L->prior = nullptr;
    if(L->next == nullptr)
        return true;
    else
        return false;
}

// 4、求双链表长度
int LengthLink(Dnode*L)
{
    int cnt = 0;
    DNode *temp;
    temp= L->next;
    while(temp != nullptr){
        temp = temp->next;
        cnt ++;
    }
    return cnt;
}

// 5、指定位置元素
int elem_check(Dnode*L,int address)
{
    int cnt = LengthLink(L);
    if(address <= 0 || address > cnt) return false;
    return true;
}
EleType ElemLink(Dnode *L,int address)
{
    int cnt = 0;
    EleType flag;
    DNode *temp;
    DNode *pre;
    temp= L->next;
    while(temp != nullptr){
        pre = temp;
        temp = temp->next;
        if(++ cnt == address) flag = pre->data;
    }
    return flag;
}

// 6.链表已存在元素的位序

bool judge_address(Dnode *L,EleType elem)
{
    DNode *temp;
    temp= L->next;
    while(temp != nullptr){
        if(temp->data == elem) return true;
        temp = temp->next;
    }
    return false;
}

int AddressLink(Dnode *L,EleType elem)
{
    int address = 0;
    int cnt = 0;
    DNode *temp;
    temp= L->next;
    while(temp != nullptr){
        cnt ++;
        if(temp->data == elem) address = cnt;
        temp = temp->next;
    }
    return address;
}

// 7.求输入元素的直接前驱

bool judge_before(Dnode *L,EleType elem)
{
    DNode *temp;
    temp= L->next;
    while(temp != nullptr){
        if(temp->data == elem)
        {
            if(temp->prior == L) return false;
            else return true;
        }
        temp = temp->next;
    }
    return false;
}

EleType BeforeLink(Dnode *L,EleType elem)
{
    EleType flag;
    DNode *temp;
    temp= L->next;
    while(temp != nullptr){
        if(temp->data == elem)
        {
            flag = temp->prior->data;
        }
        temp = temp->next;
    }
    return flag;
}

// 8.求输入元素的直接后继
bool judge_after(Dnode *L,EleType elem)
{
    DNode *temp;
    temp= L->next;
    while(temp != nullptr){
        if(temp->data == elem)
        {
            if(temp->next == nullptr) return false;
            else return true;
        }
        temp = temp->next;
    }
    return false;
}

EleType AfterLink(Dnode *L,EleType elem)
{
    EleType flag;
    DNode *temp;
    temp= L->next;
    while(true){
        if(temp->data == elem)
        {
            flag = temp->next->data;
            break;
        }
        temp = temp->next;
    }
    return flag;
}


// 9.在第i个位置插入一个元素

void LinkListInit(Dnode* L,int address,EleType elem)
{
    Dnode* l;
    l = (DNode*) malloc(sizeof(DNode));
    l->data = elem;
    int cnt = 0;
    DNode *temp;
    temp= L->next;
    int len = LengthLink(L);
    if(address == len + 1)
    {
        temp = L;
        while(true)
        {
            if(temp->next == nullptr)
            {
                l->next = nullptr;
                l->prior = temp;
                temp->next = l;
                return;
            }
            temp = temp->next;
        }
    }
    else
    {
        while(temp != nullptr){
            cnt ++;
            if(cnt == address)
            {
                l->next = temp;
                l->prior = temp->prior;
                temp->prior->next = l;
                temp->prior = l;
                return;
            }
            temp = temp->next;
        }
    }
}

// 10.删除第i个元素
void drop(Dnode* L,int address)
{
    int cnt = 0;
    DNode *temp;
    temp= L->next;
    int len = LengthLink(L);
    if(len == address)
    {
        while(true)
        {
            if(temp->next == nullptr)
            {
                temp->prior->next = nullptr;
                free(temp);
                return;
            }
            temp = temp->next;
        }
    }
    while(temp != nullptr){
        cnt ++;
        if(cnt == address)
        {
            temp->prior->next = temp->next;
            temp->next->prior = temp->prior;
            free(temp);
            return;
        }
        temp = temp->next;
    }
}

// 11.输出有的链表元素
void show(Dnode* L)
{
    DNode *temp;
    temp= L->next;
    while(temp != nullptr){
        cout << temp->data << "  ";
        temp = temp->next;
    }
    cout << endl;
}

// 12.初始化并用头插法（或尾插法）输入元素
void show12(Dnode* L,int sum)
{
    ClearDLink(L);
    for(int i = 0; i < sum; i ++)
    {
        Dnode* l;
        l = (DNode*) malloc(sizeof(DNode));
        EleType num;
        cin >> num;
        l->data = num;
        l->next = L->next;
        l->prior = L;
        if(L->next != nullptr)
        {
            L->next->prior = l;
        }
        L->next = l;
    }
    show(L);
}

void show13(Dnode* L)
{
    queue<EleType> q;
    DNode *temp;
    DNode *p;
    temp= L->next;
    while(temp != nullptr){
        q.push(temp->data);
        p = temp;
        temp = temp->next;
        free(p);
    }
    L->next = nullptr;
    L->prior = nullptr;
    while(!q.empty())
    {
        EleType s;
        s = q.front();
        q.pop();
        DNode* l;
        l = (Dnode*) malloc(sizeof(DNode));
        l->data = s;
        l->next = L->next;
        l->prior = L;
        if(L->next != nullptr)
        {
            L->next->prior = l;
        }
        L->next = l;
    }
}


int main()
{
    DLinkList L;
    int op = -1;
    bool flag = false;
    menu();
    while(op != 0)
    {
        cout << "<------------------------------>" << endl << "请输入你的选择：";
        cin >> op;
        if(op == 1)
        {
            // 1.初始化或重置链表
            if(Init_linkList(L))
            {
                cout << "初始化成功！" << endl;
                flag = true;
            }
            else cout << "初始化失败！" << endl;
        }else if(op == 2)
        {
            if(!flag)
            {
                cout << "链表已被销毁" << endl;
                continue;
            }
            // 2.销毁链表
            DestroyLink(L);
            flag = false;
            cout << "成功销毁链表！" << endl;
        }else if(op == 3)
        {
            // 3.清空链表
            if(!flag)
            {
                cout << "链表已被销毁" << endl;
                continue;
            }
            if(ClearDLink(L))
                cout << "清空链表成功！" << endl;
            else
                cout << "清空链表失败！" << endl;
        }else if(op == 4)
        {
            // 4.链表长度
            if(!flag)
            {
                cout << "链表已被销毁" << endl;
                continue;
            }
            int l = LengthLink(L);
            cout << "链表长度为：" << l << endl;
        }else if(op == 5)
        {
            // 5.指定位置的元素值
            if(!flag)
            {
                cout << "链表已被销毁" << endl;
                continue;
            }
            int address;
            cout << "请输入位置：";
            cin >> address;
            if(elem_check(L,address))
            {
                EleType ans = ElemLink(L,address);
                cout << "第" << address << "位置的元素为：" << ans << endl;
            }
            else
            {
                cout << "这个位置没有元素！" << endl;
            }
        }else if(op == 6)
        {
            // 6.链表已存在元素的位序
            if(!flag)
            {
                cout << "链表已被销毁" << endl;
                continue;
            }
            EleType elem;
            cout << "请输入查找的元素：";
            cin >> elem;
            if(judge_address(L,elem))
            {
                int address = AddressLink(L,elem);
                cout << "值" << elem << "的位置在" << address << endl;
            }
            else
            {
                cout << "链表中不存在这个值！" << endl;
            }
        }else if(op == 7)
        {
            // 7.求输入元素的直接前驱
            if(!flag)
            {
                cout << "链表已被销毁" << endl;
                continue;
            }
            EleType elem;
            cout << "请输入查找的元素：";
            cin >> elem;
            if(judge_before(L,elem))
            {
                EleType ans;
                ans = BeforeLink(L,elem);
                cout << "元素" << elem << "的直接前驱为：" << ans << endl;
            }
            else
            {
                cout << "这个值没有直接前驱！" << endl;
            }
        }else if(op == 8)
        {
            // 8.求输入元素的直接后继
            if(!flag)
            {
                cout << "链表已被销毁" << endl;
                continue;
            }
            EleType elem;
            cout << "请输入查找的元素：";
            cin >> elem;
            if(judge_after(L,elem))
            {
                EleType ans;
                ans = AfterLink(L,elem);
                cout << "元素" << elem << "的直接后继为：" << ans << endl;
            }
            else
            {
                cout << "这个值没有直接后继！" << endl;
            }
        }
        else if(op == 9)
        {
            // 9.在第i个位置插入一个元素
            if(!flag)
            {
                cout << "链表已被销毁" << endl;
                continue;
            }
            int len;
            len = LengthLink(L);
            int address;
            cout << "输入插入位置：";
            cin >> address;
            EleType elem;
            cout << "输入插入元素：";
            cin >> elem;
            if(address < 1 || address > len + 1)
            {
                cout << "这个位置不能插入元素" << endl;
            }
            else
            {
                LinkListInit(L,address,elem);
                cout << "插入成功！" << endl;
            }
        }
        else if(op == 10)
        {
            // 10.删除第i个元素
            if(!flag)
            {
                cout << "链表已被销毁" << endl;
                continue;
            }
            int address;
            cout << "请输入元素位置：";
            cin >> address;
            int len = LengthLink(L);
            if(address < 1 || address > len)
            {
                cout << "这个位置不能删除"<< endl;
                continue;
            }
            drop(L,address);
            cout << "删除成功！" << endl;
        }
        else if(op == 11)
        {
            // 11.输出有的链表元素
            if(!flag)
            {
                cout << "链表已被销毁" << endl;
                continue;
            }
            show(L);
        }
        else if(op == 12)
        {
            // 12.初始化并用头插法（或尾插法）输入元素
            if(!flag)
            {
                cout << "链表已被销毁" << endl;
                continue;
            }
            cout << "初始化并用头插法（或尾插法）输入元素" << endl;
            cout << "请输入插入元素个数：";
            int sum;
            cin >> sum;
            show12(L,sum);
        }
        else if(op == 13)
        {
            // 13.实现单链表的逆序存放
            if(!flag)
            {
                cout << "链表已被销毁" << endl;
                continue;
            }
            show13(L);
        }
        else if(op == -1) break;
    }
    cout << "程序结束！" << endl;
}

一只大黄猫
关注
  • 14
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
「算法与数据结构」链表的9个基本操作
webyouxuan的博客
09-07 800
戳蓝字"前端优选"关注我们哦！前言数据结构中的链表还是很重要的，所以这章节把剑指offer 和 LeetCode 中的相关题目做一个汇总，分享给大家????说真的，有时候...
链表的常见操作
让你爱上电路设计
05-12 204
链表的常见操作
【数据结构】链表的基本操作
m0_53171456的博客
03-11 8297
规划 /* 链表的基本操作 */ #include<iostream> #include<algorithm> #define ElemType int using namespace std; typedef struct LNode{ ElemType data; //数据域 LNode *next; //指针域 } *LinkList; //链表的初始化 void IniteList(LinkList &L){ L = new LNode; //创建头结点
链表的基本操作--c语言
qq_51533157的博客
06-25 5947
链表是数据结构中一种最基本的数据结构，它是用链式存储结构实现的线性表。它较顺序表而言在插入和删除时不必移动其后的元素。现在给你一些整数，然后会频繁地插入和删除其中的某些元素，会在其中某些时候让你查找某个元素或者输出当前链表中所有的元素。 下面给你基本的算法描述： 图1：链表类型的定义以及获得链表元素的算法描述 图2：链表的插入算法描述 图3：链表的删除算法描述 图4：链表的创建算法描述 输入 输入数据只有一组，第一行有n+1个整数，第一个整数是这行余下的整数数目n，后面是n个整
【链表】链表的基本操作
nakyoooooo的博客
05-29 117
val;} }
链表基础操作
weixin_73494910的博客
09-06 185
链表基本操作
各类链表的使用
qq_73882414的博客
05-02 74
整体代码如上,.需要注意的是.在使用链表时,应该注意一些特殊位置,比如头结点和尾结点.而带头结点的创建方式之所以相对于无头结点来说更好,就是可以使对第一个数据更改变得不再"特殊",比如可以直接在第一个位置插入.而在代码健壮性方面,需要注意的是尾结点的next指针域为NULL,可以通过if条件句的判断来增加代码的健壮性.值得注意的是,头插法的思路也用于链表原地逆置(不是使用新的链表,不断将最后一个元素插入值第一个)然而,静态链表不能增加链表长度,在链表声明时,长度已经固定.所以,这并不是一个非常重要的考点.
C语言 数据结构链表的实例（十九种操作）
08-29
C语言数据结构链表的实例（十九种操作） 在计算机科学中，数据结构是指计算机中存储、组织和管理数据的方式。链表是一种基本的数据结构，广泛应用于计算机科学和软件开发中。今天，我们将讨论C语言中的数据结构链表...
C语言实现数据结构和双向链表操作
01-21
数据结构 双向链表的实现 双向链表中的每一个结点都含有两个指针域，一个指针域存放其后继结点的存储地址，另一个指针域则存放其前驱结点的存储地址。 双向链表结点的类型描述： //双向链表的类型描述 typedef ...
头歌数据结构二叉树的二叉链表存储及基本操作
05-18
在IT领域，数据结构是计算机科学的基础，而二叉树是一种重要的抽象数据类型。本题主要涉及二叉树的链式存储方式以及基于链表的二叉树的基本操作，包括先序遍历、计算二叉树的高度、节点总数、叶子节点数、层次遍历...
数据结构链表入门.docx
01-13
《数据结构链表入门》 链表是一种基础且重要的数据结构，在计算机科学中扮演着不可或缺的角色。本资料主要介绍链表的基本概念、操作以及如何在C++中实现链表。以下将详细阐述链表的原理及其在代码中的体现。 1. ...
P9 链表 清空链表|销毁链表
最新发布
weixin_73901182的博客
12-04 1406
🎬 个人主页：@ChenPi🐻推荐专栏1: 《》✨✨✨🔥 推荐专栏2: 《》✨✨✨📝推荐专栏3: ​​​​​​《》 ✨✨✨🍉本篇简介 : 链表清空链表|销毁链表✨ 只有我努力了 才有机会接触成功✨链表是一种常见的基础数据结构，结构体指针在这里得到了充分的利用。链表可以动态的进行存储分配，也就是说，链表是一个功能极为强大的数组，他可以在节点中定义多种数据类型，还可以根据需要随意增添，删除，插入节点。链表都有一个头指针，一般以head来表示，存放的是一个地址。
链表的遍历、插入、删除、清空、销毁操作
qq_45432387的博客
05-03 3897
一、在这里链表的基本操作包括以下几点： 1.初始化链表：输入-1退出链表，输入其他值写入链表 2.遍历链表：打印输入的数字 3.插入链表：插入链表的基本思想为 1）创建指针pCurrent指向要查找的数字 2）初见前置指针pPrve指向查找数字的前一级 3）插入后建立指针关系，即插入的新数字的指针newNode指向查找数字的指针pCurrent，查找数字的前一级的指针pPrve指向插入的新数字的指针newNoded newNode->next = pCurrent; pPrve-&
链表的输出
2201_75456648的博客
03-20 1666
链表属于线性表,它是由结点组成的。分为两个部分：数据域和指针域。
链表的用法
布呗之路
06-29 1322
久违的链表 mua mua mua ！！！#include&lt;bits/stdc++.h&gt; using namespace std; struct node{ int data; // 单链表的数据域 struct node *Next; // 单链表的指针域 }; /** 建立1：头插，逆序 */ node *creat1(int n){ node *he...
链表的基本操作
09-20 5726
链表的基本概念以及分配内存空间 1.创建链表 把每个结点的next指针指向下一个结点的地址即可。 程序代码： #include<cstdio> //#include<stdlib> struct node { int data; //数据域 node* next; // 指针域 }; //创建链表 node* create(int Array[...
【C++】链表及基本操作
程序媛养成记
06-16 6万+
链表及基本操作定义基本操作1. 插入节点2. 删除节点3. 反转链表4. 倒数第K个节点5. 是否有环 本文所述均为单向链表。 定义 struct ListNode{ int val; struct ListNode* next; LsiatNode(int val): val(x), next(NULL){ } } 基本操作 1. 插入节点 2. 删除节点 3. 反转链表 4. 倒...
链表常见操作
码农在途的博客
03-02 549
链表常见类型 每一种新数据结构的出现都是为了解决原有数据结构的不足。链表的出现正是为了补充数组只能连续存储的不足。这种离散存储的方式自然携带了动态存储的特性。 单链表 单链表 是链表中最为常见的链表形式，链表中只有一个指向下一结点的指针。链表中的最后一个结点通常指向 NULL，表示链表的结束。 //Definition for singly-linked list. struct ListNod...
一步一步教你从零开始写C语言链表
热门推荐
Bruce.yang的嵌入式之旅
04-02 17万+
完整源码获取： 微信关注：嵌入式开发圈 发送"链表"即可获取。 为什么要学习链表？ 链表主要有以下几大特性： 1、解决数组无法存储多种数据类型的问题。 2、解决数组中，元素个数无法改变的限制(C99的变长数组，C++也有变长数组可以实现)。 3、数组移动元素的过程中，要对元素进行大范围的移动，很耗时间，效率也不高。 先来感性的认识一下链表,我们先来认识下简单的链表: 从这幅图我们...
数据结构链表操作大全+面向对象封装
09-14
数据结构中对链表的操作大全，亲写、亲调、测试，加上在对象上的封装。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

一只大黄猫

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值