数据结构链表（单链表）

已于 2023-10-09 22:46:18 修改
阅读量109 收藏
点赞数 1
文章标签： 数据结构 链表
于 2023-10-07 21:54:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73613602/article/details/133657296
版权

目录

结点的定义

链表的操作

链表的前插

链表的后插

链表的初始化

链表的取值

链表的查找

链表的插入

链表的删除

删除链表中的重复元素

链表排序（升序和降序）

合并两个升序的链表

反转链表

销毁链表

链表的遍历

链表的实现

.h文件

.cpp文件

main.cpp文件

运行试例

欢迎指正

结点的定义

重定义elemtype为新的数据类型，用法与int相同。这可以方便修改链表的数据域，只需要修改重定义即可。

typedef int elemtype;

下面是结点的基本结构

typedef struct m{
    elemtype n;
    struct m *next;
}list,*plist;

链表的操作

选择带头结点的链表方便对链表进行操作。

链表的前插

void createlist_h(plist &l,int n)//前插n个元素
{
    //定义一个带头结点的链表
    l=new list;
    //将头指针的下一个节点指向空
    l->next=NULL;
    //定义一个指针t，初始值为空
    plist t;
    //定义一个变量i，初始值为0
    int i;
    //当i小于n时，循环执行以下操作
    for(i=0;i<n;i++)
    {
        //定义一个新节点
        t=new list;
        //输入新节点的值
        cin>>t->n;
        //将新节点的指针指向头指针的下一个节点
        t->next=l->next;
        //将头指针的下一个节点指向新节点
        l->next=t;
    }
}

链表的后插

void createlist_r(plist &l,int n)//后插n个元素
{
    //定义一个带头结点的链表
    l=new list;
    //将头指针的下一个节点指向空
    l->next=NULL;
    //定义一个指针t，初始值为l
    plist t,r=l;
    //定义一个变量i，初始值为0
    int i;
    //当i小于n时，循环执行以下操作
    for(i=0;i<n;i++)
    {
        //定义一个新节点
        t=new list;
        //输入新节点的值
        cin>>t->n;
        //将新节点的指针指向r的下一个节点
        t->next=r->next;
        //将r的下一个节点指向新节点
        r->next=t;
        t->next=NULL;
        r=t;
    }
}

链表的初始化

bool initlist(plist &l)//初始化带头结点的链表
{
    //定义一个带头结点的链表
    l=new list;
    //将头指针的下一个节点指向空
    l->next=NULL;
    //返回1
    return 1;
}

链表的取值

bool getelem(plist l,int i,elemtype &e)//取出第i个结点的数据赋值给e
{
    //定义变量j，初始值为1
    int j=1;
    //定义变量p，初始值为l的下一个节点
    plist p=l->next;
    //当j小于i，且p不为空时，循环执行以下操作
    while(j<i&&p)
    {    
        //将p指向下一个节点
        p=p->next;
        //将j加1
        j++;
    }
    //当p为空，或者j大于i时，返回0
    if(!p||j>i)return 0;
    //将p的值赋给e
    e=p->n;
    //返回1
    return 1;
}

链表的查找

plist locatelem(plist l,elemtype e)//查找值为e的结点
{
    //定义一个指针p，初始值为l的下一个节点
    plist p=l->next;
    //当p不为空，且p的下一个节点为空时，循环执行以下操作
    while(p&&!p->next)
        p=p->next;
    //返回p
    return p;
}

链表的插入

bool listinsert(plist &l,int i,elemtype e)//在第i个结点前插入元素e
{
    //定义一个指针p，初始值为l
    plist p=l,t=new list;
    //定义一个变量j，初始值为0
    int j=0;
    //当p不为空，且j小于i-1时，循环执行以下操作
    while(p&&j<i-1)
    {
        //将p指向下一个节点
        p=p->next;
        //将j加1
        j++;
    }
    if(!p&&j>i-1)return 0;
    //当p为空，或者j大于i-1时，返回0
    if(!p||j>i-1)return 0;
    //将e赋给t
    t->n=e;
    //将t的指针指向p的下一个节点
    t->next=p->next;
    //将p的指针指向t
    p->next=t;
    //返回1
    return 1;
}

