精华内容
下载资源
问答
  • (1)采用一级指针链表进行初始化 (2)采用二级指针链表进行初始化 我们一般采用第一种方法的比较多,特别是对于刚刚接触链表的萌新,或者对于指针的理解不是很熟悉的萌新。 typedef struct link_list { int ...

    我们对链表进行初始化时:主要有两种方法

    1)采用一级指针对链表进行初始化
    (2)采用二级指针对链表进行初始化
    

    我们一般采用第一种方法的比较多,特别是对于刚刚接触链表的萌新,或者对于指针的理解不是很熟悉的萌新。

    typedef struct link_list
    {
    	int data; 				//结构体中的元素
    	struct link_list *next; //指向下一个节点
    }link_list_t;
    

    我们对链表进行初始化,一般采用一级指针的方法,如下代码所示:
    优点:易理解,对于刚入门的萌新
    特点,初始化函数要有返回值,而且要接收已经分配内存的list,才能完成初始化,如下所示

    //链表的初始化,一级指针的方法(一般做法)
    link_list_t* list_init(link_list_t *list)
    {
    	
    	if (!list)
    	{
    		list = new link_list_t;
    		list)->data = 0;
    		list)->next = NULL;
    		return list;
    	}
    	else
    	{
    		printf("链表已经存在!不用进行初始化\n");
    		return 0;
    	}
    }
    
    int main()
    {
    	link_list_t *link_list = NULL;
    	link_list = list_init(link_list)//要接收已经分配内存的list,才能完成初始化
    	if (link_list)
    	{
    		printf("链表初始化成功!\n");
    	}
    	return 0;
    }
    

    那么二级指针怎么使用来初始化呢?
    也简单,初始化函数中的形参采用二级指针就行了,相当于对传入的实参对其地址进行操作。

    link_list_t *link_list = NULL;
    
    void list_init(link_list_t **list);//初始化函数
    
    list_init(&link_list); //传入链表的地址
    

    如上,初始化函数中的形参是二级指针,而我们的结构体指针link_list 为一级指针,所以我们要传入link_list 的地址,那怎么访问二级结构体中指针的元素呢?使用(*list)访问就行了,访问二级结构体中指针的元素时,不能这样子直接*list, 会报错

    优点:
    1.直接操作内存,不需要接收返回值,速度快
    2.高逼格
    完整代码如下

    //链表初始化, 二级指针
    void list_init(link_list_t **list)
    {
    	if (!(*list))
    	{
    		(*list) = new link_list_t;
    		(*list)->data = 0;
    		(*list)->next = NULL;
    	}
    	else
    	{
    		printf("链表已经存在!\n");
    	}
    }
    int main()
    {
    	link_list_t *link_list = NULL;
    	list_init(&link_list); //传入链表的地址
    	if (link_list)
    	{
    		printf("链表初始化成功!\n");
    	}
    	return 0;
    }
    

    有什么疑惑欢迎评论区留言哦!

    展开全文
  • 非循环链表的C++语言定义//非循环单链表数据结构C艹类声明template class LinkList { public: class LinkNode { public: ElemType data; LinkNode *next; // NodePointer next; };

    非循环链表的C++语言定义

    //非循环单链表数据结构C艹类声明
    
    template <typename ElemType>
    class LinkList
    {
    public:
        class LinkNode
        {
        public:
            ElemType data;
            LinkNode *next;
        //  NodePointer next;
        };
        typedef LinkNode * NodePointer;
        // 下面可以添加很多链表操作函数
        void adverse();                                               //非循环单链表的逆置
        void randLinkList();                                        //产生随机链表
        void display(ostream& out) const;
    //************************下列为系统自动调用的构造函数和析构函数**************************//
        LinkList();
        virtual~LinkList();
        LinkList(const LinkList<ElemType>& otherL);
    
    protected:
        NodePointer head;
    };
    
    
    //非循环单链表的逆置
    
    template <typename ElemType>
    void LinkList<ElemType>::adverse()
    {
        NodePointer r,p,q;
    
        if(!head)
            return;
        r=NULL,p=head,q=p->next;
        while(p)
        {
            p->next=r;
            r=p;
            p=q;
            if(q)
                q=q->next;
        }
        head=r;
    }
    //随机产生非循环单链表
    void LinkList<ElemType>::randLinkList()
    {
        clear();
        int i,n;
        int elem[11];
        NodePointer p=head;
        NodePointer s;
        srand((unsigned)time(NULL));
        n=rand()%10+1;
        cout<<"用如下随机数生成非循环单链表:"<<endl;
         for( i=0;i<=n;i++)
         { 
             elem[i]=rand()%100+1;
           cout<<elem[i]<<" ";
          }
        cout<<endl;
        cout<<endl<<"随机生成的非循环单链表为:"<<endl;
        for( i=1;i<=n+1;i++)
            cout<<"[ "<<i<<"] ";
        cout<<endl;
        for(i=0;i<=n;i++)
        {
            s=new LinkNode;
            assert(s!=0);
            s->data=elem[i];
            if(!head)
                head=s;
            else
                p->next=s;
            p=s;
            if(p)
            p->next=NULL;
        }
        p=head;
        while(p)
        {
            while(p->next!=NULL)
            {
            cout<<" "<<p->data<<"->";
            break;
            }       
            while(p->next==NULL)
            {
                    cout<<" "<<p->data<<"∧";
                    break;
            }
            p=p->next;
        }   
        cout<<endl;
    }

    使用随机产生的数组elem[i]对链表进行初始化的过程如下:

      for(i=0;i<=n;i++)
        {
            s=new LinkNode;
            assert(s!=0);
            s->data=elem[i];
            if(!head)
                head=s;
            else
                p->next=s;
            p=s;
            if(p)
            p->next=NULL;
        }
        p=head;

    看似简单的程序,理解起来对于初学者却很费力,现上传自己的梳理程序流程图如下:
    链表初始化流程图
    链表的逆置,也体现了指针操作的精髓,其核心思想是:从非循环单链表的第一个结点开始,沿着链表滑动,知道最后一个结点,逐一反转。
    具体程序如下:

    NodePointer r,p,q;//声明结点指针型的三个指针,分别用来指向当前结点、前结点和后结点
    
        if(!head)   //如果当前链表的头指针为空,说明链表不存在,程序终止
            return;
        r=NULL,p=head,q=p->next;  //第一次时,当前指针指向首结点,也就是等于头指针
        while(p)
        {
            p->next=r;//对当前结点的指针赋值,指向前结点,当然首节点反转后成为尾结点,其next指针为NULL
            r=p;  //r,p,q依次向后滑动
            p=q;
            if(q)
                q=q->next;
        }
        head=r;   当p=q=NULL时,说明当前结点已经滑动至尾结点之外,此时,只需要将r指针赋值给头指针即可

    具体流程图自己在草稿纸上消化如下:
    这里写图片描述

    展开全文
  •  函数卡在INIT_LIST_HEAD 宏,无法初始化全局链表数组,该数组的每个元素分别是一组同阶的buddy链表的链表头。数组为全局变量,存储在bss段。既然无法修改bss的内容,尝试在函数内部定义一个连

        解决了函数调用多时系统无响应的问题,现在来解决初始化 buddy 链表头时卡在INIT_LIST_HEAD 宏的问题,把难啃的骨头留在后边,最后再腾出功夫来看中断无法初始化是怎么回事。

        函数卡在INIT_LIST_HEAD 宏,无法初始化全局链表数组,该数组的每个元素分别是一组同阶的buddy链表的链表头。数组为全局变量,存储在bss段。既然无法修改bss的内容,尝试在函数内部定义一个连表节点变量,将该变量的两个指针成员指向自身,结果是成功的。查看变量的地址,靠近内存最高端的栈里,这是因为arm的堆栈是满递减结构,从顶向下增长的。再回头看数组的地址:0x00000420,在前4K,这个地址是CPU内部STEPSTONE使用的,那么要解决这个问题就要修改bss段的链接地址了,将其避开前4K地址。做法是将链接脚本中bss段从kernel段上边拿到下边,原链接脚本:

     /********************************************************************
     *
     * @ File Name  : link.lds
     * @ Date       : 2012-03-24
     * @ Author     : gaofeilong <gaofeilonglcu@163.com>
     *
     * @ Description: link scripts, determin all section layout
     *
     * *****************************************************************/

    OUTPUT_FORMAT("elf32-littlearm","elf32-littlearm", "elf32-littlearm")
    OUTPUT_ARCH(arm)
    ENTRY(_start)

    SECTIONS
    {
            . = 0x00000000;
            . = ALIGN(4);
            .bootloader    :
            {
                   start.o(.text .rodata* .data)
                   init.o(.text .rodata* .data)
                   serial.o(.text .rodata* .data)
                   nand.o(.text .rodata* .data)
            }

           . = ALIGN(4);
            __bss_start = .;
           .bss            : {*(.bss) }
            . = ALIGN(4);
            __bss_end = .;


            . = ALIGN(4);
            .kernel 0x30000000 : AT(0x1000) {*(.text .rodata* .data .bss) }
    }

     修改后的链接文件:

    /********************************************************************
     *
     * @ File Name  : link.lds
     * @ Date       : 2012-03-24
     * @ Author     : gaofeilong <gaofeilonglcu@163.com>
     *
     * @ Description: link scripts, determin all section layout
     *
     * *****************************************************************/

    OUTPUT_FORMAT("elf32-littlearm","elf32-littlearm", "elf32-littlearm")
    OUTPUT_ARCH(arm)
    ENTRY(_start)

    SECTIONS
    {
            . = 0x00000000;
            . = ALIGN(4);
            .bootloader    :
            {
                   start.o(.text .rodata* .data)
                   init.o(.text .rodata* .data)
                   serial.o(.text .rodata* .data)
                   nand.o(.text .rodata* .data)
            }
            . = ALIGN(4);
            .kernel 0x30000000 : AT(0x1000) {*(.text .rodata* .data .bss) }

           . = ALIGN(4);
            __bss_start = .;
           .bss            : {*(.bss) }
            . = ALIGN(4);
            __bss_end = .;


    }

    编译报警:warning: section `.kernel' type changed to PROGBITS,这是看到kernel段中也有bss信息,应该是和下边的bss段信息重叠了,删除kernel中的bss,最后的样子:

     /********************************************************************
     *
     * @ File Name  : link.lds
     * @ Date       : 2012-03-24
     * @ Author     : gaofeilong <gaofeilonglcu@163.com>
     *
     * @ Description: link scripts, determin all section layout
     *
     * *****************************************************************/

    OUTPUT_FORMAT("elf32-littlearm","elf32-littlearm", "elf32-littlearm")
    OUTPUT_ARCH(arm)
    ENTRY(_start)

    SECTIONS
    {
            . = 0x00000000;
            . = ALIGN(4);
            .bootloader    :
            {
                   start.o(.text .rodata* .data)
                   init.o(.text .rodata* .data)
                   serial.o(.text .rodata* .data)
                   nand.o(.text .rodata* .data)
            }

     

           . = ALIGN(4);
            .kernel 0x30000000 : AT(0x1000) {*(.text .rodata* .data) }

            .= ALIGN(4);
            __bss_start = .;
           .bss            : {*(.bss) }
            . = ALIGN(4);
            __bss_end = .;

    }

    再编译,OK通过。

       烧到板子上运行,结果正常,能够初始化链表头数组了。

     


    展开全文
  • 就例如在链表的构建中,链表初始化和销毁为何需要使用一个二级指针,而不是只需要传递一个指针就可以了,其问题的关键就在于c语言的参数传递的方式是值传递 那么,这篇文章就来聊一聊在链表初始化中一级指针的传递和...

    ###引言###

    在数据结构的学习过程中,有时候会遇到一些一时无法理解的问题,深究起来却是语言的底层的语法机制所限制.
    就例如在链表的构建中,链表的初始化和销毁为何需要使用一个二级指针,而不是只需要传递一个指针就可以了,其问题的关键就在于c语言的参数传递的方式是值传递
    那么,这篇文章就来聊一聊在链表的初始化中一级指针的传递和二级指针的区别.


    一级指针和二级指针的区别


    1.前提知识:c语言中参数传递的方式是值传递和地址传递

    • 值传递:传递的是实参的副本,即形参是一个新开辟的类型一样,里面的内容一样,地址不一样的一个变量,主函数和被被调用函数用的是不一样的内存空间
    • 地址传递:传递的是一个地址,实际上主函数和被调用函数共用的是同一块内存空间,被调用函数依然需要一个新的指针来保存起来这块地址

    2.传递一级指针:无法对原指针指向第地址进行修改

    一级指针实例:

    #include <stdio.h>
    
    #include <stdlib.h>
    
    #define MaxSize 100
    
    typedef int ElemType;
    
    typedef struct SingleNode{
    
             ElemType data;
    
             struct SingleNode *next;
    
    }SingleNodeList,*Linklist;
    
    void LinkedListInit(SingleNodeList *head){//用一个指针head接收传入的地址
    
        Linklist p;
    
             if((head=(SingleNodeList *)malloc(sizeof(SingleNodeList)))==NULL){
    
                       exit(1);//给head分配内存,改变了head指针指向的地址(注意这里的head只是LinkedListInit的head,不是主函数那个)
    
             }
    
             head->next=NULL;
    
    }//这个函数结束后head被销毁了,主函数的那个head不变;
    
    int LinkedList_PushFront(SingleNodeList *head,ElemType x){//2单链表头插入
    
             SingleNodeList *q;
    
             if((q=(struct SingleNode *)malloc(sizeof (struct SingleNode)))==NULL){
    
                       exit(1);
    
             }
    
            q->data=x; q->next=head->next;//头节点的数据域与指针域赋值
    
             head->next=q;//头节点加入链表
    
             return 1;
    
    }
    
    int LinkedList_PopFront(SingleNodeList *head,ElemType *x){//3单链表头删除
    
             SingleNodeList *p=head,*q;
    
             if(p->next==NULL){
    
                       printf("There is no data in the Linkedlist to delete.\n");
    
                       *x = -12345;//未成功删除则在x指向单元赋特定值
    
                       return 0;
    
             }
    
            p=head->next;
            q=p;
            head->next=p->next;
            *x=q->data;
            free(q);
            return *x;//请填写多行代码
    
    }
    
    int LinkedListGet_current(SingleNodeList *p,ElemType *x){//4取当前指针指数据
    
            *x =p->data;
    
             return 1;
    
    }
    
    int LinkedListUpdata_current(SingleNodeList *p,ElemType x){//5修改当前指针数据
    
             p->data=x;
    
             return 1;
    
    }
    
    int LinkedListShow(SingleNodeList *head){//6打印单链表
    
             SingleNodeList *p=head;
    
             if(p->next==NULL){
    
                       printf("There is no data in the Linkedlist to print.\n");
    
                       return 0;
    
             }
    
             while(p->next!=NULL){
    
                       printf("%d ",p->next->data);
    
                       p=p->next;
    
             }
    
             printf("\n");
    
             return 1;
    
    }
    
    void LinkedListDestroy(SingleNodeList **head){//7释放链表
    
             SingleNodeList *p=*head,*q;
    
             while(p!=NULL){
    
                       q=p;
    
                       p=p->next;
    
                       free(q);
    
             }
    
             *head=NULL;
    
    }
    
    int LinkedListLength(SingleNodeList *head){//8求单链表长度
    
             SingleNodeList *p=head;
    
             int size=0;
    
             while(p->next!=NULL){
    
                       size++;
    
                       p=p->next;
    
             }
    
             return size;
    
    }
    
    int main(){
    
             SingleNodeList *head,*p;
    
             ElemType i,x;
    
             int switch_num;
    
             scanf("%d",&switch_num);
    
             switch(switch_num){
    
                       case 1:
    
                                LinkedListInit(head); //传入指针变量head的地址
    
                                LinkedList_PushFront(head,1);
    
                                LinkedList_PushFront(head,3);
    
                                LinkedList_PushFront(head,2);
    
                                LinkedListShow(head);
    
                                break;
    
           }
    
           LinkedListDestroy(&head);
    
           return 0;
    
    }

    传递流程如图所示

    1671712-20190427135432693-938925229.png

    从图中可以看出,main函数中我们定义了 一个指针head,假设它的地址是0x10010,但是还没给它初始化,也就是说它存的地址是随机的,我们也假设它存的是0x12306

    在main函数中,我们把head这个指针作为参数传递进去初始化函数(值传递),按照值传递的原则,初始化函数首先开辟了一个*head指针,它的地址是0x12345(与main函数的0x10010不一样),但是它的内容是是和主函数的head是一样的,都是指向0x12306这个地址

    在初始化的过程中,我们用malloc函数对初始化函数内的head指针分配内存空间,也就是改变了head指针的值,由未初始化的随机值0x12306改变成了0x10086

    也就是说,由于这个head是作用在初始化函数内的,mallo作用的不是主函数的head,初始化函数结束后,这个head指针就被销毁掉了,主函数中的head不受影响,初始化失败,而分配了内存不能使用,造成了内存泄漏


    3. 传递二级指针:对指针指向的内容进行操作,head销毁后无影响

    二级指针传递实例:

        
    
    
    #include <stdio.h>
    
    #include <stdlib.h>
    
    #define MaxSize 100
    
    typedef int ElemType;
    
    typedef struct SingleNode{
    
             ElemType data;
    
             struct SingleNode *next;
    
    }SingleNodeList,*Linklist;
    
    void LinkedListInit(SingleNodeList **head){//1初始化有头节点的单链表
    
        Linklist p;
    
             if((*head=(SingleNodeList *)malloc(sizeof(SingleNodeList)))==NULL){
    
                       exit(1);
    
             }
    
             (*head)->next=NULL;
    
    }
    
    int LinkedList_PushFront(SingleNodeList *head,ElemType x){//2单链表头插入
    
             SingleNodeList *q;
    
             if((q=(struct SingleNode *)malloc(sizeof (struct SingleNode)))==NULL){
    
                       exit(1);
    
             }
    
            q->data=x; q->next=head->next;//头节点的数据域与指针域赋值
    
             head->next=q;//头节点加入链表
    
             return 1;
    
    }
    
    int LinkedList_PopFront(SingleNodeList *head,ElemType *x){//3单链表头删除
    
             SingleNodeList *p=head,*q;
    
             if(p->next==NULL){
    
                       printf("There is no data in the Linkedlist to delete.\n");
    
                       *x = -12345;//未成功删除则在x指向单元赋特定值
    
                       return 0;
    
             }
    
            p=head->next;
            q=p;
            head->next=p->next;
            *x=q->data;
            free(q);
            return *x;//请填写多行代码
    
    }
    
    int LinkedListGet_current(SingleNodeList *p,ElemType *x){//4取当前指针指数据
    
            *x =p->data;
    
             return 1;
    
    }
    
    int LinkedListUpdata_current(SingleNodeList *p,ElemType x){//5修改当前指针数据
    
             p->data=x;
    
             return 1;
    
    }
    
    int LinkedListShow(SingleNodeList *head){//6打印单链表
    
             SingleNodeList *p=head;
    
             if(p->next==NULL){
    
                       printf("There is no data in the Linkedlist to print.\n");
    
                       return 0;
    
             }
    
             while(p->next!=NULL){
    
                       printf("%d ",p->next->data);
    
                       p=p->next;
    
             }
    
             printf("\n");
    
             return 1;
    
    }
    
    void LinkedListDestroy(SingleNodeList **head){//7释放链表
    
             SingleNodeList *p=*head,*q;
    
             while(p!=NULL){
    
                       q=p;
    
                       p=p->next;
    
                       free(q);
    
             }
    
             *head=NULL;
    
    }
    
    int LinkedListLength(SingleNodeList *head){//8求单链表长度
    
             SingleNodeList *p=head;
    
             int size=0;
    
             while(p->next!=NULL){
    
                       size++;
    
                       p=p->next;
    
             }
    
             return size;
    
    }
    
    int main(){
    
             SingleNodeList *head,*p;
    
             ElemType i,x;
    
             int switch_num;
    
             scanf("%d",&switch_num);
    
             switch(switch_num){
    
                       case 1:
    
                                LinkedListInit(&head);
    
                                LinkedList_PushFront(head,1);
    
                                LinkedList_PushFront(head,3);
    
                                LinkedList_PushFront(head,2);
    
                                LinkedListShow(head);
    
                                break;
    
           }
    
           LinkedListDestroy(&head);
    
           return 0;
    
    }
    

    1671712-20190427135508067-1098256038.png

    如图所示,如果传递的是二级指针就不一样了,首先我们在main函数中的操作是和一级指针差不多,只是传递的时候传递的不是一个指针变量,而是这个指针变量的地址(地址传递),但是在初始化函数中我们接收这个地址的是用一个二级指针,也就是用一个head指针指向传递主函数那个head指针的地址,从而来进行对初始化函数中head指针内容的改变去影响到主函数中的head的指向

    如图所示,我们在mian函数中传递了一个head的地址,也就是0x10010,这个地址是指向0x12306指针的地址
    在初始化函数中,我们用一个另外的head指针接受这块地址,也就是个二级指针,第一级是0x10010,指向0x12305),第二级是0x12345,指向0x10010

    在初始化函数中,malloc函数操作的对象是head指针内的内容,也就是0x10010这块指针(主函数中的head指针),这样成功改变了主函数中的head指向的地址,而在销毁初始化函数的head指针的时候,主函数的的head指针不受影响


    4. 总结

    • 参数传递时,在需要改变指针指向的时候需要传递二级指针,例如初始化和销毁链表
    • 一二级指针的图片对比如下图
      1671712-20190427135527029-1328862907.png

    转载于:https://www.cnblogs.com/fanqieya/p/10778516.html

    展开全文
  • #include<iostream> using namespace std; typedef struct Node { int data; struct Node *next;...}Node, *Linklist;...//*L为头结点,L为头指针 (*L)->next = NULL; } void fromhead(Linklist L) { Nod
  • //循环链表 实现对循环链表初始化,创建,插入,删除,输出操作 //它只设置尾指针rear,这时头节点为rear->next #include #include #include typedef struct node{ //定义单链表的节点 int data; struct node ...
  • 链式存储结构 ...我的初始化是从键盘输入数据,只要不输入0就能一直创建新的结点,输入0就是链表结束。并且打印一遍链表。 代码实现如下: #include<stdio.h> #include<stdlib.h> typ
  • } 注: 1:巧用指针初始化,给翻转链表的末尾空指针赋值。 2:如果不想修改函数传入的参数head,可以重新声明一个指针替代head的移动修改。 92. 反转链表 II 题目: 反转从位置 m 到 n 的链表。请使用一趟...
  • 链表初始化看C语言的二级指针

    千次阅读 2014-07-26 23:35:43
    链表初始化看C语言的二级指针 博客分类: C语言 C语言链表初始化内存分配  先来看C语言创建链表、插入节点和遍历链表的一段代码: C代码   #include #include typedef int ...
  • 链表初始化为什么要用双重指针】 如: typedef DataType int typedef struct Node{  DataType data;  struct Node *next; }LNode,*PNode,*LinkList;   int Initial(LinkList *h){ //参数为头结点...
  • 理解 我的链表 9.20 今天下午先到这( ̄▽ ̄)" #include<iostream> #include<...//需要头结点、头指针、结点的结构体、还有各种方法(一个一个的来)。 typedef struct Node{ //结点的结构体成员...
  • 静态链表初始化、插入、删除

    千次阅读 2017-12-28 21:36:57
    #include #include #define OK 1 #define TRUE 1 #define ERROR -1 #define FALSE -1 #define OVERFLOW -2 ...//------静态链表 X 使用数组实现链表,可以在没有指针的编程语言中实现链表结构 #define MAXSI
  • 链表初始化看C语言的二级指针 博客分类: C语言 C语言链表初始化内存分配 先来看C语言创建链表、插入节点和遍历链表的一段代码: C代码 #include #include typedef int ElemType; typedef struct ...
  • 一、单链表的初始化 先上结构体: typedef struct Node { int data; Node* next; }Node,*LinkedList; Node为struct Node的别名, LinkedList为struct Node*,也就是链表指针的别名。 代码: LinkedList ...
  • 简单来说,修改头指针则必须传递头指针的地址, 不修改头指针就传一级指针(即头指针本身)。 这与普通变量类似,当需要修改普通...所以创建链表和销毁链表需要二级指针或者一级指针引用 typedef struct Node{ Ele...
  • 双向链表是在单链表的基础上增加了指向直接前驱的指针,所以在双向链表中的每一个节点都能很容易的找到他的前驱和后继。双向链表经常和循环链表一起使用,成为双向循环链表,他的尾指针的后继指向头结点,头结点的...
  • 昨天和今天通过学习《数据结构与算法分析》以及上机实验复习了链表,结构体指针,malloc函数的使用。 先说说昨天心里一热一下听了两节CS50的收获。 TRIE树是一种由HASH表的变种,是一种效率大于HASH表的查找树,...
  • 链表初始化C++

    2021-05-13 16:10:07
    #include <iostream> using namespace std;... Node(int _data) { //显式构造函数,每次对新声明的节点类的对象进行初始化 data = _data; next = NULL; } }; //链表类 class LinkList { publi
  • 双向链表:又称为双链表,是链表的一种,它的每个数据结点中都有两个指针,分别指向直接后继和直接前驱。 特点: 在数据结构中具有双向指针 插入数据的时候需要考虑前后的方向的操作 同样,删除数据的是有也需要考虑...
  • 当我们为指针申请内存时若用一下方法: list* head; head=new list;...会造成未初始化内存head(在函数中) 此时将head=new list; 改成head=(list*)malloc(sizeof(list*));即可 malloc函数头文件stdlib.h;
  • 用数组代替指针或引用来描述单链表,即用数组描述的链表叫做静态链表,这种描述方法叫做游标实现法。 静态链表结构 游标 6 2 3 4 5 0 7 … 1 数据 - A B C D E - … - 下标 0 1 2 3 4 5 6 … MAX-1 ...
  • #include using namespace std; typedef struct Node ... //当输入链表为空时,初始化链表 ListOut1(p1); //此时输出为空? 为什么? 我不是在初始化时在堆中分配的内存 不是可以用吗? system("pause"); }
  • 双向链表和单向链表也是有很多相似的地方的,听名字可以猜到,每个节点都包含两个指针,一个指针指向上一个节点,一个指针指向下一个节点。这里有两个特殊的地方,第一就是头节点的一个指针指向NULL空指针(没有前驱...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,313
精华内容 925
关键字:

链表指针初始化