静态链表常用操作（节点计数/查找/增加/删除）

最新推荐文章于 2023-08-08 21:16:50 发布
最新推荐文章于 2023-08-08 21:16:50 发布
阅读量651 收藏 2
点赞数
文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lzh201864031/article/details/130010475
版权

1.封装计算链表节点个数的API

代码心得：

  1. cnt是count的缩写，用来计数。
  2. 节点，我们一般指的是链表中数据的地址（指针）。比如节点1就是第一个结构体的地址，节点2就是第2个结构体的地址，以此类推。
  3. 函数接收链表头以后，再修改head指向，看起来有点奇怪（实际上没什么问题，因为main函数中的head不会变），最好养成习惯，在函数中另外定义一个代表节点的结构体指针p保存head的值，让p去移动。

1、计算链表节点个数：

  1. 思路： 
    f1. 封装计算链表节点个数的API: int getLinkNodeNum(struct Test *head); 形参head用来接收链表头
	f1.1 while，控制循环的变量是链表头head，当head!=NULL 时，进入循环
    //内在逻辑：当结构体指针head不等于NULL时，说明没有访问到链表尾巴的后面
    	f1.1.1 修改代表节点个数的变量cnt: cnt++;  //注意一开始要将cnt初始化成0
        f1.1.2 修改代表节点的循环变量head，让head往后走: head = head->next;
	f1.2 返回代表节点个数的变量cnt

  2. 代码： 
    #include <stdio.h>
struct Test
{
    int idata;
    struct Test *next;
};
int getLinkNodeNum(struct Test *head);
int main(int argc, char const *argv[])
{
    int cnt = 0;
    struct Test t1 = {1,NULL};
    struct Test t2 = {2,NULL}; 
    struct Test t3 = {3,NULL};
    struct Test t4 = {4,NULL};
    t1.next = &t2;                 
    t2.next = &t3; 
    t3.next = &t4; 
    cnt = getLinkNodeNum(&t1);
    printf("node numbers: %d\n", cnt);
    return 0;
}
int getLinkNodeNum(struct Test *head) 
{
    int cnt = 0;
    while(head != NULL){
        cnt++;
        head = head->next;
    }
    return cnt;
}

2.封装链表查找的API

  1. 思路： 
    f1. 封装链表查找的API: int searchLink(struct Test *head, int idata); 
形参head用来接收链表头，形参idata是想要找的整型数据
	f1.1 while，控制循环的变量是链表头head，当head!=NULL 时，进入循环
    //内在逻辑：当结构体指针head不等于NULL时，说明没有访问到链表尾巴的后面
    	f1.1.1 通过结构体指针间接访问成员变量idata，判断head->idata是否等于idata
        	f1.1.1.1 如果是，
            			那么，返回1
    	f1.1.2 修改代表节点的循环变量head，让head往后走: head = head->next;
	f1.2 返回0
    //内在逻辑：如果顺利通过f1.1，说明没有提前退出循环，也就是没找到idata

  2. 代码： 
    #include <stdio.h>
struct Test
{
    int idata;
    struct Test *next;
};
int searchLink(struct Test *head, int idata);
int main(int argc, char const *argv[])
{
    struct Test t1 = {1,NULL};
    struct Test t2 = {2,NULL}; 
    struct Test t3 = {3,NULL};
    struct Test t4 = {4,NULL};
    t1.next = &t2;                 
    t2.next = &t3; 
    t3.next = &t4; 
    if(searchLink(&t1, 5)){
        puts("找到了");
    }else{
        puts("没找到");
    }
    return 0;
}
int searchLink(struct Test *head, int idata)
{
    while(head != NULL){
        if(head->idata == idata){
            return 1;
        }
        head = head->next;
    }
    return 0;
}

3.封装链表中插入新节点的API