链表的删除

bool listdelete(plist &l,int i)//删除第i个元素
{
    //定义一个指针p，初始值为l
    plist p=l,t;
    //定义一个变量j，初始值为0
    int j=0;
    //当p的下一个节点不为空，且j小于i-1时，循环执行以下操作
    while(p->next&&j<i-1)
    {
        //将p指向下一个节点
        p=p->next;
        //将j加1
        j++;
    }
    //当p的下一个节点为空，或者j大于i-1时，返回0
    if(!p->next||j>i-1)return 0;
    //将p的指针指向下一个节点
    t=p->next;
    //将t的指针指向空
    p->next=t->next;
    //删除t
    delete t;
    //返回1
    return 1;
}

删除链表中的重复元素

void ddlist(plist &l)//删除链表中的重复元素
{
    //p指向当前节点，t指向下一个节点
    plist p=l->next,t,t1,m;
    while(p)
    {
        //t指向下一个节点
        t=p->next;
        //t1指向当前节点
        t1=p;
        //m指向当前节点
        while(t)
        {
            //如果当前节点和下一个节点值相同
            if(p->n==t->n)
            {
                //m指向下一个节点
                m=t;
                //t指向下一个节点
                t=t->next;
                //将当前节点指向下一个节点
                t1->next=t;
                //删除m指向的节点
                delete m;
            }
            else {
                //t1指向下一个节点
                t1=t;
                //t指向下一个节点
                t=t->next;
            }
        }
        //p指向下一个节点
        p=p->next;
    }
}

链表排序（升序和降序）

void sortlist(plist &l,int i)//链表排序
{
    //定义一个指针p指向当前节点，初始值为l的下一个节点
    plist p=l->next,t;
    elemtype m;
    if(i==0)//升序
    while(p)
    {
        //定义一个指针t指向当前节点的下一个节点
        t=p->next;
        //当t不为空时，循环比较p和t的n值
        while(t)
        {
            //如果p的n值大于t的n值，交换p和t的n值
            if(p->n>t->n)
            {
                m=p->n;
                p->n=t->n;
                t->n=m;
            }
            else t=t->next;
            //t指向t的下一个节点
        }
        //p指向p的下一个节点
        p=p->next;
    }
    else if(i==1)//降序
    while(p)
    {
        //定义一个指针t指向当前节点的下一个节点
        t=p->next;
        //当t不为空时，循环比较p和t的n值
        while(t)
        {
            //如果p的n值小于t的n值，交换p和t的n值
            if(p->n<t->n)
            {
                m=p->n;
                p->n=t->n;
                t->n=m;
            }
            else t=t->next;
            //t指向t的下一个节点
        }
        //p指向p的下一个节点
        p=p->next;
    }
    //显示链表
    display(l);
}

合并两个升序的链表

plist mergelist(plist l,plist i)//合并两个升序的链表
{
    // l: 第一个链表，i: 第二个链表
    plist p=l->next,t=i->next,l1,l2;
    // p: 第一个链表的指针，t: 第二个链表的指针，l1: 合并后的链表，l2: 合并后的链表的指针
    initlist(l1);
    // 初始化合并后的链表
    l2=l1;
    // l2: 合并后的链表的指针
    while(p&&t)
    {
        // 当两个链表都不为空时
        if(p->n<=t->n)
        {
            // 如果第一个链表的指针的值小于等于第二个链表的指针的值
            l2->next=p;
            // 将第一个链表的指针的值赋值给l2的指针的下一个值
            p=p->next;
            // 将第一个链表的指针的值指向下一个值
            l2=l2->next;
            // 将l2的指针的值指向下一个值
            l2->next=NULL;
            // 将l2的指针的值指向空
        }
        else 
        {
            // 如果第一个链表的指针的值大于第二个链表的指针的值
            l2->next=t;
            // 将第二个链表的指针的值赋值给l2的指针的下一个值
            t=t->next;
            // 将第二个链表的指针的值指向下一个值
            l2=l2->next;
            // 将l2的指针的值指向下一个值
            l2->next=NULL;
            // 将l2的指针的值指向空
        }
    }
    if(!p)l2->next=t;
    // 如果第一个链表的指针为空，将第二个链表的指针的值赋值给l2的指针的下一个值
    else l2->next=p;
    // 将第一个链表的指针的值赋值给l2的指针的下一个值
    return l1;
    // 返回合并后的链表
}

