精华内容
下载资源
问答
  • C语言链表中q->next=p;表示什么意思?

    千次阅读 2021-05-19 11:03:37
    意思:使当前指针指向链表的下一个结点。一般作用在数据结构的单链表里由应用,语句的p一般指向一个结构体类型的数据,此类型的数据通常表示节点;结构体里存放的一些数据和记录下一个节点地址的指针变量next;...

    q->next = p; 表示将节点p加入到节点q之后。

    意思:使当前指针指向链表的下一个结点。

    一般作用在数据结构中的单链表里由应用,语句中的p一般指向一个结构体类型的数据,此类型的数据通常表示节点;结构体里存放的一些数据和记录下一个节点地址的指针变量next;这个next就好比链条一样,连接着一个个节点。

    ->是一个整体,它是用于指向结构体、C++中的class等含有子数据的指针用来取子数据。换种说法,如果在C语言中定义了一个结构体,然后申明一个指针指向这个结构体,那么要用指针取出结构体中的数据,就要用到“->”.

    5639f78c33c552dfb82237d2ac00af61.png

    扩展资料

    链表的特点:

    1、n个节点离散分配

    2、每一个节点之间通过指针相连

    3、每一个节点有一个前驱节点和一个后继节点

    4、首节点没有前驱节点,尾节点没有后继节点

    创建链表前须知

    首节点:存放第一个有效数据的节点。

    头节点:在单链表的第一个结点之前附设一个结点,它没有直接前驱,称之为头结点,头结点的数据域可以不存储任何信息,指针域指向第一个节点(首节点)的地址。头结点的作用是使所有链表(包括空表)的头指针非空。

    头指针:指向头节点的指针。

    尾节点:存放最后一个有效数据的节点。

    尾指针:指向尾节点的指针。

    参考资料来源:

    百度百科——链表

    展开全文
  • 浅谈链表的构建,next到底是什么

    千次阅读 多人点赞 2021-06-19 19:47:09
    相信很多同学在学习链表会纠结这个next什么什么能指向下一个数据,下面由博主给大家刨析下next的作用!! #include<stdio.h> #include<stdlib.h> #include<string.h> //这里我们创建一个...

    浅谈链表
    引言:

    相信很多同学在学习链表会纠结这个next是什么为什么能指向下一个数据,下面由博主给大家刨析下next的作用!!

    #include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    //这里我们创建一个结构体
    struct LinkNode
    {
    	int num;
    	//看仔细了,这个next是struct LinkNode*  类型的数据
    	//它可以去指向本身的数据类型
    	struct LinkNode* next;
    };
    void test01()
    {
    	//这里我们动态开辟5个struct LinkNode* 的内存
    	struct LinkNode* node1 = malloc(sizeof(struct LinkNode));
    	struct LinkNode* node2 = malloc(sizeof(struct LinkNode));
    	struct LinkNode* node3 = malloc(sizeof(struct LinkNode));
    	struct LinkNode* node4 = malloc(sizeof(struct LinkNode));
    	struct LinkNode* node5 = malloc(sizeof(struct LinkNode));
    	//分别给这五个struct LinkNode* 的数据域赋值
    	node1->num = 100;
    	node2->num = 200;
    	node3->num = 300;
    	node4->num = 400;
    	node5->num = 500;
    	//我们第一块开辟的内存的指针node1他的指针域指向node2这块内存,node2指针域指向node3,所以说next并不是平白无故指向下一个数据,而是next本身是struct LinkNode* ,它可以指向本身数据类型,你创建一个struct LinkNode*数据,都可以用前一个的指针与next来指向他,就构成了链表
    	node1->next = node2;
    	node2->next = node3;
    	node3->next = node4;
    	node4->next = node5;
    	node5->next = NULL;
    	//创建一个struct LinkNode*的指针指向node1;
    	struct LinkNode* pCurret = NULL;
    	pCurret = node1;
    	//pCurret如果不为NULL就继续循环
    	while (pCurret!=NULL)
    	{
    		//这里读取pCurret的数据域
    		printf("%d\n", pCurret->num);
    		//这里pCurret的指向变为pCurret->next、而由上面代码可知,pCurret->next=node1->next,就是node2,此时pCurret的指向变为node2了
    		pCurret = pCurret->next;
    	}
    	//动态开辟要手动释放,防止内存泄漏
    	free(node1);
    	free(node2);
    	free(node3);
    	free(node4);
    	free(node5);
    	//将指针制空
    	node1 = NULL;
    	node2 = NULL;
    	node3 = NULL;
    	node4 = NULL;
    	node5 = NULL;
    }
    int main()
    {
    	test01();
    	return 0;
    }
    
    展开全文
  • C语言链表详解

    千次阅读 2021-05-19 11:03:26
    本文摘自wikipedia。本文内容是关于:C语言 ... 单链表(单向链表)是链表的一种,其特点是链表的链接方向是单向的,对链表的访问要通过顺序读取从头部开始,如下图所示。本文将结合代码详解C语言链表,单向链表的数据...

    本文摘自wikipedia。本文内容是关于:C语言 链表详解,c语言链表教程。 链表(Linked list)是一种常见的基础数据结构,是一种线性表,但是并不会按线性的顺序存储数据,而是在每一个节点里存到下一个节点的指针(Pointer)。 单链表(单向链表)是链表的一种,其特点是链表的链接方向是单向的,对链表的访问要通过顺序读取从头部开始,如下图所示。

    3f4d24cc006c7c0236b0ffeed6f2c434.png

    本文将结合代码详解C语言链表,单向链表的数据结构可以分为两部分:数据域和指针域,数据域存储数据,指针域指向下一个储存节点的地址,C语言详细代码及注释如下。

    /*线性表的单链表存储结构*/

    typedef struct LNode {

    ElemType data;

    struct LNode * next;

    }

    LNode,

    *LinkList;

    /*带有头结点的单链表的基本操作(12个)*/

    void InitList(LinkList * L) {

    /* 操作结果:构造一个空的线性表L */

    * L = (LinkList) malloc(sizeof(struct LNode));

    /* 产生头结点,并使L指向此头结点 */

    if (!*L)

    /* 存储分配失败 */

    exit(OVERFLOW); ( * L) - >next = NULL;

    /* 指针域为空 */

    }

    void DestroyList(LinkList * L) {

    /* 初始條件:线性表L已存在。操作结果:销毁线性表L */

    LinkList q;

    while ( * L) {

    q = ( * L) - >next;

    free( * L); * L = q;

    }

    }

    void ClearList(LinkList L)

    /* 不改变L */

    {

    /* 初始条件:线性表L已存在。操作结果:将L重置为空表 */

    LinkList p,

    q;

    p = L - >next;

    /* p指向第一个结点 */

    while (p)

    /* 没到表尾 */

    {

    q = p - >next;

    free(p);

    p = q;

    }

    L - >next = NULL;

    /* 头结点指针域为空 */

    }

    Status ListEmpty(LinkList L) {

    /* 初始条件:线性表L已存在。操作结果:若L为空表,则返回TRUE,否则返回FALSE */

    return L - >next == NULL;

    }

    int ListLength(LinkList L) {

    /* 初始条件:线性表L已存在。操作结果:返回L中数据元素个数 */

    int i = 0;

    LinkList p = L - >next;

    /* p指向第一个结点 */

    while (p)

    /* 没到表尾 */

    {

    i++;

    p = p - >next;

    }

    return i;

    }

    Status GetElem(LinkList L, int i, ElemType * e)

    /* 算法2.8 */

    {

    /* L为带头结点的单链表的头指针。当第i个元素存在时,其值赋给e并返回OK,否则返回ERROR */

    int j = 1;

    /* j为计数器 */

    LinkList p = L - >next;

    /* p指向第一个结点 */

    while (p && j < i)

    /* 顺指针向后查找,直到p指向第i个元素或p为空 */

    {

    p = p - >next;

    j++;

    }

    if (!p || j > i)

    /* 第i个元素不存在 */

    return ERROR; * e = p - >data;

    /* 取第i个元素 */

    return OK;

    }

    int LocateElem(LinkList L, ElemType e, Status( * compare)(ElemType, ElemType)) {

    /* 初始条件: 线性表L已存在,compare()是数据元素判定函数(满足为1,否则为0) */

    /* 操作结果: 返回L中第1个与e满足关系compare()的数据元素的位序。 */

    /* 若这样的数据元素不存在,则返回值为0 */

    int i = 0;

    LinkList p = L - >next;

    while (p) {

    i++;

    if (compare(p - >data, e))

    /* 找到这样的数据元素 */

    return i;

    p = p - >next;

    }

    return 0;

    }

    Status PriorElem(LinkList L, ElemType cur_e, ElemType * pre_e) {

    /* 初始条件: 线性表L已存在 */

    /* 操作结果: 若cur_e是L的数据元素,且不是第一个,则用pre_e返回它的前驱, */

    /* 返回OK;否则操作失败,pre_e无定义,返回INFEASIBLE */

    LinkList q,

    p = L - >next;

    /* p指向第一个结点 */

    while (p - >next)

    /* p所指结点有后继 */

    {

    q = p - >next;

    /* q为p的后继 */

    if (q - >data == cur_e) { * pre_e = p - >data;

    return OK;

    }

    p = q;

    /* p向后移 */

    }

    return INFEASIBLE;

    }

    Status NextElem(LinkList L, ElemType cur_e, ElemType * next_e) {

    /* 初始条件:线性表L已存在 */

    /* 操作结果:若cur_e是L的数据元素,且不是最后一个,则用next_e返回它的后继, */

    /* 返回OK;否则操作失败,next_e无定义,返回INFEASIBLE */

    LinkList p = L - >next;

    /* p指向第一个结点 */

    while (p - >next)

    /* p所指结点有后继 */

    {

    if (p - >data == cur_e) { * next_e = p - >next - >data;

    return OK;

    }

    p = p - >next;

    }

    return INFEASIBLE;

    }

    Status ListInsert(LinkList L, int i, ElemType e)

    /* 算法2.9。不改变L */

    {

    /* 在带头结点的单链线性表L中第i个位置之前插入元素e */

    int j = 0;

    LinkList p = L,

    s;

    while (p && j < i - 1)

    /* 寻找第i-1个结点 */

    {

    p = p - >next;

    j++;

    }

    if (!p || j > i - 1)

    /* i小于1或者大于表长 */

    return ERROR;

    s = (LinkList) malloc(sizeof(struct LNode));

    /* 生成新结点 */

    s - >data = e;

    /* 插入L中 */

    s - >next = p - >next;

    p - >next = s;

    return OK;

    }

    Status ListDelete(LinkList L, int i, ElemType * e)

    /* 算法2.10。不改变L */

    {

    /* 在带头结点的单链线性表L中,删除第i个元素,并由e返回其值 */

    int j = 0;

    LinkList p = L,

    q;

    while (p - >next && j < i - 1)

    /* 寻找第i个结点,并令p指向其前岖 */

    {

    p = p - >next;

    j++;

    }

    if (!p - >next || j > i - 1)

    /* 删除位置不合理 */

    return ERROR;

    q = p - >next;

    /* 删除并释放结点 */

    p - >next = q - >next; * e = q - >data;

    free(q);

    return OK;

    }

    void ListTraverse(LinkList L, void( * vi)(ElemType))

    /* vi的形参类型为ElemType,与bo2-1.c中相应函数的形参类型ElemType&不同 */

    {

    /* 初始条件:线性表L已存在。操作结果:依次对L的每个数据元素调用函数vi() */

    LinkList p = L - >next;

    while (p) {

    vi(p - >data);

    p = p - >next;

    }

    printf("

    ");

    }

    展开全文
  • java实现:初识链表

    2021-02-26 08:46:38
    今天来谈谈链表数组与链表分别属于线性表的两种基本存储结构:顺序存储结构和链式存储结构。顺序存储结构:用一段地址连续的存储单元依次存储线性表的数据元素。链式存储结构:地址可以连续也可以不连续的存储单元...

    今天来谈谈链表

    数组与链表分别属于线性表的两种基本存储结构:顺序存储结构和链式存储结构。

    顺序存储结构:用一段地址连续的存储单元依次存储线性表的数据元素。

    链式存储结构:地址可以连续也可以不连续的存储单元存储数据元素。

    链式存储结构包括单链表,双链表,循环链表。

    链表优劣势:使用链表结构可以克服数组链表需要预先知道数据大小的缺点,链表结构可以充分利用计算机内存空间,实现灵活的内存动态管理。但是链表失去了数组随机读取的优点,同时链表由于增加了结点的指针域,空间开销比较大,检索时遍历需要从头开始导致效率低。链表最明显的好处就是,常规数组排列关联项目的方式可能不同于这些数据项目在记忆体或磁盘上顺序,数据的存取往往要在不同的排列顺序中转换。链表允许插入和移除表上任意位置上的节点,但是不允许随机存取。

    单向链表:

    单向链表只有一个指针域,在整个节点中数据域用来存储数据元素,指针域用于指向下一个具有相同结构的节点。

    要实现链表首先定义节点类,有数据域(存储数据,类型自定)+引用域(存储下一个节点,用于节点链接)

    public class Node {

    private Object data;

    private Node next;

    //无参构造 public Node(){

    }

    //有参构造 public Node(Object data){

    this.data = data;

    }

    //获取数据 public Object getData() {

    return data;

    }

    //添加数据 public void setData(Object data) {

    this.data = data;

    }

    //获取下一个节点, public Node getNext() {

    return next;

    }

    //设置下一个节点 public void setNext(Node next) {

    this.next = next;

    }

    }

    接着就可以写链表类来实现链表的功能了

    包括头结点root 与中间的n个数据节点node(包括尾部节点last),主要有几个功能要实现:添加新节点到末尾,添加新节点到指定位置,获取链表大小,获取指定位置的节点数据,移除指定位置的节点

    public class LinkedList {

    //链表的长度

    private int size = 0;

    //链表的头结点,内容为null

    private Node root = new Node(null);

    //链表的尾部:尾插法

    private Node last = root;

    //构造方法,初始化链表

    public LinkedList() {

    }

    /**

    * add()方法:

    * 尾差法:添加新节点到链表的末尾

    * @param data:添加的数据

    */

    public void add(Object data) {

    //创建本node对象的时候初始化数据:data

    Node node = new Node(data);

    //尾差法:添加到链表的末尾

    //设置尾部last的下一个为:node

    last.setNext(node);

    //更新链表尾部last

    last = node;

    //size增加

    size++;

    }

    /**

    * 获取链表大小

    *

    * @return :链表长度

    */

    public int size() {

    return size;

    }

    /**

    * 获取链表第index的数据data

    *

    * @param index :要获取的第i个链表

    * @return :第index的个链表的数据内容

    */

    public Object get(int index) {

    Node node = root.getNext();

    if (index < 0 || index > size) {

    return null;

    }

    for (int i = 0; i < index; i++) {

    node = node.getNext();

    }

    return node.getData();

    }

    /**

    * 移除第index的节点node

    *

    * @param index :第i个

    * @return

    */

    public Object remove(int index) {

    Node node = root.getNext();

    if (index < 0 || index > size) {

    return 0;

    }

    //若要移除的index为第一个node,index为0,不存在index-1,则单独设置

    if (index == 0) {

    //setNext链接上一个和下一个 :上一个为root,下一个为node.getNext()

    root.setNext(node.getNext());

    //清除该节点的引用域为null:next

    node.setNext(null);

    size--;

    }

    //移除的index不为0

    else {

    //获取三个节点:上一个node、这个removenode、下一个nextnode

    //获取要移除node的上一个node

    for (int i = 0; i < index - 1; i++) {

    node = node.getNext();

    }

    // 获取要移除的node

    Node removenode = node.getNext();

    // 获取要移除的下一个node

    Node nextnode = removenode.getNext();

    // setNext链接上一个和下一个:上一个为node,下一个为nextnode

    node.setNext(nextnode);

    //清除该node的引用域为null:next

    removenode.setNext(null);

    size--;

    }

    return 0;

    }

    }

    如果对单链表的操作能够掌握的话,剩下的这几种链表,相信也能很快掌握,只不过把node中的基本数据改一下,增删的时候多一两行代码。

    对于循环链表,你可以想象成y一个闭环的链表。也就是最后一个元素又指向了第一个元素。双向链表每一个节点既指向前驱又指向后继。

    双向链表相对于单链表还是比较复杂的,毕竟每个节点多了一个前驱,因此对于插入和删除要格外小心。双向链表的优点在于对每个节点的相邻接点操作时候,效率会比较高。

    展开全文
  • 对Java实现单链表.next的解释 2

    千次阅读 多人点赞 2021-04-12 11:00:32
    又或是有这种疑惑, Java实现的这种node.next写法是如何移动链表的 A: 首先,Java虽然没有指针但是有引用啊. Java的眼里,万物皆对象,对象之间靠引用关系联系在一起. 在单链表的实现, 我们经常会写一个Node类...
  • 我们知道 mysql 有一个非常重要的内存组件,就是缓冲池(Buffer Pool)。它里面缓存了很多的数据,使得我们在查询和修改数据的时候可以基于内存来操作,极大地提高了执行效率。 当然,缓存池毕竟还是内存,如果...
  • java链表什么

    2021-02-12 18:29:41
    本篇文章将和大家讲述Java链表,感兴趣的朋友可以了解一下。链表是一种根据元素节点逻辑关系排列起来的一种数据结构。利用链表可以保存多个数据,这一点类似于数组的概念。但是数组本身有一个缺点—— 数组的...
  • 链表

    2021-03-04 14:02:13
    什么链表链表是一种通过指针串联在一起的线性结构,每一个节点是由两部分组成,一个是数据域,一个是指针域(存放指向下一个节点的指针),最后一个节点的指针域指向NULL。 1、单链表 链表的入口点称为链表的头...
  • 而对于双循环链表,只需要最后一个元素的next指向head->next,head->next的prior指向最后一个节点即可。插入操作新节点s插入链表,s->next给p结点,s->prior给p->prior,然后,p->prior->next...
  • public class Solution { public boolean hasCycle(ListNode head) { if (head == null){ return false; } ListNode fast = head;...fast = fast.next.next; slow = slow.next; if(fast == slow){ return tr
  • 链表正向遍历和反向遍历、链表排序、判断链表是否有环、是否相交、获取某一结点等。二、概念:链表:一种重要的数据结构,HashMap等集合的底层结构都是链表结构。链表以结点作为存储单元,这些存储单元可以是不连续...
  • p=p->next什么意思

    千次阅读 多人点赞 2021-01-13 14:58:00
    换种说法,如果我们在C语言定义了一个结构体,然后申明一个指针指向这个结构体,那么我们要用指针取出结构体的数据,就要用到“->”. 举个例子: structData { int a,b,c; }; /*定义结构体*/ struct Data * ...
  • temp可以理解为一个指针,一开始将链表头部信息的内容赋给temp ...temp.next就是调用next的信息,只不过next是HeroNode类型的变量(注意temp.next中 next是HeroNode类型的变量),它存储着下一个方块的no,name,ni.
  • //遍历链表,找到最后 while(true) { //找到链表的最后 if(temp.next == null) { break; } //如果没找到最后,将temp后移 temp = temp.next; } //当退出while时,temp就指向了链表的最后
  • 指针可以使C非常容易的操作内存的地址和数据,这比其他高级语言更加灵活方便。Java、C#等面向对象语言,虽然不使用指针,但因为启用了对象引用机制,从某种角度也间接实现了指针的某些作用。但对于其他一些语言,...
  • 它在LinkedList扮演的角色是什么?如果我们尝试打印出this.next,在将它指定为null之前它将为null.System.out.println(this.next);结果为空另外,如果p.next指向新节点,为什么我们需要设置p = p.next指向同一个节点...
  • 如果链表中有某个节点,可以通过连续跟踪 next 指针再次到达,则链表中存在环。 为了表示给定链表中的环,我们使用整数 pos 来表示链表尾连接到链表中的位置(索引从 0 开始)。 如果 pos 是 -1,则在该链表中没有环...
  • 1、链表是一种物理存储单元上非连续、非顺序的存储结构,数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点(链表中每一个元素称为结点)组成,结点可以在运行时动态生成。每个结点包括两个部分...
  • 在一个双链表中,删除p结点之后的一个结点的操作是()。A.p->next=p->next->next;p->next->next->pr更多相关问题造成木枕严重的机械磨损主要原因有()。A、道床积水B、道钉不合要求,出现“八害”道钉C...
  • 如果链表中有某个节点,可以通过连续跟踪 next 指针再次到达,则链表中存在环。 为了表示给定链表中的环,我们使用整数 pos 来表示链表尾连接到链表中的位置(索引从 0 开始)。 如果 pos 是 -1,则在该链表中没有环...
  • 链表(linked list)是一种在物理上非连续、非顺序的数据结构,由若干个节点(node)所组成。 链表分为单向链表和双向链表。...如果说数组在内存的存储方式为顺序存储,那么链表在内存在的存储方式则是随机存储。
  • 从单向链表中删除一个元素 一、题目 从单向链表删除一个元素。 二、基本思想 1、遍历整个链表; 2、找到数据域值等于要删除的元素的节点; 3、将数据域值等于要删除的元素的节点的上一节点的 “next”...
  • 下面总结双向链表与单链表之间的不同之处及我在实现过程所遇到的问题。1.双向链表的建立双向链表在初始化时,要给首尾两个节点分配内存空间。成功分配后,要将首节点的prior指针和尾节点的next指针指向NULL,这是...
  • 如何理解c语言链表

    2021-05-22 18:32:14
    链表可以动态的进行传输分配,也就是说,链表是一个功能极为强大的变量,它可以在结点定义多种数据类别,还可以按照需要轻易增添,删除,插入节点。接下来将在文章中为你们具体介绍C语言链表,希望对你们有所...
  • 1.在链表中查找链表的元素,如果存在该元素,打印有,否则打印没有。 #include <stdio.h> struct Test { int data; struct Test *next; }; void printlink(struct Test *head) { struct Test *point;...
  • 链表概述:链表是一种常见的数据结构。数组可以存放数据,但是使用数组时要先指定数组包含元素的个数,即数组长度。但是如果向这个数组加入的元素个数超过了数组的大小时,便不能将内容完全保存。例如在定义一个...
  • 我们知道在C和C++里有值和地址的概念,所以能轻松构建出链表,那在java又是怎么构建出链表的呢?链表元素在jvm里又是怎么存的呢? 我们知道JVM里有栈区和堆区,栈区主要存引用的,而堆区存的是对象,栈里的引用存...
  • c语言链表: 链表里p->next是怎么指向下一个结点的呢,它是怎么得到下一个结点的地址。。。求详细答案:8信息版本:手机版解决时间 2019-10-06 11:20已解决2019-10-05 14:25c语言链表: 链表里p->next是怎么指向...
  • 在函数不是有q->next=p;这时q是插入前的尾节点。那样q的的下一个(新插入的节点)就由q指向节点里的字段next指向了。单链表的插入只需让s->next 和p->next的指针做一点改变即可。s->next = p->next;...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 512,902
精华内容 205,160
关键字:

链表中的next什么意思