代码心得：

  1. 我们如何表示链表中的数据（结构体）是第几个节点呢？其实可以在结构体中定义一个代表当前节点位置的成员变量，不妨叫做node。
  2. 插入前，新插入的节点new的指向要设置成NULL，因为我们不知道这个链表数据的后面是什么，如果选择在链表末尾那个数据后面插入节点new的话，那么节点new就成为了链表的末尾，因此NULL是必须的。
  3. 如果有必要修改main函数中的链表头head的指向，也就是修改指针head的值，我们之前讲过，有两种思路，一是用指针函数返回一个结构体指针，二是传递&head后在函数中用结构体二级指针修改head的值。我们推荐用前一种，不容易出错。
  4. 初始化链表的时候，可以提前定义一个结构体指针变量head表示链表头，在链表创建完毕后令head=&t1
  5. 以下两种插入方法，只要是正常插入（不涉及链表头的改变），成功插入新节点new后，p->next立马就变成了new，因此成功插入后最好直接退出while循环，不要让p往后移动了，防止死循环（见f1.2、f1.3）。

知识点：插入新节点有两种方式，每种方式中修改节点指向时，需要注意赋值的顺序

  1. 节点后插入：以在节点3后方插入新节点New为例，必须要让原先节点3和节点4之间的连线最后断掉。
    1. 找到节点3
    2. 让节点New先指向节点3原先的指向，也就是节点4
    3. 让节点3指向节点New，断开3与4的连接
    4. 依次修改new节点后面节点的节点位置标志node（必要的话）
  2. 节点前插入：要考虑插入的是否是第一个节点之前。①如果在第一个节点之前插入新节点，那么链表头会发生变化，体现在main函数中的head的指向发生变化。②如果不是在第一个节点之前插入，那么不需要修改链表头，以在节点4前方插入新节点New为例，这里要注意：不能等到节点p移到4的位置才插入，而是需要通过节点3找节点4，因为我们需要修改节点3的指向，所以这部分代码和在节点后插入类似。

 

1、节点后插入的方式：

  1. 思路： 
    f1. 封装在链表某节点后插入新节点的API: 
int inserFromBehind(struct Test *head, int nodePosition, struct Test *new); 
形参head用来接收链表头，形参nodePosition代表想要在第几个节点后插入，形参new代表新节点
	f1.1 新定义一个代表节点的结构体指针变量p，用来保存链表头head
	f1.2 while循环，控制循环的变量是链表头p，当p!=NULL 时，进入循环，找出位置插入新节点new
    //内在逻辑：当结构体指针head不等于NULL时，说明没有访问到链表尾巴的后面
    	f1.2.1 通过结构体指针间接访问成员变量node(node代表当前第几个节点)，
        判断 p->node 是否等于nodePosition
        	f1.2.1.1 如果是，
            	f1.2.1.1.1 修改代表找到设定节点位置nodePosition的变量flag: flag = 1;
				//内在逻辑：用flag=1代表找到了位置插入，flag=0代表没有找到位置插入，可以初始化成0
				f1.2.1.1.2 让节点new先指向节点p原先的指向: new->next = p->next;
				f1.2.1.1.3 让节点p指向节点new，断开节点p和它原先后面节点的连接
               	f1.2.1.1.4 修改节点new中的成员node: new->node = nodePosition + 1;
				//内在逻辑：找到可插入位置并插入后，把代表节点编号的node成员变量修改一下
				f1.2.1.1.5 插入成功后，提前退出循环，不急着退出函数，一会来改后面节点的node
            f1.2.1.2 修改代表节点的循环变量p，让p往后走: p = p->next;
    f1.3 判断代表找到设定节点位置nodePosition的变量flag是否等于1
    //内在逻辑：插入成功后，在return 1之前，修改新插入节点后面节点的节点位置标志node，让它们加1。
    	f1.3.1 如果是，接下来让new节点后面的节点中的node成员变量自增1
        	f1.3.1.1 修改代表节点的变量p，让p往后走: p = p->next;
			f1.3.1.2 修改代表节点的变量p，让p往后走: p = p->next;
			//内在逻辑：两次往后走是因为想跳过新插入的节点
			f1.3.1.3 while循环，控制循环的变量p，当p!=NULL 时，进入循环
            	f1.3.1.3.1 修改循环变量p中的node成员变量，自增1: p->node = p->node + 1;
				f1.3.1.3.2 修改代表节点的循环变量p，让p往后走: p = p->next;
			f1.3.1.4 修改完毕，返回1，结束函数。
		f1.3.2 否则，代表插入失败（比如新节点插入的位置输入的过大）
        	那么，返回0

  2. 代码： 
    #include <stdio.h>