反转链表

void imagelist(plist &l)//反转链表
{
    plist p,t,t1,q=l->next;
    while(q->next)q=q->next;//q指向最后一个结点，作为反转后的首元结点
    while(1)
    {
        p=t=l->next;
        while(t->next)//t指向当前链表的最后一个结点
        {
            t1=t;
            t=t->next;
        }
        t->next=t1;//t之前倒数第二个结点
        t1->next=NULL;//将t剔除
        t=t->next;//t指向新链表的最后一个结点
        if(t==p)break;
    }
    l->next=q;//l的头结点指向q
}

销毁链表

void breaklist(plist &l)//销毁链表
{
    // l: 链表
    plist p=l->next,t;
    // p: 链表的指针，t: 链表的指针
    while(p)
    {
        t=p;
        p=p->next;
        delete t;
        // 删除链表的指针的值指向的值
    }
    delete l;
    // 销毁链表
}

链表的遍历

void display(plist l)
{
    //定义一个指针p，初始值为l的下一个节点
    plist p=l->next;
    //当p不为空时，循环执行以下操作
    while(p)
    {
        //输出p的值
        cout<<p->n<<" ";
        //将p指向下一个节点
        p=p->next;
    }
    //换行
    cout<<endl;
}

链表的实现

我用项目的方法进行实现。项目的建立可以参考我的博客。

.h文件

#include<iostream>
using namespace std;
typedef int elemtype;
typedef struct m{
    elemtype n;
    struct m *next;
}list,*plist;
void menu();//菜单
void createlist_h(plist &l,int n);//前插n个元素
void createlist_r(plist &l,int n);//后插n个元素
bool initlist(plist &l);//初始化带头结点的链表
bool getelem(plist l,int i,elemtype &e);//取出第i个结点的数据赋值给e
plist locatelem(plist l,elemtype e);//查找值为e的结点
bool listinsert(plist &l,int i,elemtype e);//在第i个结点前插入元素e
bool listdelete(plist &l,int i);//删除第i个元素
void display(plist l);//显示链表
void ddlist(plist &l);//删除链表中的重复元素
void sortlist(plist &l,int i);//链表排序
plist mergelist(plist l,plist i);//合并两个升序的链表
void imagelist(plist &l);//反转链表
void breaklist(plist &l);//销毁链表

.cpp文件

