精华内容
下载资源
问答
  • 【实验课程名称】算法与数据结构 【实验项目名称】链表基本操作的实现
  • 链表基本操作

    2011-12-08 12:25:13
    链表基本操作,是关于代码的使用,链表的基本操作,设计等操作
  • 链表基本操作源码

    2017-12-28 19:12:20
    c 语言 链表基本操作,创建 查找 删除 插入 双向链表源码
  • 静态链表基本操作

    2014-08-06 11:49:14
    静态链表基本操作,用codeblocks运行通过,包含初始化,插入,删除等。
  • 代码如下:#include ...int main(){ /*—————————–程序描述——————————————– 题目:写出一个主函数,分别调用建立链表的函数create(),输出链表的函数print(), 删除链表结点的函数del(),
  • 链表基本操作.cpp

    2020-07-02 23:40:20
    以下内容是我最近归纳总结的一些链表基本操作,内容很基础,适合数据结构初学者 包括:建立空表 按序号查找 按值查找 插入结点 删除节点 参考资料:浙江大学数据结构mooc
  • 链表基本操作实验报告.doc
  • 用C语言实现双向列表的创建,删除,添加节点,删除节点,插入节点,遍历节点,打印节点,并结合插入排序法实现了基于双向链表的升序排序。
  • C语言链表基本操作[文].pdf
  • 单向链表基本操作python实现

    万次阅读 2018-08-11 20:58:44
    一:基本介绍 单向链表也叫单链表,是链表中最简单的一种形式,它的每个节点包含两个域,一个信息域(元素域)和一个链接域。这个链接指向链表中的下一个节点,而最后一个节点的链接域则指向一个空值。 - 表...

    一:基本介绍
    单向链表也叫单链表,是链表中最简单的一种形式,它的每个节点包含两个域,一个信息域(元素域)和一个链接域。这个链接指向链表中的下一个节点,而最后一个节点的链接域则指向一个空值。
    这里写图片描述
    - 表元素域elem用来存放具体的数据。
    - 链接域next用来存放下一个节点的位置(python中的标识)
    - 变量p指向链表的头节点(首节点)的位置,从p出发能找到表中的任意节点。

    二:单链表的基本操作

    • is_empty() 链表是否为空
    • length() 链表长度
    • travel() 遍历整个链表
    • add(item) 链表头部添加元素
    • append(item) 链表尾部添加元素
    • insert(pos, item) 指定位置添加元素
    • remove(item) 删除节点
    • search(item) 查找节点是否存在

    三:代码实现

    1):节点实现

    class SingleNode(object):
        """单链表的结点"""
        def __init__(self,item):
            # item存放数据元素
            self.item = item
            # next是下一个节点的标识
            self.next = None

    2):单链表的实现

    class SingleLinkList(object):
    
        def __init__(self):
            self.__head = None
    
        def is_empty(self):
            '''判断链表是否为空'''
            return self.__head == None
    
        def length(self):
            '''链表长度'''
            # cur初始时指向头节点
            cur = self.__head
            count = 0
            # 当到达尾部时,尾节点指向None
            while cur != None:
                count += 1
                # 把cur后移一个节点
                cur = cur.next
            # 返回数量
            return count
    
        def travel(self):
            '''遍历链表'''
            cur = self.__head
            # 只要未到达末尾,也就是cur未指向None
            while cur != None:
                print(cur.item)
                # cur指向下一个节点
                cur = cur.next
    
            print("")

    3):头部添加元素
    这里写图片描述

        def add(self, item):
            '''头部添加元素'''
            # 首先创建保存item值的节点
            node = SingleNode(item)
            # 将新节点的链接域next指向头节点,即__head指向的位置
            node.next = self.__head
            # 将链表的头__head指向新节点
            self.__head = node

    4):尾部添加元素

        def append(self, item):
            '''尾部添加元素'''
            # 创建要添加的元素node
            node = SingleNode(item)
            # 首先判断链表是否为空,如果是空,则将__head指向新节点
            if self.is_empty():
                self.__head = node
    
            # 如果不为空,则将尾节点的next指向新节点
            else:
                cur = self.__head
                while cur.next != None:
                    cur = cur.next
                cur.next = node
    

    5):指定位置添加元素
    这里写图片描述

        def insert(self, pos, item):
            '''指定位置添加元素'''
    
            # 如果指定位置pos为第一个元素之前,则执行头部插入
            if pos <= 0:
                self.add(item)
    
            # 如果指定位置pos为最后一个元素之后,则执行尾部插入
            elif pos > (self.length() - 1):
                self.append(item)
    
            else:
                # 指定位置插入
                # 创建新元素
                node = SingleNode(item)
    
                count = 0
                # pre用来指向指定位置pos的前一个位置pos-1,初始从头节点移动到该位置
                pre = self.__head
                while count < (pos - 1):
                    count += 1
                    pre = pre.next
    
                # 先将新节点node的next指向插入位置的节点
                node.next = pre.next
                # 将插入位置的前一个节点的next指向新节点
                pre.next = node
    

    6):删除节点
    这里写图片描述

        def remove(self, item):
            '''删除节点'''
    
            cur = self.__head
            pre = None
            while cur != None:
                # 找到了要删除的元素
    
                if cur.item == item:
                    # 如果第一个元素就是要删除的节点
                    if not pre:
                        # 将头指针指向头节点的后一个节点
                        self.__head = cur.next
                    else:
                        # 将删除位置前一个节点的next指向删除位置的后一个节点
                        pre.next = cur.next
                    break
                else:
                    # 未找到要删除的元素.继续向后移动节点
                    pre = cur
                    cur = cur.next

    7):查找节点是否存在

        def search(self, item):
            '''查找节点是否存在,返回True或False'''
            cur = self.__head
            while cur != None:
                if cur.item == item:
                    return True
                cur = cur.next
    
            return False

    链表与顺序表的对比:
    链表失去了顺序表随机读取的优点,同时链表由于增加了结点的指针域,空间开销比较大,但对存储空间的使用要相对灵活。

    链表与顺序表的各种操作复杂度如下所示:
    这里写图片描述
    注:注意虽然表面看起来复杂度都是 O(n),但是链表和顺序表在插入和删除时进行的是完全不同的操作。链表的主要耗时操作是遍历查找,删除和插入操作本身的复杂度是O(1)。顺序表查找很快,主要耗时的操作是拷贝覆盖。因为除了目标元素在尾部的特殊情况,顺序表进行插入和删除时需要对操作点之后的所有元素进行前后移位操作,只能通过拷贝和覆盖的方法进行。

    展开全文
  • 链表基本操作及其过程详细叙述

    千次阅读 2017-09-15 22:38:12
    链表概述:链表是一种常见的数据结构。数组可以存放数据,但是使用数组时要先指定数组中包含元素的个数,即数组长度。但是如果向这个数组中加入的元素个数超过了数组的大小时,便不能将内容完全保存。例如在定义一个...

    链表概述:链表是一种常见的数据结构。数组可以存放数据,但是使用数组时要先指定数组中包含元素的个数,即数组长度。但是如果向这个数组中加入的元素个数超过了数组的大小时,便不能将内容完全保存。例如在定义一个班级的人数时,如果小班是30人,普通班是50人,且定义班级人数时使用数组,那么要定义数组的个数为最大,也就是最少为50个元素,否则不满足最大时的情况。这种方式非常浪费空间。而链表,其存储元素的个数不受限定的,当进行添加元素的时候存储的个数就会随之改变。
    如图1所示为链表结构的示意图
    这里写图片描述

    在链表中有一个头指针变量,图中head表示的就是头指针,这个指针变量保存一个地址。从图中的箭头可以看到该地址为一个变量的地址,也就是说头指针指向一个变量。这个变量称为元素,在链表中每一个元素包括两个部分:数据部分和指针部分。数据部分用来存放元素所包含的数据,而指针部分用来指向下一个元素。最后一个元素指针指向NULL,表示指向的地址为空。从图1可以看到,head头结点指向第一个元素,第一个元素中的指针又指向第二个元素,第二个元素的指针又指向第三个元素的地址,第三个元素的指针就指向为空。
    根据对链表的描述,可以想象到链表就像一个铁链,一环扣一环。然后通过头指针寻找链表中的元素,这就好比在一个幼儿园中,老师拉着第一个小朋友的手,第一个小朋友又拉着第二个小朋友的手,这样下去在幼儿园中的小朋友就连成了一条线。最后一个小朋友没有拉着任何人,他的手是空着的,他就好像是链表中链尾,而老师就是头指针,通过老师就可以找到这个队伍中的任何一个小朋友。
    注意:在链表这种结构中,必须利用指针才能实现。因此链表中的结点应该包含一个指针变量来保存下一个结点的地址。

    三个函数
    void *malloc(unsigned int size);
    该函数的功能是在内存中动态地分配一块size大小的内存空间。malloc函数会返回一个指针,该指针指向分配的内存空间,如果出现错误则返回NULL。

    void *calloc(unsigned int n,unsigned int size);
    该函数的功能是在内存中动态分配n个长度为size的连续内存空间数组。calloc函数会返回一个指针,该指针指向动态分配的连续内存空间地址。当分配空间错误时,返回NULL。

    void free(void *ptr);
    该函数的功能是使用由指针ptr指向的内存区,使部分内存区能被其他变量使用(简单来说就是释放不需要的内存空间)。ptr是最近一次调用calloc或malloc函数时返回的值,free函数无返回值。
    这里写图片描述

    链表的插入操作:链表的插入操作可以在链表的头指针位置进行(图3),也可以在某个结点的位置进行,或者可以像创建结构时在链表的后面添加结点(图2)。这三种插入操作的思想都是一样的。
    ![这里写图片描述](https://img-blog.csdn.net/20170915223224227?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQveWFuemk5MDE2/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast) 
    
    链表头插入结点的过程就比如手拉手的小朋友连成一条线,这时又来了一个小朋友他要站在老师和一个小朋友的中间,那么老师就要放开原来的小朋友,拉住新加入的小朋友。这个新加入的小朋友就拉住原来的那个小朋友。这样,这条连成的线还是连在一起。
    

    链表的删除操作:当希望删除链表中的结点时,应该怎么办?还是通过前文中小朋友手拉手的比喻进行理解。例如队伍中的一个小朋友离开队伍了,并且这个队伍不会断开的方法只需他两边的小朋友将手拉起来就可以了。
    例如在一个链表中删除其中的一点:
    这里写图片描述

    实例:

    #include <stdio.h>  
    #include <stdlib.h>  
    
    struct student          //学生结构体  
    {  
        char name[20];      //姓名  
        int number;     //学号      
        struct student * next;  //指向下一个结点的指针  
    };  
    
    int count;          //全局变量表示链表长度  
    
    /* 
        create函数的功能是创建链表,在create的外部可以看到一个整型的全局变量count,这个变量 
    的作用是表示链表中结点的数量。在create函数中,首先定义需要用到的指针变量,head用来表示头 
    指针,end用来指向原来的尾结点,new指向新创建的结点。 
        使用malloc函数分配内存,先用end和new两个指针都指向第一个分配的内存。然后显示提示信息, 
    先输入一个学生的姓名,再输入学生的学号。使用while进行判断,如果学号为0,则不执行循环语句。 
        在while循环中,count++自加操作表示链表中结点的增加。然后要判断新加入的结点是否是第一次 
    加入的结点,如果是第一次加入结点则执行if语句块中的代码,否则执行else语句块中的代码。 
        在if语句块中,因为第一次加入结点时其中没有结点,所以新结点即为首结点也为最后一个结点, 
    并且要将新加入的结点的指针指向NULL,即为head指向。else语句实现的是链表中已经有结点存在时的 
    操作。首先将新结点new的指针指向NULL,然后将原来最后一个结点的指针指向新结点,最后将end指针 
    指向最后一个结点。 
        这样一个结点创建完之后,要再进行分配内存,然后向其中输入数据,通过while语句再次判断输入 
    的数据是否符合结点的要求。当结点不符合要求时,执行下面的代码,调用free函数将不符合要求的结点 
    空间进行释放。 
    */  
    struct student * create()  
    {  
        struct student * head = NULL;   //初始化链表头指针为空  
        struct student * end,* new;  
        count = 0;          //初始化链表长度  
        end = new = (struct student *)malloc(sizeof(struct student));  
        printf("please first enter name,then nember\n");  
        scanf("%s",new->name);  
        scanf("%d",&new->number);  
        while(0 != new->number)  
        {  
            count++;  
            if(1 == count)  
            {  
                new->next = head;    //使得指向为空  
                end = new;      //跟踪新加入的结点  
                head = new;     //头指针指向首结点  
            }  
            else  
            {  
                new->next = NULL;    //新结点的指针为空  
                end->next = new; //原来的尾结点指向新结点  
                end = new;      //end指向新结点  
            }  
            new = (struct student *)malloc(sizeof(struct student));//再次分配结点内存空间  
            scanf("%s",new->name);  
            scanf("%d",&new->number);  
        }  
        free(new);  //释放没用到的空间  
        return head;  
    }  
    
    
    /* 
        print函数是用来将链表中的数据进行输出。在函数的参数中,head表示一个链表的头结点。 
    在函数中,定义一个临时的指针temp用来进行循环操作。定义一个整型变量表示链表中的结点序号。 
    然后将临时指针temp指针变量保存首结点的地址。 
        使用while语句将所有的结点中保存的数据都显示输出。其中每输出一个结点的内容后,就移动 
        temp指针变量指向下一个结点的地址。当最后一个结点时,所拥有的指针指向NULL,此时循环结束。 
    */  
    void print(struct student * head)  
    {  
        struct student *temp;   //循环所用的临时指针  
        int index = 1;      //表示链表中结点的序号  
    
        printf("---the list has %d members:---\n\n",count);  
        temp = head;    //指针得到首结点的地址  
    
        while(NULL != temp)  
        {  
            printf("the NO%d member is:\n",index);          //输出结点序号  
            printf("the name is:%s\n",temp->name);       //输出姓名  
            printf("the number is:%d\n\n",temp->number);    //输出学号  
            temp = temp->next;   //移动临时指针到下一个结点  
            index++;              
        }  
    }  
    
    /* 
        insert函数为链表头插入操作函数,在代码中,为要插入的新结点分配内存,然后向新结点中输入数据。这样 
    一个结点就创建完成了,接下来就是将这个结果插入到链表中。首先将新结点的指针指向原来的首结点,保存首结 
    点的地址。然后将头指针指向新结点,这样就完成了结点的连接操作,最后增加链表的结点数量。 
    */  
    struct student * insert(struct student * head)  
    {  
        struct student * new;   //指向新分配的空间  
        printf("---insert member at first---\n");  
        new = (struct student *)malloc(sizeof(struct student));//分配内存空间,并返回指向该内存空间的指针  
    
        scanf("%s",new->name);  
        scanf("%d",&new->number);  
    
        new->next = head;    //新结点指针指向原来的首结点  
        head = new;     //头指针指向新结点  
        count++;        //增加链表结点数量  
        return head;  
    }  
    
    /* 
        为delete函数传递两个参数,head表示链表的头指针,index表示要删除结点在链表中的位置。 
    定义整型变量i用来控制循环的次数,然后定义两个指针,分别用来表示要删除的结点和这个结点 
    之前的结点。 
        输出一行提示信息表示要进行删除操作,之后利用for语句进行循环操作找到要删除的结点, 
    使用temp保存要删除结点的地址,pre保存前一个结点的地址。找到要删除的结点后,连接删除结点 
    两边的结点,并使用free函数将temp指向的内存空间进行释放。 
    */  
    void delete(struct student * head,int index)//head表示头结点,index表示要删除的结点下标  
    {  
        int i;          //控制循环变量  
        struct student * temp;  //临时指针  
        struct student * pre;   //表示要删除结点前的结点  
        temp = head;        //得到头结点  
        pre = temp;  
    
        printf("---delete NO%d member---\n\n\n",index);  
        for(i=1;i<index;i++) //for循环使得temp指向要删除的结点  
        {  
            pre = temp;  
            temp = temp->next;  
        }  
        pre->next = temp->next;   //连接删除结点两边的结点  
        free(temp);     //释放掉要删除结点的内存空间  
        count--;        //减少链表中的元素个数  
    }  
    
    /* 
        在main函数中,先定义一个头结点指针head,然后调用create函数创建链表,并将链表的头结点 
    返回给head指针变量。利用得到的头结点head作为print函数的参数。 
        在main函数中分别添加代码执行插入和删除操作。 
    */  
    int main()  
    {  
        struct student * head;  //定义头结点  
        head = create();    //创建结点  
        print(head);        //输出链表  
        head = insert(head);    //插入结点  
        print(head);        //输出链表  
        delete(head,2);     //删除第二个结点  
        print(head);        //输出链表  
    
        return 0;  
    }  
    

    转:http://blog.csdn.net/dezhihuang/article/details/39118293

    展开全文
  • 链表基本操作(doc)

    2011-08-22 17:13:30
    一个用C语言编写的链表基本操作word文档
  • #include <stdlib.h>#define null 0 #define MAXSIZE 50struct strlnode { int data; struct strlnode *plast; struct strlnode *pnext;...void create(struct strlnode **p, int x) /*创建双链表(表头节点)*/ {
    #include <stdlib.h>
    
    #define null 0
    #define MAXSIZE 50
    
    struct strlnode {
        int data;
        struct strlnode *plast;
        struct strlnode *pnext;
    };
    
    void create(struct strlnode **p, int x)  /*创建双链表(表头节点)*/
    {
        struct strlnode *q;
    
        q = (struct strlnode *)malloc(sizeof(struct strlnode));
        q->data = x;
        q->plast = null;
        q->pnext = null;
    
        *p = q;
    
        return;
    }
    
    void insertnode(struct strlnode **p, int i, int x) /* 在链表第i个位置插入数据等于x的节点 */
    {
        /* 代码在这里实现 */
        if(!*p||!p)
            return;
    
        struct strlnode *ptemp=*p,*psave=*p;
        struct strlnode *t = NULL;
        int pnodeLen=0;
    
        while(ptemp->pnext!=NULL) {
            pnodeLen++;
            ptemp=ptemp->pnext;
        }
        if(i<0||i>pnodeLen+1)
            return;
    
        /*申请该节点的地址*/
        struct strlnode *q=(strlnode *)malloc(sizeof(strlnode));
    
        q->data=x;
        /*插入为第一个位置时候*/
        if(i==0) {
            q->pnext=psave;
            q->plast=NULL;
            psave->plast=q;
            *p=q;
    
            return;
        /*最后位置*/    
        } else if(i==pnodeLen+1) {
            q->pnext = NULL;
            q->plast = ptemp;
            ptemp->pnext = q;
    
            return;
        /*中间位置*/
        } else {
            int pnodeCur=0;
    
            while(pnodeCur!=i) {
                pnodeCur++;
                t = psave;
                psave = psave->pnext;
            }
            q->pnext=t->pnext;
            psave->plast=q;
            q->plast=t;
            t->pnext=q;
    
            return;
        }
    
    
    }
    
    void deletenode(struct strlnode **p, int i) /* 删除链表中第i个节点 */
    {
        /* 代码在这里实现 */   
        if(!*p||!p)
            return;
        if(i<0)
            return;
    
        struct strlnode *ptemp=*p,*psave=*p;
        struct strlnode *t = NULL;
        int pnodeLen=0;
    
        while(ptemp->pnext!=NULL) {
            pnodeLen++;
            ptemp=ptemp->pnext;
        }
        if(i<0||i>pnodeLen)
            return;
    
        /*删除为第一个位置时候*/
        if(i==0) {
            if(pnodeLen==0) 
                *p = NULL;
            t = psave->pnext;
            t->plast = NULL;
            free(psave);
            psave = NULL;
            *p = t; /*注意这里,记得返回*/
    
            return;
    
        /*其它位置*/
        } else {
            int pnodeCur=0;
    
            while(pnodeCur!=i) {
                pnodeCur++;
                t = psave;
                psave = psave->pnext;
            }
            t->pnext = psave->pnext;
            (psave->pnext)->plast = t;
            free(psave);
    
            return;
        }
    }
    
    int getnodenum(struct strlnode **p)  /*获取链表中节点个数*/
    {
    
        if(!*p||!p)
            return 0;
    
        struct strlnode *plasttemp = *p;;
        int nodenum = 1;
        /* 代码在这里实现 */
        while(plasttemp->pnext!=NULL) {
            nodenum ++;
            plasttemp = plasttemp->pnext;
        }
    
        return nodenum;
    }
    
    /* 使用链表实现大整数相加 */
    void bignumberplus(struct strlnode **plus, struct strlnode **p, struct strlnode **q)
    {
        int lenp = getnodenum(p);
        int lenq = getnodenum(q);
        /*初始化为0很重要,便于后面的处理*/
        int a[10000] = {0};
        int b[10000] = {0};
        /*看哪个整数更大*/
        int len = lenp > lenq ? lenp : lenq;
        struct strlnode *pl = *p;
        struct strlnode *ql = *q;
        /*将链表数据取出来,分别存入不同数组中*/
        for(int i = lenp - 1; i>= 0; i--) {
            a[i] = pl->data;
            pl = pl ->pnext;
        }
        for(int i = lenq - 1; i>= 0; i--) {
            b[i] = ql->data;
            ql = ql ->pnext;
        }
        for(int i = 0; i < len; i++) {
            a[i] = a[i] + b[i];
            if(a[i]>=10) {
                a[i+1] += a[i] / 10;
                a[i] %= 10;
            }
        }
    
        if(a[len] != 0)//最后进位后会多出来的
            len++;
        /*从高到低依次存储*/
        (*plus)->data = a[len -1];
        int j = 1;
        for(int  i = len - 2; i>= 0 ;i--) {
            int data = a[i];
            insertnode(plus, j, data);
            j++;
        }
    
        return;
    }
    
    /* 将数组写入链表中,链表中的数据的先后顺序和数组中的顺序要保持一致 */
    void readtolnode(struct strlnode **p, int *a, int size) 
    {
        int j = 0;
        int data = 0;
        struct strlnode *s = *p;
    
        s->data = *(a + (size-1));
    
        for(j = 2; j < (size+1); j++) {
            data = *(a + (size-j));
            insertnode(p, 0, data);
        }
    
        return;
    }
    
    /* 将链表写入数组中,数组中的数据的先后顺序和链表中的顺序要保持一致 */
    void writetosqlist(int *a, struct strlnode *p)  
    {
        int j = 0;
        struct strlnode *s = p;
    
        while(s != null) {
            *(a + j) = s->data;
            s = s->pnext;
            j++;
        }
    
        return;
    }
    
    
    
    
    
    
    
    展开全文
  • 前面学习了如何创建一个双向链表,本节学习有关双向链表的一些基本操作,即如何在双向链表中添加、删除、查找或更改数据元素。 本节知识基于已熟练掌握双向链表创建过程的基础上,我们继续上节所创建的双向链表来...

    前面学习了如何创建一个双向链表,本节学习有关双向链表的一些基本操作,即如何在双向链表中添加、删除、查找或更改数据元素。

    本节知识基于已熟练掌握双向链表创建过程的基础上,我们继续上节所创建的双向链表来学习本节内容,创建好的双向链表如 1 所示:

    双向链表示意图

                                                            图 1 双向链表示意图

    双向链表添加节点

    根据数据添加到双向链表中的位置不同,可细分为以下 3 种情况:

    添加至表头

    将新数据元素添加到表头,只需要将该元素与表头元素建立双层逻辑关系即可。

    换句话说,假设新元素节点为 temp,表头节点为 head,则需要做以下 2 步操作即可:

    1. temp->next=head; head->prior=temp;
    2. 将 head 移至 temp,重新指向新的表头;

    例如,将新元素 7 添加至双链表的表头,则实现过程如图 2 所示:

    展开全文
  • C++链表基本操作大全

    2010-03-23 05:45:41
    C++链表基本(创建、插入、删除、释放)
  • 本文将单链表与双向链表基本操作在同一个程序中实现。其中单链表头文件中的函数与双向链表头文件中的函数可以分离出来单独使用。菜单程序的实现的程序较为复杂,变量多且作用范围不同,如果修改代码需要对代码非常...
  • 选择何时的存储方式实现线性表。其中,必须实现的线性表基本操作为:InitList、 ClearList、ListEmpty、ListLength、GetElem、PriorElem、ListInsert、ListDelete这8个基本操作
  • C++链表基本操作 链表的操作基本都有 找个东西不容易
  • c语言链表及其基本操作

    千次阅读 多人点赞 2020-11-11 00:58:26
    链表及其基本操作 文章目录 链表及其基本操作 一、链表是什么? 二、链表是如何实现的 1.创建链表 2.输出链表 三、基本操作(增删改查插) 1.查找结点 2.删除结点 3.插入结点 4.清空结点 做为一名 新生蒟蒻来写第一...
  • 链表基本操作整理

    2013-03-17 14:30:54
    链表基本操作整理,妈妈,我再也不怕链表啦
  • 实例讲解C++ 双链表基本操作

    千次阅读 2016-04-26 08:09:28
    1.概念  双向链表也叫双链表,是链表的一种,它的每个数据结点中都有两个指针,分别指向直接后继和直接前驱。所以,从双向链表中的任意一个...2.基本操作实例   DoubleList.cpp #include "stdafx.h
  • 【数据结构 严蔚敏版】 链表基本操作 链表是一种物理存储单元上非连续、非顺序的存储结构,数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点(链表中每一个元素称为结点)组成,结点可以在...
  • 链表基本操作

    千次阅读 2019-09-19 21:35:48
    链表基本概念以及分配内存空间 1.创建链表 把每个结点的next指针指向下一个结点的地址即可。 程序代码: #include<cstdio> //#include<stdlib> struct node { int data; //数据域 node* ...
  • 链表基本操作和实现

    2014-07-15 16:17:29
    本文档介绍了链表的建立原理,以及使用方法,非常适合初学者对链表操作

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 245,969
精华内容 98,387
关键字:

链表的基本操作