struct Test
{
    int node;
    struct Test *next;
};
void printLink(struct Test *head);
int inserFromBehind(struct Test *head, int nodePosition, struct Test *new);
int main(int argc, char const *argv[])
{
    struct Test t1 = {1,NULL};
    struct Test t2 = {2,NULL}; 
    struct Test t3 = {3,NULL};
    struct Test t4 = {4,NULL};
    t1.next = &t2;                 
    t2.next = &t3; 
    t3.next = &t4; 
    struct Test new = {0,NULL};					//新插入的节点new的指向要设置成NULL
    int nodePosition;
    puts("插入新节点以前");
    printLink(&t1);
    puts("请输入在哪个节点后插入新节点");
    scanf("%d", &nodePosition);
    inserFromBehind(&t1, nodePosition, &new);
    puts("插入新节点以后");
    printLink(&t1);
    return 0;
}
void printLink(struct Test *head) 
{
    while(head != NULL){
        printf("%d ", head->node);
        head = head->next;
    }
    putchar('\n');
}
int inserFromBehind(struct Test *head, int nodePosition, struct Test *new)
{
    struct Test *p = head;
    int flag = 0;
    while(p != NULL){
        if(p->node == nodePosition){
            flag = 1;
            new->next = p->next;
            p->next = new;
            new->node = nodePosition + 1;
            break;
        }
        p = p->next;
    }
    if(flag == 1){
        p = p->next;
        p = p->next;
        while(p != NULL){
            p->node = p->node + 1;
            p = p->next;
        }
        return 1;
    }else{
        return 0;
    }
}

2、节点前插入的方式：

  1. 思路： 
    f1. 封装在链表某节点前插入新节点的API: 
struct Test* inserFromFront(struct Test *head, int nodePosition, struct Test *new); 
形参head用来接收链表头，形参nodePosition代表想要在第几个节点前插入，形参new代表新节点，
返回值是结构体指针，用来修改main函数的链表头head
	f1.1 新定义一个代表节点的结构体指针变量p，用来保存链表头head
    f1.2 判断是否要在第一个节点前插入新节点，
    	f1.2.1 如果是，说明链表头需要改动
        	f1.2.1.1 让新节点指向旧链表头，让节点new成为新链表头: new->next = head;
			f1.2.1.2 修改节点new的node为1: new->node = 1;
			f1.2.1.3 while循环，控制循环的变量p，当p!=NULL 时，进入循环，把后面所有节点的node+1
                f1.2.1.3.1 从节点p开始，也就是从旧链表头开始，修改node: p->node = p->node + 1;
				f1.2.1.3.2 修改代表节点的循环变量p，让p往后走: p = p->next;
			f1.2.1.4 返回new节点，提前结束函数: return new;
	f1.3 while循环，控制循环的变量是链表头p，当p->next!=NULL 时，进入循环，找出位置插入新节点new
    //内在逻辑1：如果跳过了f1.2，那么说明不用修改链表头，接下来就正常插入
    //内在逻辑2：因为我们希望通过设定节点的上一个节点来找设定节点，不能等到p移到设定节点的位置才插入
    	f1.3.1 通过前一个节点访问后一个节点的node，判断 p->next->node 是否等于nodePosition
        	f1.3.1.1 如果是，
            	f1.3.1.1.1 修改代表找到设定节点位置nodePosition的变量flag: flag = 1;
				//内在逻辑：用flag=1代表找到了位置插入，flag=0代表没有找到位置插入，flag初始化成0
				f1.3.1.1.2 让节点new先指向节点p原先的指向: new->next = p->next;
				f1.3.1.1.3 让节点p指向节点new，断开节点p和它原先后面节点的连接: p->next = new;
               	f1.3.1.1.4 修改节点new的node: new->node = nodePosition;
				//内在逻辑：找到可插入位置并插入后，把代表节点编号的node成员变量修改一下
				f1.3.1.1.5 插入成功后，提前退出循环，不急着退出函数，一会来改后面节点的node
            f1.3.1.2 修改代表节点的循环变量p，让p往后走: p = p->next;
    f1.4 判断代表找到设定节点位置nodePosition的变量flag是否等于1
    //内在逻辑：插入成功后，在return head之前，修改新插入节点后面节点的node，让它们加1。
    	f1.4.1 如果是，接下来让new节点后面的节点中的node成员变量自增1
        	f1.4.1.1 修改代表节点的变量p，让p往后走: p = p->next;
			f1.4.1.2 修改代表节点的变量p，让p往后走: p = p->next;
			//内在逻辑：两次往后走是因为想跳过新插入的节点
			f1.4.1.3 while循环，控制循环的变量p，当p!=NULL 时，进入循环
            	f1.4.1.3.1 修改循环变量p中的node成员变量，自增1: p->node = p->node + 1;
				f1.4.1.3.2 修改代表节点的循环变量p，让p往后走: p = p->next;
			f1.4.1.4 修改完毕，返回head，结束函数。
            //内在逻辑，不需要修改链表头时，直接返回原先的链表头即可
		f1.4.2 否则，代表插入失败（比如新节点插入的位置输入的过大）
        	那么，返回head
           	//内在逻辑：即使插入失败，我们也不希望链表头发生改变

  2. 代码： 
    #include <stdio.h>