#include"own.h"
void menu()//菜单
{
    cout<<"1.取值       2.查找  3.插入    4.删除"<<endl;
    cout<<"5.显示元素   6.删除重复元素     7.排序"<<endl;
    cout<<"8.合并两个升序的链表     9.反转链表  -1.退出"<<endl;
    cout<<"请输入："<<endl;
}
void createlist_h(plist &l,int n)//前插n个元素
{
    //定义一个带头结点的链表
    l=new list;
    //将头指针的下一个节点指向空
    l->next=NULL;
    //定义一个指针t，初始值为空
    plist t;
    //定义一个变量i，初始值为0
    int i;
    //当i小于n时，循环执行以下操作
    for(i=0;i<n;i++)
    {
        //定义一个新节点
        t=new list;
        //输入新节点的值
        cin>>t->n;
        //将新节点的指针指向头指针的下一个节点
        t->next=l->next;
        //将头指针的下一个节点指向新节点
        l->next=t;
    }
}
void createlist_r(plist &l,int n)//后插n个元素
{
    //定义一个带头结点的链表
    l=new list;
    //将头指针的下一个节点指向空
    l->next=NULL;
    //定义一个指针t，初始值为l
    plist t,r=l;
    //定义一个变量i，初始值为0
    int i;
    //当i小于n时，循环执行以下操作
    for(i=0;i<n;i++)
    {
        //定义一个新节点
        t=new list;
        //输入新节点的值
        cin>>t->n;
        //将新节点的指针指向r的下一个节点
        t->next=r->next;
        //将r的下一个节点指向新节点
        r->next=t;
        t->next=NULL;
        r=t;
    }
}
bool initlist(plist &l)//初始化带头结点的链表
{
    //定义一个带头结点的链表
    l=new list;
    //将头指针的下一个节点指向空
    l->next=NULL;
    //返回1
    return 1;
}
bool getelem(plist l,int i,elemtype &e)//取出第i个结点的数据赋值给e
{
    //定义变量j，初始值为1
    int j=1;
    //定义变量p，初始值为l的下一个节点
    plist p=l->next;
    //当j小于i，且p不为空时，循环执行以下操作
    while(j<i&&p)
    {    
        //将p指向下一个节点
        p=p->next;
        //将j加1
        j++;
    }
    //当p为空，或者j大于i时，返回0
    if(!p||j>i)return 0;
    //将p的值赋给e
    e=p->n;
    //返回1
    return 1;
}
plist locatelem(plist l,elemtype e)//查找值为e的结点
{
    //定义一个指针p，初始值为l的下一个节点
    plist p=l->next;
    //当p不为空，且p的下一个节点为空时，循环执行以下操作
    while(p&&!p->next)
        p=p->next;
    //返回p
    return p;
}
bool listinsert(plist &l,int i,elemtype e)//在第i个结点前插入元素e
{
    //定义一个指针p，初始值为l
    plist p=l,t=new list;
    //定义一个变量j，初始值为0
    int j=0;
    //当p不为空，且j小于i-1时，循环执行以下操作
    while(p&&j<i-1)
    {
        //将p指向下一个节点
        p=p->next;
        //将j加1
        j++;
    }
    if(!p&&j>i-1)return 0;
    //当p为空，或者j大于i-1时，返回0
    if(!p||j>i-1)return 0;
    //将e赋给t
    t->n=e;
    //将t的指针指向p的下一个节点
    t->next=p->next;
    //将p的指针指向t
    p->next=t;
    //返回1
    return 1;
}
bool listdelete(plist &l,int i)//删除第i个元素
{
    //定义一个指针p，初始值为l
    plist p=l,t;
    //定义一个变量j，初始值为0
    int j=0;
    //当p的下一个节点不为空，且j小于i-1时，循环执行以下操作
    while(p->next&&j<i-1)
    {
        //将p指向下一个节点
        p=p->next;
        //将j加1
        j++;
    }
    //当p的下一个节点为空，或者j大于i-1时，返回0
    if(!p->next||j>i-1)return 0;
    //将p的指针指向下一个节点
    t=p->next;
    //将t的指针指向空
    p->next=t->next;
    //删除t
    delete t;
    //返回1
    return 1;
}
void display(plist l)
{
    cout<<"该链表为：";
    //定义一个指针p，初始值为l的下一个节点
    plist p=l->next;
    //当p不为空时，循环执行以下操作
    while(p)
    {
        //输出p的值
        cout<<p->n<<" ";
        //将p指向下一个节点
        p=p->next;
    }
    //换行
    cout<<endl;
}
void ddlist(plist &l)//删除链表中的重复元素
{
    //p指向当前节点，t指向下一个节点
    plist p=l->next,t,t1,m;
    while(p)
    {
        //t指向下一个节点
        t=p->next;
        //t1指向当前节点
        t1=p;
        //m指向当前节点
        while(t)
        {
            //如果当前节点和下一个节点值相同
            if(p->n==t->n)
            {
                //m指向下一个节点
                m=t;
                //t指向下一个节点
                t=t->next;
                //将当前节点指向下一个节点
                t1->next=t;
                //删除m指向的节点
                delete m;
            }
            else {
                //t1指向下一个节点
                t1=t;
                //t指向下一个节点
                t=t->next;
            }
        }
        //p指向下一个节点
        p=p->next;
    }
}
void sortlist(plist &l,int i)//链表排序
{
    //定义一个指针p指向当前节点，初始值为l的下一个节点
    plist p=l->next,t;
    elemtype m;
    if(i==0)//升序
    while(p)
    {
        //定义一个指针t指向当前节点的下一个节点
        t=p->next;
        //当t不为空时，循环比较p和t的n值
        while(t)
        {
            //如果p的n值大于t的n值，交换p和t的n值
            if(p->n>t->n)
            {
                m=p->n;
                p->n=t->n;
                t->n=m;
            }
            else t=t->next;
            //t指向t的下一个节点
        }
        //p指向p的下一个节点
        p=p->next;
    }
    else if(i==1)//降序
    while(p)
    {
        //定义一个指针t指向当前节点的下一个节点
        t=p->next;
        //当t不为空时，循环比较p和t的n值
        while(t)
        {
            //如果p的n值小于t的n值，交换p和t的n值
            if(p->n<t->n)
            {
                m=p->n;
                p->n=t->n;
                t->n=m;
            }
            else t=t->next;
            //t指向t的下一个节点
        }
        //p指向p的下一个节点
        p=p->next;
    }
    //显示链表
    display(l);
}
plist mergelist(plist l,plist i)//合并两个升序的链表
{
    // l: 第一个链表，i: 第二个链表
    plist p=l->next,t=i->next,l1,l2;
    // p: 第一个链表的指针，t: 第二个链表的指针，l1: 合并后的链表，l2: 合并后的链表的指针
    initlist(l1);
    // 初始化合并后的链表
    l2=l1;
    // l2: 合并后的链表的指针
    while(p&&t)
    {
        // 当两个链表都不为空时
        if(p->n<=t->n)
        {
            // 如果第一个链表的指针的值小于等于第二个链表的指针的值
            l2->next=p;
            // 将第一个链表的指针的值赋值给l2的指针的下一个值
            p=p->next;
            // 将第一个链表的指针的值指向下一个值
            l2=l2->next;
            // 将l2的指针的值指向下一个值
            l2->next=NULL;
            // 将l2的指针的值指向空
        }
        else 
        {
            // 如果第一个链表的指针的值大于第二个链表的指针的值
            l2->next=t;
            // 将第二个链表的指针的值赋值给l2的指针的下一个值
            t=t->next;
            // 将第二个链表的指针的值指向下一个值
            l2=l2->next;
            // 将l2的指针的值指向下一个值
            l2->next=NULL;
            // 将l2的指针的值指向空
        }
    }
    if(!p)l2->next=t;
    // 如果第一个链表的指针为空，将第二个链表的指针的值赋值给l2的指针的下一个值
    else l2->next=p;
    // 将第一个链表的指针的值赋值给l2的指针的下一个值
    return l1;
    // 返回合并后的链表
}
void imagelist(plist &l)//反转链表
{
    plist p,t,t1,q=l->next;
    while(q->next)q=q->next;//q指向最后一个结点，作为反转后的首元结点
    while(1)
    {
        p=t=l->next;
        while(t->next)//t指向当前链表的最后一个结点
        {
            t1=t;
            t=t->next;
        }
        t->next=t1;//t之前倒数第二个结点
        t1->next=NULL;//将t剔除
        t=t->next;//t指向新链表的最后一个结点
        if(t==p)break;
    }
    l->next=q;//l的头结点指向q
}
void breaklist(plist &l)//销毁链表
{
    // l: 链表
    plist p=l->next,t;
    // p: 链表的指针，t: 链表的指针
    while(p)
    {
        t=p;
        p=p->next;
        delete t;
        // 删除链表的指针的值指向的值
    }
    delete l;
    // 销毁链表
}

