精华内容
下载资源
问答
  • #include<stdio.h> #include<stdlib.h> #include<malloc.h> // 定义存储结构 typedefstruct .../*每元素数据信息*/ structLnode*next; /*后继元素的地址*/ }LNode,*LinkLis...

    #include<stdio.h> 

    #include<stdlib.h> 

    #include <malloc.h> 

    //

    定义存储结构 

    typedef struct 

    Lnode{ 

    int data;  

    /*每个元素数据信息*/ 

    struct Lnode *next; 

    /*后继元素的地址*/ 

    } LNode,*LinkList; 

    void main() 

    void Create_L(LinkList &L,int n); 

    void Print_L(LinkList L); 

    void ReverseList(LinkList L); 

    LinkList La;//

    创建单链表La

     int n; 

    printf("请输入链表La中的元素个数:\n"); 

    scanf("%d",&n); 

    Create_L(La,n);//

    printf("现在La中的元素顺序为:\n"); 

    Print_L(La); 

    printf("-------------------------------------\n\n"); 

    ReverseList(La); 

    printf("逆置后,La的元素顺序为:\n"); 

    Print_L(La);

    void Create_L(LinkList &L,int n) 

    int j=1; 

    L=(LinkList)malloc(sizeof(Lnode)); 

    L->next =NULL;//先建立一个带头结点的单链线性表L 

    for(int i=n;i>0;--i) 

    LinkList p=(LinkList)malloc(sizeof(Lnode)); 

    printf("请输入链表中的第%d个元素:\n",j++); 

    scanf("%d",&p->data); 

    p->next=L->next; 

    L->next =p; 

    }//(逆序实现) 

    /* LinkList q=L; 

     for(int i=1;i<=n;i++)  

    LinkList p=(LinkList)malloc (sizeof(Lnode)); 

    q->next=p; 

    p->next=NULL; 

    q=q->next  

    printf("请输入链表La中的第%d个元素:\n",i); 

     

    scanf("%d",&p->data); 

    }//(正序实现) 

    */ 

    }//

    初始化单链表

    //

    输出单链表

    void Print_L(LinkList L) 

    LinkList p; 

    p=L->next; 

    while(p) 

    printf("%d ",p->data ); 

    p=p->next; 

    printf("\n"); 

    }

    void ReverseList(LinkList L) 

    LinkList p,q; 

    p=L->next; 

    L->next=NULL; 

    while(p!=NULL) 

    q=p->next;

     /*q指针保留p->next得值*/ 

    p->next=L->next; 

    L->next=p; 

    /*将p结点头插入到单链表L中*/ 

    p=q; 

    /*p指向下一个要插入的结点*/ 

    }

    转载于:https://www.cnblogs.com/xufeng123/p/7788463.html

    展开全文
  • 怎么删除一个没有头指针的单链表的一个节点?
    你是不可能拿到要删的这个节点的上一个节点的,所以想用通常删除链表节点的方法删除,是不可能的。
    我们可以将下一个节点的数据拷贝的到要删的节点中来,再将下一个节点删掉。
    展开全文
  • 原题:有一个有序单链表(从小到大有序),表头指针为 L ,编写一个函数向该单链表中插入一个元素 a 的结点,使插入后链表仍然有序。 说明:以下程序先自动生成一个从小到大有序链表,然后要求输入插入结点的数据,...
    原题:有一个有序单链表(从小到大有序),表头指针为 L ,编写一个函数向该单链表中插入一个元素为 a 的结点,使插入后链表仍然有序。
    说明:以下程序先自动生成一个从小到大有序链表,然后要求输入插入结点的数据,再用函数int InSnode(LinkList &L)来实现插入操作,该函数为实现插入操作的核心。
    #include<stdio.h>
    #include<stdlib.h>
    #include<malloc.h>
    #include<conio.h>
    typedef struct LNode
    {
    	int data;
    	struct LNode *next;
    }LNode,*LinkList;
    
    int DisplayList(LinkList L)//输出链表中的数据域的值
    {
    	if(L == NULL)
    	{
    		printf("链表为空!\n");
    		return -1;
    	}
    	printf("当前链表的数据为:\n");
    	LinkList p=L;
    	while(p->next!=NULL)
    	{
    		printf("%d->",p->data);
    		p=p->next;
    	}
    	printf("%d\n\n",p->data);
    	return 1;
    }
    
    int Create(LinkList &L)//	生成链表的函数定义
    {
    	int i;
    	LinkList p=NULL,q=NULL;L=NULL;
    	for(i=0;i<8;i++)
    	{
    		p=(LinkList)malloc(sizeof(LNode));
    		p->data=13*i+68;//为结点的数据域赋值
    		if(L == NULL)
    			L=p;
    		else
    			q->next=p;
    		q=p;		
    	}
    
    	if(L != NULL)
    	{
    		q->next=NULL;
    	}
    	return 1;
    }
    
    int InSnode(LinkList L)//插入结点的函数
    {
    	LinkList s,p,q;int a;
    	printf("请输入你要插入的结点的数据域的值:\n");
    	scanf("%d",&a);
    	s=(LinkList)malloc(sizeof(LNode));	//生成要插入的结点
    	s->data=a;s->next=NULL;
    	if(L==NULL || a<L->data)//寻找插入位置
    	{
    		s->next=L;
    		L=s;
    	}
    	else
    	{
    		q=L;p=q->next;
    		while(p!=NULL && a>p->data)
    			if(a>p->data)
    			{
    				q=p;
    				p=p->next;
    			}
    			s->next=p;
    			q->next=s;
    	}
    	return 1;
    }
    
    void main()
    {
    	LinkList L;
    	Create(L);
    	DisplayList(L);
    	InSnode(L);
    	DisplayList(L);
    }

    展开全文
  • 头指针结点

    千次阅读 2016-12-11 23:42:53
    在一个没有结点的链表里面,我们要插入一个结点我们要传的是头指针的地址,因为我们插入第一个结点的时候要改变头指针 (想改表一个东西就要传它的地址,我们现在要改变的是这个指针 所以要传的是这个指针的地址...

    对于一个链表来说  头指针是必须的 头结点是可有可无的  

    不过头结点为链表的插入实现了统一化

    在一个没有头结点的链表里面,我们要插入一个结点我们要传的是头指针的地址,因为我们在插入第一个结点的时候要改变头指针  (想改表一个东西就要传它的地址,我们现在要改变的是这个指针  所以要传的是这个指针的地址,这里考虑的后插  所以只有第一次会改变头指针)、、

    没有头结点的链表  头指针初始化是这样的

    void init(list **head)

    {

        *head = NULL;

    }

    void insert_list(list **L,int new_value)
    {
        list *new;

        new = (list *)malloc(sizeof(list));
        if(new == NULL )
        {
            printf("error\n");
    exit(1);
        }
        
        if( *L == NULL )
        {
            new->value = new_value;
            new->next = NULL;
            *L = new;   //          这个时候需要改变头指针,这也是我们为什么传指针的地址(二维指针)的原因
        }
        else
        {

             list *temp = *L;   // 之后我们只需要改变结点里面的值,所以只需要用到结点的地址  对L进行降维操作  


            while( temp->next != NULL )
    {
       temp = temp->next;
    }


    new->value = new_value;
    new->next = NULL;
            temp->next = new;
        }
        
    }

    int main()

    {

        list *head;

        init(&head);

        insert_list(&head);

    }


    下面写一个有头结点的链表

    有头节点的链表初始化的时候已经申请了一个链表节点的空间作为头指针,这个节点本身没有太大意义  它的数据段是不存放我们想要输入的数据的  下面我们来初始化一个有头结点的链表
    int main()
    {
        list  *head; / /这是一个头指针

        head = creat_list(); //初始化

    }  

    list *creat_list()

    {

        list  *head ;

        head = (list *)malloc(sizeof(list));

        if(head == NULL)

        {

            printf("error");

            exit(1);

        }

        head->next = NULL;

        return head;

    }

    因为我们已经为头指针赋了一个地址(头结点的地址),不要问为什么要插入一个不用的结点,这个只是为了之后插入节点时不需要改变头指针的,实现插入的统一化。我们在之后的插入都不会改变头指针,因为我们插到头结点的后面的,所以我们后面插入的时候直接传head(结构体指针)就可以了  不需要传&head;

    void insert_list(list *head,int new_value)

    {

         list *new;

        while(head->next != NULL)

        {

            head = head->next;

        }

        new = (list *)malloc(sizeof(list))

        if(new ==NULL)

        {

            printf("error\n");

            exit(1);

        }

        new->value = new_value;

        new->next = NULL;

        head->next  = new;

    }

    因为定义了一个头结点  这里面是不存放有效数字的  所以我们遍历打印的时候 要从head->next开始打印  判断这个表是不是空判断的也是判断head->next是否为NULL


    http://www.nowamagic.net/librarys/veda/detail/1805  结构之美:单链表的头结点与头指针

    展开全文
  • 核心代码 void Count(LinkList head,int y) { LinkList p; p=head; int n=0; while(p->next!=NULL) { p=p->next; if(p->data==y) ... printf("%d出现次数:%d",y,n); } main函数...
  • 头指针head

    千次阅读 2019-06-05 11:54:09
    使用头指针head时,通常先定义head=NULL,目的是初始化时使head有一个明确定义,head不指针。 例: int * head=NUll,* L; L=(LNode * )malloc(sizeof(Lnode)); head=L; 二、head->next=null 把Head...
  • 单链表头节点,头指针

    万次阅读 多人点赞 2018-06-12 21:17:55
    ...链表中第一个结点的存储位置叫做头指针,那么整个链表的存取就必须是从头指针开始进行了。之后的每一个结点,其实就是上一个的后继指针指向的位置。 这里有个地方要注意,就是对头指针...
  • 单链表中头指针结点的关系

    千次阅读 2019-06-02 12:48:16
    头指针结点不同,结点即第一个结点,头指针是指向第一个结点的指针。 链表中可以没有结点,但不能没有头指针。 以下是头指针结点的关系: typedef struct LNode{ int data; struct LNode *next; }...
  • 9,给定一个带表头结点的单链表,设head为头指针,结点结构(data, next), data整型元素, next为指针,试写出算法:按递增次序输出单链表中各结点的数据元素,并释放结点所占的存储空间(要求:不允许使用数组作为辅助...
  • 单链表中,我们有了结点时,我们可以用O(1)的时间访问第一个结点,但对于要访问最后一个结点,我们必须要挨个向下索引,所以需要O(n)的时间。 用O(1)的时间就可以由链表指针访问到最后一个结点。 不过我们需要...
  • 链式存储结构的头指针结点

    千次阅读 2013-08-09 15:28:37
    此处返回给L的是一个指针,并且赋给了头指针 L->next=null; //这里说明我创建了一个头结点,即同时运用了头指针结点,不过感觉结点用处不大,所以一般还是不用最好。  假设L是LinkList
  • 链表中结点与头指针的概念

    千次阅读 2016-05-04 16:16:28
    1.线性表的链式存储结构中,头指针是指链表中指向第一个结点的指针,若链表有结点,则头指针就是指向链表头结点的指针。 2.头指针具有标识作用,因此经常使用链表的名字作为头指针名 3.无论链表是否空,...
  • 头指针结点、首元结点概念区别

    万次阅读 多人点赞 2018-06-11 14:34:51
    转自:https://blog.csdn.net/liangxingda/article/details/52755800链表中第一个结点的存储位置叫做头指针,那么整个...“链表中第一个结点的存储位置叫做头指针”,如果链表有结点,那么头指针就是指向结点...
  • 链表、头指针结点

    万次阅读 多人点赞 2010-12-22 22:10:00
    图1 线性链表的逻辑状态 有时单链表的第一个结点之前附设一个结点,称之为头结点 。 结点的数据域可以不存储任何信息,也可以存储如线性表长度等类的附加信息,结点的指针域存储指向第一个结点的指针(即第...
  • { /* 操作结果:构造一个空的线性表L */ *L=(LinkList)malloc(sizeof(struct LNode)); /* 产生结点,并使L指向此结点 */ if(!*L) /* 存储分配失败 */ exit(OVERFLOW); (*L)->next=NULL; /* 指针空 */ ...
  • 头指针结点、首元节点】

    万次阅读 多人点赞 2016-10-08 13:25:10
    链表中第一个结点的存储位置叫做头指针,那么整个链表的存取就必须是从头指针开始进行了。之后的每一个结点,其实就是上一个的后继指针指向的位置。 这里有个地方要注意,就是对头指针概念的理解,这个很重要。...
  • 数据结构-线性表-头指针&结点

    万次阅读 多人点赞 2013-10-05 10:59:47
    链表中第一个结点的存储位置叫做头指针,那么整个链表的存取就必须是从头指针开始进行了。之后的每一个结点,其实就是上一个的后继指针指向的位置。 这里有个地方要注意,就是对头指针概念的理解,这个很重要。 ...
  • 链表中使用结点与尾指针

    万次阅读 多人点赞 2018-01-06 21:21:59
    链表头:数据内容一个元素的结点。 头指针:指向结点元素的指针结点:数据内容无效,其指针头指针。 一句话描述头指针是指向结点的指针结点是指向链表头的结点。
  • 假设数组Q[m]存放循环队列中的元素, 同时设置一个标志tag,tag = 0 和 tag = 1来区别头指针(front)和队尾指针(rear)相等时,队列状态“空”还是“满”。试设计与此结构相应的插入和删除算法,编写代码,并...
  • 问题:设一个没有结点指针的单链表。一个指针指向此单链表中间的一个结点(不是第一个,也不是最后一个结点),将该结点从单链表中删除,要求时间复杂度O(1) &nbsp; &nbsp; &nbsp; &nbsp;...
  • 不改变链表的前提下,请设计一个尽可能高效的算法,查找链表中倒数第k个位置上的结点(k正整数),若查找成功,算法输出该结点的data域的值,并返回1;否则,只返回0,要求: 1)描述算法的基本设计思想。 2)描述算法的详细...
  • 结点和头指针的理解

    千次阅读 2019-02-14 21:28:55
    线性表使用顺序(数组)存储时有个弊端,那就是插入和删除时需要大量的移动数据,这显示是非常消耗时间的,所以可以采用链式存储,即有一个指针域(单链表),来记录下个结点的存储位置(地址),这样插入和删除...
  • 1.结点:(1)数据结构中,单链表的开始结点之前设立一个节点称之为头结点,结点的数据域可以不存储任何信息,也可以存储链表的长度等附加信息,结点的指针域存储指向第一个结点的指针(即第一个结点的存储...
  • void sortDel(LinkList* L){ LinkList *p,*pre,*minp,*minpre; LinkList* temp; while(L->next!=NULL){ p = L->next; pre = L; minpre = pre; minp = p; while(p!=NULL){ if(p->data < mi
  • 已知一个带有表头的单链表,结点结构data-link,假设该链表只给出了头指针list。不改变链表的前提下,请设计一个尽可能高效的算法,查找链表中倒数第k个位置上的结点(k正整数)。若查找成功,算法输出该结点...
  • 关于链表中头指针结点的理解

    万次阅读 多人点赞 2018-05-29 16:04:03
    线性表使用顺序(数组)存储时有个弊端,那就是插入和删除时需要大量的移动数据,这显示是非常消耗时间的,所以可以采用链式存储,即有一个指针域(单链表),来记录下个结点的存储位置(地址),这样插入和删除...
  • !... ElemType data; struct LNode *next; ...}LNode,*LinkList;...L=(LinkList)malloc(sizeof(LNode));...问题:我们知道L->data是结点的数据域,可是一般不会放有效数据...存在的话怎么提取头指针L的data域和next域的数据?
  • 关于单链表的存取,有时候我们单链表的第一个结点(有效元素)之前附设一个结点,称之为头结点;指向结点的指针,称之为头指针;对单链表的存取必须从头指针开始进行,由于单链表的最后一个数据元素没有直接后继...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 343,001
精华内容 137,200
关键字:

在一个以l为头指针