struct Test
{
    int node;
    struct Test *next;
};
void printLink(struct Test *head);
struct Test* inserFromFront(struct Test *head, int nodePosition, struct Test *new);
int main(int argc, char const *argv[])
{
    struct Test *head;
    struct Test t1 = {1,NULL};
    struct Test t2 = {2,NULL}; 
    struct Test t3 = {3,NULL};
    struct Test t4 = {4,NULL};
    t1.next = &t2;                 
    t2.next = &t3; 
    t3.next = &t4; 
    head = &t1;
    struct Test new = {0,NULL};
    int nodePosition;
    puts("插入新节点以前");
    printLink(head);
    puts("请输入在哪个节点前插入新节点");
    scanf("%d", &nodePosition);
    head = inserFromFront(head, nodePosition, &new); 
    puts("插入新节点以后");
    printLink(head);
    return 0;
}
void printLink(struct Test *head) 
{ 
    while(head != NULL){
        printf("%d ", head->node);
        head = head->next;
    }
    putchar('\n');
}
struct Test* inserFromFront(struct Test *head, int nodePosition, struct Test *new)
{
    int flag = 0;
    struct Test *p = head;
    if(nodePosition == 1){
        new->next = head;
        new->node = 1;
        while(p != NULL){
            p->node = p->node + 1;
            p = p->next;    
        }
        return new;
    }
    while(p->next != NULL){
        if(p->next->node == nodePosition){
            flag = 1;
            new->next = p->next;
            p->next = new;
            new->node = nodePosition;
            break;
        }  
        p = p->next;
    }
    if(flag == 1){
        p = p->next;
        p = p->next;
        while(p != NULL){
            p->node = p->node + 1;
            p = p->next;
        }
        return head;
    }else{
        puts("插入失败");
        return head;
    }
}

4.封装删除静态链表节点的API

代码心得：

  1. 我们现在所讲的删除链表节点的方法，不涉及到释放被删除节点的内存空间，因为目前我们学习到的链表的内存是静态分配的。我们将在第3节（链表动态创建）中去完善删除节点的代码。

知识点：

  1. 删除节点时，要考虑删除的是否是第一个节点。①如果删除第一个节点，那么链表头会发生变化，体现在main函数中的head的指向发生变化。②如果删除的不是第一个节点，那么不需要修改链表头，以删除节点4为例，这里要注意：不能等到节点p移到4的位置才进行删除，而是需要通过节点3找节点4，因为我们需要修改节点3的指向（绕过节点4，指向节点5）。

 

1、删除链表节点的方式：

  1. 思路： 
    f1. 封装删除静态链表某节点的API: struct Test* delNode(struct Test *head, int nodePosition);