main.cpp文件

#include"own.h"
int main()
{
    //定义变量
    int n,a;
    plist h,h1;
    //循环输入
    while(1)
    {
        cout<<"1.前插   2.后插"<<endl;
        cout<<"请输入:";
        cin>>a;
        cout<<"请输入元素个数：";
        cin>>n;
        cout<<"请输入元素：";
        //根据输入的选项，调用不同的函数
        if(a==1){
            createlist_h(h,n);
            break;
        }
        else if(a==2){
            createlist_r(h,n);
            break;
        }
    }
    //循环输出
    while(1)
    {
        menu();
        cin>>a;
        //根据输入的选项，调用不同的函数
        if(a==1)
        {
            elemtype t;
            int m;
            cout<<"输入取出的元素位置：";
            cin>>m;
            //调用函数，获取元素
            if(getelem(h,m,t))
                cout<<"该元素为："<<t<<endl;
            else cout<<"ERROR"<<endl;
        }
        else if(a==2)
        {
            plist t;
            elemtype m;
            cout<<"输入要查找元素：";
            cin>>m;
            //调用函数，查找元素
            t=locatelem(h,m);
            if(t==NULL)cout<<"ERROR"<<endl;
            else cout<<"成功"<<endl;
        }
        else if(a==3)
        {
            int m;
            elemtype t;
            cout<<"输入插入的位置和数据";
            cin>>m>>t;
            //调用函数，插入元素
            if(listinsert(h,m,t))
                cout<<"插入成功"<<endl;
            else cout<<"ERROR"<<endl;
        }
        else if(a==4)
        {
            int m;
            cout<<"请输入删除的元素位置：";
            cin>>m;
            //调用函数，删除元素
            if(listdelete(h,m))
                cout<<"删除成功"<<endl;
            else cout<<"ERROR"<<endl;
        }
        //调用函数，显示链表
        if(a==5)display(h);
        if(a==6)
        {
            ddlist(h);
            display(h);
        }
        if(a==7)
        {
            int i;
            cout<<"0.升序   1.降序"<<endl;
            cin>>i;
            sortlist(h,i);
        }
        if(a==8)
        {
            plist t;
            initlist(h1);
            cout<<"h1尾插五个：";
            createlist_r(h1,5);
            h=mergelist(h,h1);
            display(h);
        }
        if(a==9)
        {
            imagelist(h);
            display(h);
        }
        else if(a==-1)break;
    }
    if(h)breaklist(h);
    if(h1)breaklist(h1);
}