形参head用来接收链表头，形参nodePosition代表想要删除第几个，
返回值是结构体指针，用来修改main函数的链表头head
	f1.1 新定义一个代表节点的结构体指针变量p，用来保存链表头head
    f1.2 判断是否删除的是第1个节点
    	f1.2.1 如果是，说明链表头需要改动
        	f1.2.1.1 修改链表头的指向，让head指向节点2: head = head->next;
			f1.2.1.2 将节点p移动到新链表头，接下来准备修改往后各个节点的node: p = head;
			f1.2.1.3 while循环，控制循环的变量p，当p!=NULL 时，进入循环，把后面所有节点的node-1
                f1.2.1.3.1 从节点p开始，也就是从新链表头开始，修改node: p->node = p->node - 1;
				f1.2.1.3.2 修改代表节点的循环变量p，让p往后走: p = p->next;
			f1.2.1.4 返回节点head，提前结束函数: return new;
	f1.3 while循环，控制循环的变量是链表头p，当p->next!=NULL 时，进入循环，找出位置插入新节点new
    //内在逻辑1：如果跳过了f1.2，那么说明不用修改链表头，接下来就正常删除
    //内在逻辑2：因为我们希望通过设定节点的上一个节点来找设定节点，不能等到p移到设定节点的位置才删除
    	f1.3.1 通过前一个节点访问后一个节点的node，判断 p->next->node 是否等于nodePosition
        	f1.3.1.1 如果是，
            	f1.3.1.1.1 修改代表找到设定节点位置nodePosition的变量flag: flag = 1;
				//内在逻辑：用flag=1代表找到了位置删除，flag=0代表没有找到位置删除，flag初始化成0
				f1.3.1.1.2 让节点p指向设定删除节点的后一个节点，断开节点p和它原先后面节点的连接: 
					p->next = p->next->next;
				f1.3.1.1.3 删除成功后，提前退出循环，不急着退出函数，一会来改后面节点的node
            f1.3.1.2 修改代表节点的循环变量p，让p往后走: p = p->next;
    f1.4 判断代表找到设定节点位置nodePosition的变量flag是否等于1
    //内在逻辑：删除成功后，在return head之前，修改被删除节点后面节点的node，让它们减1。
    	f1.4.1 如果是，接下来让被删节点后面的节点中的node成员变量自减1
        	f1.4.1.1 修改代表节点的变量p，让p往后走: p = p->next;
			//内在逻辑：比如说删除节点4之后，那么就从节点3跳到节点5，从原先的节点5位置开始修改node
			f1.4.1.2 while循环，控制循环的变量p，当p!=NULL 时，进入循环
            	f1.4.1.3.1 修改循环变量p中的node成员变量，自减1: p->node = p->node - 1;
				f1.4.1.3.2 修改代表节点的循环变量p，让p往后走: p = p->next;
			f1.4.1.4 修改完毕，返回head，结束函数。
            //内在逻辑，不需要修改链表头时，直接返回原先的链表头即可
		f1.4.2 否则，代表删除失败（比如被删节点的位置输入的过大）
        	那么，返回head
           	//内在逻辑：即使删除失败，我们也不希望链表头发生改变

  2. 代码： 
    #include <stdio.h>
struct Test
{
    int node;
    struct Test *next;
};
void printLink(struct Test *head);
struct Test* delNode(struct Test *head, int nodePosition);
int main(int argc, char const *argv[])
{
    struct Test *head;
    struct Test t1 = {1,NULL};
    struct Test t2 = {2,NULL}; 
    struct Test t3 = {3,NULL};
    struct Test t4 = {4,NULL};
    t1.next = &t2;                 
    t2.next = &t3; 
    t3.next = &t4; 
    head = &t1;
    int nodePosition;
    puts("删除节点以前");
    printLink(head);
    puts("请输入删除哪个节点");
    scanf("%d", &nodePosition);
    head = delNode(head, nodePosition); 
    puts("删除节点以后");
    printLink(head);
    return 0;
}
void printLink(struct Test *head) 
{ 
    while(head != NULL){
        printf("%d ", head->node);
        head = head->next;
    }
    putchar('\n');
}
struct Test* delNode(struct Test *head, int nodePosition)
{
    int flag = 0;
    struct Test *p = head;
    if(nodePosition == 1){
        head = head->next;
        p = head;
        while(p != NULL){
            p->node = p->node - 1;
            p = p->next;
        }
        return head;
    }
    while(p->next != NULL){
        if(p->next->node == nodePosition){
            flag = 1;
            p->next = p->next->next;
            break;
        }
        p = p->next;
    }
    if(flag == 1){
        p = p->next;
        while(p != NULL){
            p->node = p->node - 1;
            p = p->next;
        }
        return head;
    }else{
        puts("删除失败");
        return head;
    }
}

lzh201864031
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
c++ 链表应用 链表类源代码 原创
12-07
在这个主题中，我们主要讨论的是链表的应用，以及一个原创的C++链表类实现，包括了对链表的各种操作，如插入、删除、查找、长度计算、显示、比较、翻转、连接、迭代、拷贝和赋值等。 1. **链表的插入**：在链表中...
静态链表的插入，增添和删除
lmxinei的博客
04-06 437
【代码】静态链表的插入，增添和删除。
静态链表实现及其插入与删除操作
ccjjjjdff的博客
02-09 2708
静态链表介绍 静态链表，也是线性存储结构的一种，它兼顾了顺序表和链表的优点于一身，其如构造线性表的操作需要预先分配一个大的空间，每个节点存储元素值以及游标代替指针指示下一个节点在数组中的相对位置。 其在线性表中进行插入和删除操作时不需要移动元素，仅需修改指针的值，因此其具有链式结构的优点。 例如，使用静态链表存储 {1,2,3} 的过程如下： （1）创建一个足够大的数组，假设大小为 6，如图 所示： （2）在将数据存放到数组中时，给各个数据元素配备一个整形变量，此变量用于指明各个元素的直接后继元素所在数
【数据结构与算法】不带头节点静态链表的插入和删除算法
知识虔诚的信徒，探索所有未知是信徒毕生的信仰
04-06 2174
无表头的静态链表也能实现插入和删除算法？当然！
统计链表元素个数
qq_62759433的博客
10-16 878
统计链表元素个数
删除整个链表的方法
qq_62846665的博客
08-31 2022
删除整个链表的方法
Go、Rust实现常用数据结构和算法。.zip
最新发布
06-17
- **枚举（Enums）和模式匹配**: 枚举可以模拟多种数据结构，如链表节点，模式匹配则提供了一种优雅处理不同情况的方式。 - **Box与Vec**: Box用于在堆上分配对象，Vec是动态大小的数组，支持动态增长。 - **...
线性表的操作
12-06
- 删除末尾元素：数组中直接减少元素计数，链表中断开尾部节点的链接。在C++中，链表的删除操作通常更高效，因为它不需要移动元素。 - 删除指定位置元素：数组需要将删除位置之后的所有元素向前移动一位，链表则只...
Sequence_and_list:序列和列表操作DS
03-20
6. **查找与计数**：`find()`函数可以找到特定元素的位置，`count()`返回元素出现的次数。例如，`auto pos = myList.find(2); if(pos != myList.end()) std::cout *pos ;` 7. **容量管理**：`size()`返回列表的元素...
CircularLinkedList（循环链表）
11-06
- 插入和删除操作相对于数组或静态链表较慢，因为需要调整多个指针。 - 需要额外的内存空间存储指针。 - 不支持随机访问，只能顺序访问。 **五、应用场景** 1. **队列**：循环链表常被用作循环队列的基础，当队列...
【链表】静态链表的基础操作
lxylxylxy的博客
11-12 912
用顺序表模拟链表。完成初始化，插入，删除等操作
静态链表详解
hibugs
07-18 9001
静态链表是分配一整片连续的内存空间，各个结点集中安置，而不是像单链表那样，每个结点在内存中分散存储。如上如的存储方式，优点类似于顺序表，但是在这一整片连续的内存空间中，元素不是按照顺序存储的。而是可以打乱顺序存储，这时候就需要将结点分为两个部分，一个部分存储数据元素，另一个部分存储下一个结点所在的下标(称其为游标)，比如头结点存放的下标(游标)为2，代表在2的位置上是静态链表的第一个真正存放数据的结点。addr+8*2（这里假设数据元素和游标的大小都为4B）。//数组a作为静态链表}}...
数据结构之静态链表
m0_64365419的博客
08-20 1万+
静态链表：分配一整片连续的内存空间，各个结点集中安置，逻辑结构上相邻的数据元素，存储在指定的一块内存空间中，数据元素只允许在这块内存空间中随机存放，这样的存储结构生成的链表称为静态链表。也就是说静态链表是用数组来实现链式存储结构，静态链表实际上就是一个结构体数组举例：通过a[1]中存放的游标变量3可找到存放的数据元素5的后继元素为3，再通过a[3]中存放的游标变量2可找到存放数据元素3的后继数据为2，以此类推，直到某元素的游标变量为0即可停止（注：a[0]为头结点不存储数据元素）
数据结构回顾——静态链表操作详解及C语言实现
只要思想不滑坡，想法总比问题多。
08-26 2386
使用静态数组表示的链表称为静态链表。静态链表综合了顺序表和链表的优点，既有高效的查找操作，又能快速增删元素节点。
静态链表的 增，删，改，查
qq_57524313的博客
08-08 192
链表是一个由 节点组成的集合。这里的每一个节点都是一个结构体。链表里面 节点与节点之间的内存空间是不一定连续的，很大概率是分散的。为了构成我们想要的链表，我们需要在 结构体里面 声明一个结构体指针。这个结构体指针，用来保存下一个节点的地址。以此类推，我们就可以得到我们想要得链表了。下面我将用几何图形来表示链表，这样或许就更好理解些许了。首先我们先定义一个结构体。这个结构体里面有两种 属性 一个是整型 一个是结构体指针。这里记住，结构体 就是链表 里面的节点。
静态链表相关概念及其操作
qq_38158479的博客
01-17 364
静态链表结构 首先我们先来看看静态链表的结构定义 typedef struct{ ElemType data; int cur; }Component,StaticLinkList[MAXSIZE]; 如上面代码所示，静态链表需要预先分配容量为MAXSIZE的存储空间（接下来以MAXSIZE值为5进行演示），data定义了数据元素，cur定义了数据元素的游标（可以理解为指向下一节点的...
静态链表的理解及基本操作
皮卡qiu~的博客
05-27 3277
一、静态链表的由来 某些高级语言里面并没有指针，只有数组，静态链表就是利用数组来实现类似链表的操作 二、如何建立静态链表 1.要分配足够大的内存，用来存放变量，内存大小记为MAXSIZE； 2.内存不仅要存放数据，而且要存放' 指针 '，把它称为游标，满足这一条件的变量类型是结构体，其定义如下： typedef struct{ ElemType data; int c...
【数据结构】静态链表的定义和操作
Jacky_Feng的博客
09-13 1103
文章目录 一、静态链表的定义 二、静态链表的插入和删除操作 前言 单链表实现的一个很大的作用来源于指针，但如果没有指针之前，该如何来描述单链表呢？有人提出用数组来代替指针，来描述单链表。接下来就看看它是如何实现的？ 一、静态链表的定义 用数组来存放元素的值和地址。由于数组元素的个数一旦确定就不会改变，因而称这种链表为静态链表。 数组元素由两部分组成：data和cur。数据域data，用来存放数据元素（要处理的数据）；游标cur相当于单链表的next指针，存放该元素的后继在数组中的下标。.
链表的删除操作
热门推荐
Joaquin233的博客
12-12 1万+
小甲鱼链表删除 实现链表的输出： 首先要知道链表第一个结点的地址，也就是要知道head的值。 然后设一个指针变量p，先指向第一个结点，输出p所指的结点，然后使p后移一个结点，再输出，直到链表的危结点。 如此我们得到这样的流程图： 对链表的删除操作： 从一个动态链表中删去一个结点，并不是真正从内存中把它抹掉，而是把它从链表中分离开来，只要撤销原来的链接关系即可。如图： 链表删除练习： 题目：写一函数以删除动态链表中指定的结点。 解题思路： 1、从p指向的第一个结点开始，检查该结点中的num值是否等于输入的
C/C++笔试题目常见题目
11-13
这是因为我们需要遍历整个链表，对每个节点进行操作。 除了上述的遍历法之外，还有其他的方法可以实现链表的反转。一种常用的方法是递归法。递归法的基本思想是将问题划分为一个较小的子问题和一个较大的子问题。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值