运行试例

4d1f3dcf4dec40b7afe91430c4542aef.png

93a941ba04a74ffbb0dba4119733dc4a.png

欢迎指正

感谢阅读本文，如果您有任何问题或建议，请随时与我联系。祝愿您编程愉快，继续前进！

晓零清
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
数据结构 合并有序链表 单链表 初学
02-17
合并有序链表 嵌入式技术公开课数据结构笔记
[数据结构]链表之单链表（详解）
m0_63123468的博客
03-28 1万+
[数据结构]链表之单链表的详细解析
数据结构之单链表
chuxinchangcun的博客
08-15 1688
前言： 之前的文章，我们了解了顺序表，包括静态顺序表和动态顺序表。具体可以看我的上两篇文章 1.静态顺序表知识及代码实现：静态顺序表 2.动态顺序表知识及代码实现：动态顺序表 既然顺序表已经能存储数据，那么我们什么又要引入链表呢？ 首先，我们要知道顺序表的优缺点： 优点：空间连续，支持随机访问 缺点： 1.中间或前面部分的插入删除的时间复杂度为O(N) 2.增容的代价比较大 为了解决上述问题，我们引入了链表的概念。 目录 一:什么是链表 二:链表的种类 三:...
数据结构-单链表
qq_54227351的博客
11-08 1258
链表是数据结构中线性表的一种，其中的每个元素实际上是一个单独的结构体对象，而所有对象都通过每个元素中的指针链接在一起。它是以结构体为节点，将一个结构体看成数据域和指针域两个部分，数据域用于存储数据，指针域用于连接下一个节点。链表中每个结构体对象叫做节点，其中第一个数据节点叫做链表的首元节点；如果第一个节点不用于存储数据，只用于代表链表的起始点，则这个节点称为链表的头节点。
数据结构-单链表存储
有朋自远方来，不亦乐乎。
07-27 2151
包括数据域和指针域charelem;//数据域//指针域，用来连接后继元素}link;//link为节点名，每个结点都是一个link结构体。
数据结构之链表——单链表的逆置
weixin_64495476的博客
07-06 582
【代码】数据结构之链表——单链表的逆置。
【数据结构】单链表和双向循环链表
qq_63474430的博客
11-03 1102
单链表的概念及结构，单链表的分类，单链表的实现（尾插，尾删，头插，头删）， 双向循环链表的一些基本操作
【数据结构】单链表
Zxingyun12的博客
11-03 1756
数据结构与算法基础（青岛大学-王卓）笔记
数据结构之单链表实验
// 在校菜鸟大学生的日常学习博客
09-01 5681
单链表实验实验目的实验环境实验要求实验内容源代码运行结果 实验目的 掌握线性表的定义、特点、逻辑结构，理解线性表的抽象数据类型。 熟练掌握线性表的两种存储结构的结构类型定义、特点和基本操作的实现。 通过本次实验帮助学生加深对线性表的理解，并加以应用； 实验环境 CodeBlocks 实验要求 1.熟悉c语言的语法知识； 2.了解线性表的逻辑结构特性； 3.掌握线性表的链式存储结构—单链表的定义、创建、插入、删除、取值等基本操作； 实验内容 完成单链表的基本操作（定义、初始化、插入、删除、定位等）的汇总，
数据结构——单链表代码总结
Acc222222的博客
08-02 2562
1.单链表结点的定义
C语言链表超详解
热门推荐
k666499436的博客
05-17 10万+
详细对比顺序表与链表的区别， 实现单链表，与双向带头循环链表，以及各中类型的链表
使用C++实现链表数据结构之单链表.zip
03-13
链表 使用C++实现链表数据结构之单链表
数据结构链表：单链表的代码实现
03-20
本文通过数据结构教程的方法利用C++语言写了单链表的各项功能 功能包括 1.链表的初始化 2.链表的查找和判断是否为空表 3.插入 4.取值 5.插入（尾插法） 6.链表的输出 7.//删除指定元素 8.//链表的释放 其中有着详细...
浅谈PHP链表数据结构(单链表)
12-18
链表：是一个有序的列表，但是它在内存中是分散存储的，使用链表可以解决类似约瑟夫问题，排序问题，搜索问题，广义表 单向链表，双向链表，环形链表 PHP的底层是C，当一个程序运行时，内存分成五个区（堆区，栈区，...
数据结构的单链表算法
09-27
数据结构单链表：单链表的运算，循环单链表基本运算，约瑟夫环，集合运算，多项式相加，分为插入前插入后。
数据结构 | 详解栈实现队列&队列实现栈
最新发布
mooridy的博客
05-17 327
step2：此时非空队列中剩下的唯一一个数就是“栈顶”元素，使用QueueFront进行·取值后，直接进行QueuePop删除。step0.先利用假设法假定非空队列notempty和空队列empty，再利用MyStackEmpty函数对进行修正。step1:将notempty队列中的前size-1个元素依次push到empty队列中，再进行删除，实现移动操作。
USB3.0接口——（2）数据结构
dkmknjk的博客
05-14 1064
在 USB 3.0 及更高版本的 xHCI 协议中，"Rings"、"Transfer Request Block (TRB)" 和 "Transfer Descriptor (TD)" 是用于管理 USB 数据传输和事件的重要概念。
「探索数据结构：了解顺序表」
2301_80321602的博客
05-17 528
顺序表是一种线性表的存储结构，它是由一组物理地址连续的存储单元（通常是数组）依次存储线性表中的元素。顺序表中的元素在内存中是连续存储的，通过元素在数组中的下标来访问和操作元素。顺序表的优点是访问元素的时间复杂度为O(1)，即可以通过下标直接访问元素，操作效率高；缺点是插入和删除元素时需要移动其他元素，时间复杂度为O(n)，效率较低。首先，我们需要定义动态顺序表的数据类型SLDataType和结构体SeqList。动态顺序表使用数组arr存储数据，size表示当前有效数据个数，capacity。
“ 树 ” 的概念
2401_82669797的博客
05-14 688
通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址。树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。：若一个结点含有子结点，则这个结点称为其子结点的父结点；：以某结点为根的子树中任一结点都称为该结点的子孙。：一个结点含有的子树的根结点称为该结点的子结点；具有相同父结点的结点互称为兄弟结点；：一个结点含有的子树的个数称为该结点的度；：从根开始定义起，根为第1层，根的子结点为第2层，以此类推；
 数据结构循环单链表
10-07
循环单链表是一种链表的变体，它与单向链表的区别在于尾节点的指针不是指向 null，而是指向链表的头节点。这样就形成了一个循环，最后一个节点指向第一个节点。 循环单链表的主要优点是可以方便地遍历整个链表。遍...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

晓零清

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

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

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

打赏作者

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

抵扣说明：

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

余额充值