7.C语言终极之链表（静态链表、动态链表）

最新推荐文章于 2022-05-04 20:06:25 发布
最新推荐文章于 2022-05-04 20:06:25 发布
阅读量254 收藏 2
点赞数 1
文章标签： 链表 指针
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47692173/article/details/111874866
版权

C语言终极之链表

链表与数组的区别

数组：顺序存储，大小固定
链表：随机储存，可存放不同类型的结构体数据

数组的特性

#include <stdio.h>
int main()
{
        int array[]={1,2,3,4};
        int i;
        for(i=0;i<sizeof(array)/sizeof(array[0]);i++){
                printf("%d ",array[i]);
        }
        putchar('\n');
        return 0;
}

静态链表

程序A：访问方式（每次以起始节点向后访问）

#include <stdio.h>
struct test
{
        int data;
        struct test *next;
};

int main()
{
        struct test t1 = {1,NULL};
        struct test t2 = {2,NULL};
        struct test t3 = {3,NULL};

        t1.next = &t2;			/
        t2.next = &t3;

        printf("%d %d %d \n",t1.data,t1.next->data,t1.next->next->data);
        //第二个数：进入结构体指针所以要用 “->” ,再指向 data
        return 0;
}

程序B：通过节点地址手动相连关系访问

#include <stdio.h>
struct test
{
        int data;
        struct test *next;
};
void printlink(struct test *head)
{
        struct test *point =head;
        while(1){
                if(point != NULL){				 //不是空指针，输出数值，并地址向后偏移
                        printf("%d ",point->data);	
                        point = point->next;	
                }else{							//指针为空，则跳出程序
                        puchar('\n');	
                        break;
                }
        }
}
int main()
{
        struct test t1 = {1,NULL};
        struct test t2 = {2,NULL};
        struct test t3 = {3,NULL};

        t1.next = &t2;
        t2.next = &t3;

        printlink(&t1);		//通过传递链表首元素的地址
        return 0;
}

静态链表 计算节点个数

#include <stdio.h>
struct test
{
        int data;
        struct test *next;
};
void printlink(struct test *head)
{
        struct test *point =head;
        while(1){
                if(point != NULL){				 //不是空指针，打印数值，并指针向后偏移
                        printf("%d ",point->data);	
                        point = point->next;	
                }else{							//指针为空，则跳出程序
                        putchar('\n');	
                        break;
                }
        }
}
int node_Number(struct test *head)
{
		int num = 0;
		struct test *point = head;
		while(point != NULL){
				++num;					//指针每进入循环一次，+1
				point = point -> next;
		}
		return num;						//返回节点个数
}
int main()
{
        struct test t1 = {1,NULL};
        struct test t2 = {2,NULL};
        struct test t3 = {3,NULL};

        t1.next = &t2;
        t2.next = &t3;

        printlink(&t1);				//通过传递首元素的地址(打印链表)
        
        int ret = node_Number(&t1);		//计算链表个数
        printf("链表的节点个数是%d\n",ret);
		return 0;
}

静态链表 查找节点

#include <stdio.h>
struct test
{
        int data;
        struct test *next;
};
void printlink(struct test *head)
{
        struct test *point =head;
        while(1){
                if(point != NULL){                 //不是空指针，打印数值，并指针向后偏移
                        printf("%d ",point->data);
                        point = point->next;
                }else{  
                        putchar('\n');
                        break;
                }
        }
}
int seek_node(struct test *head,int data)
{
        struct test *point = head;
        while(point != NULL){
                if(point -> data == data){          //链表节点的数值 等于 查找的数值 进行对比
                        return 1;
                }
                point = point -> next;
        }
        return 0;
}
int main()
{
        struct test t1 = {1,NULL};
        struct test t2 = {2,NULL};
        struct test t3 = {3,NULL};

        t1.next = &t2;
        t2.next = &t3;

        printlink(&t1);         		//通过传递首元素的地址（打印链表）
        int ret = seek_node(&t1,2);		//获取seek_node函数的返回值
        if(ret == 1){
                printf("链表中有 1\n");
        }else{
                printf("链表中没 1\n");
        }
        ret = seek_node(&t1,8);
        if(ret == 1){
                printf("链表中有 8\n");
        }else{
                printf("链表中没 8 \n");
        }
        return 0;
}

静态链表从指定节点后方插入新节点

**思路
a.找到指定的节点
b.新节点地址 指向 指定节点的下一个节点地址
c.指定节点的下一个节点地址 指向 新节点 **

#include <stdio.h>
struct test
{
        int data;
        struct test *next;
};
void printlink(struct test *head)
{
        struct test *point =head;
        while(1){
                if(point != NULL){                    //不是空指针，打印数值，并指针向后偏移
                        printf("%d ",point->data);
                        point = point->next;
                }else{                                //指针为空，则跳出程序
                        putchar('\n');
                        break;
                }
        }
}
int Insert_after_node(struct test *head,struct test *new,int data)
{
        struct test *point = head;
        while(point != NULL){
                if(point -> data == data){			// a.找到指定的节点
                        new ->next = point -> next;	// b.新节点地址 指向 指定节点的下一个节点地址
                        point ->next = new;			// c.指定节点的下一个节点地址 指向 新节点 
                        return 1;
                }
                point = point ->next;
        }
        return 0;
}
int main()
{
        struct test t1 = {1,NULL};
        struct test t2 = {2,NULL};
        struct test t3 = {3,NULL};
        struct test t4 = {4,NULL};
        struct test t5 = {5,NULL};
        t1.next = &t2;
        t2.next = &t3;
        t3.next = &t4;
        t4.next = &t5;
        struct test new = {100,NULL};

        printlink(&t1);         //通过传递首元素的地址
        int ret = Insert_after_node(&t1,&new,3);
        if(ret == 1){			//判断是否插入成功
                printf("插入成功\n");
        }else{
                printf("插入失败\n");
        }
        printlink(&t1);         //通过传递首元素的地址
        return 0;
}

静态链表从指定节点前方插入新节点

思路
A. 头节点插入

B.中间以及尾部插入

#include <stdio.h>
struct test
{
        int data;
        struct test *next;
};
void printlink(struct test *head)
{
        struct test *point =head;
        while(1){
                if(point != NULL){                    //不是空指针，打印数值，并指针向后偏移
                        printf("%d ",point->data);
                        point = point->next;
                }else{                                //指针为空，则跳出程序
                        putchar('\n');
                        break;
                }
        }
}
struct test *Insert_front_node(struct test *head,struct test *new,int data)
{
        struct test *point = head;
        if(point -> data == data){				//A. 头节点插入
                new -> next = point;
                return new;						//切记：返回的是新节点头
        }
        while(point -> next != NULL){			//B.中间以及尾部插入
                if(point -> next -> data == data){
                        new ->next = point -> next;
                        point ->next = new;
                        return head;			//切记：需要返回值原节点
                }
                point = point ->next;
        }
        return head;
}
int main()
{
        struct test t1 = {1,NULL};
        struct test t2 = {2,NULL};
        struct test t3 = {3,NULL};
        struct test t4 = {4,NULL};
        struct test t5 = {5,NULL};
        t1.next = &t2;
        t2.next = &t3;
        t3.next = &t4;
        t4.next = &t5;
        struct test new = {100,NULL};

        struct test *head = &t1;
        printlink(head);                //通过传递首元素的地址
        head= Insert_front_node(head,&new,1);   //图一的效果
        printlink(head);               //通过传递首元素的地址
    
      //head= Insert_front_node(head,&new,3);	//图二的效果
      //printlink(head);     
        return 0;
}

图一：在这里插入图片描述
图二：在这里插入图片描述

静态链表删除指定节点

#include <stdio.h>
struct test
{
        int data;
        struct test *next;
};
void printlink(struct test *head)
{
        struct test *point =head;
        while(1){
                if(point != NULL){                  //不是空指针，打印数值，并指针向后偏移
                        printf("%d ",point->data);
                        point = point->next;
                }else{                              //指针为空，则跳出程序
                        putchar('\n');
                        break;
                }
        }
}
struct test *delete_node(struct test *head,int data)
{
        struct test *point = head;
        if(head -> data == data){
                head = head -> next;
                return head;
        }
        while(point -> next != NULL){
                if(point -> next -> data == data){
                        point -> next = point -> next -> next;
                        return head;
                }
                point = point ->next;
        }
}
int main()
{
        struct test t1 = {1,NULL};
        struct test t2 = {2,NULL};
        struct test t3 = {3,NULL};
        struct test t4 = {4,NULL};
        struct test t5 = {5,NULL};
        t1.next = &t2;
        t2.next = &t3;
        t3.next = &t4;
        t4.next = &t5;
        struct test new = {100,NULL};

        struct test *head = &t1;
        printf("原链表的节点：");
        printlink(head);                //通过传递首元素的地址
        head = delete_node(head,1);		//任意修改链表节点
        printf("删除后的链表：");
        printlink(head);                //通过传递首元素的地址
        return 0;
}

在这里插入图片描述

动态链表之头插法（程序A与程序B结果相同，但程序B使用函数分装）

程序A

#include <stdlib.h>
#include <stdio.h>
struct test
{
        int data;
        struct test *next;
};
void printlink(struct test *head)
{
        struct test *point =head;
        while(1){
                if(point != NULL){                    //不是空指针，打印数值，并指针向后偏移
                        printf("%d ",point->data);
                        point = point->next;
                }else{                                    //指针为空，则跳出程序
                        putchar('\n');
                        break;
                }
        }
}
struct test *head_insert(struct test *head)
{
        struct test *new;
        while(1){
                new = (struct test *)malloc(sizeof(struct test));
                printf("请输入新节点：");
                scanf("%d",&(new->data));
                if(new->data ==0){
                        printf("输入0，即将退出程序\n");
                        return head;
                }
                if(head == NULL){			//刚创建链表时，链表为空
                        head = new;			//所以将第一个数表示为链表头
                }else{						//当链表中有数时
                        new -> next= head;	//新节点的地址 指向 节点头
                        head = new;			//新节点为链表头
                }
        }
                return head;
}
int main()
{
        struct test *head = NULL;
        head = head_insert(head);
        printlink(head);                //通过传递首元素的地址
}

程序B

#include <stdlib.h>
#include <stdio.h>
struct test
{
        int data;
        struct test *next;
};
void printlink(struct test *head)
{
        struct test *point =head;
        while(1){
                if(point != NULL){                    //不是空指针，打印数值，并指针向后偏移
                        printf("%d ",point->data);
                        point = point->next;
                }else{                                    //指针为空，则跳出程序
                        putchar('\n');
                        break;
                }
        }
}
struct test *head_insert(struct test *head,struct test *new)	//头插法
{
        if(head == NULL){
                head = new;
        }else{
                new -> next= head;
                head = new;
        }
        return head;
}
struct test *link_create(struct test *head)			//创建链表
{
        struct test *new;
        while(1){
                new = (struct test *)malloc(sizeof(struct test));
                printf("请输入新节点：");
                scanf("%d",&(new->data));
                if(new->data ==0){
                        free(new);
                        printf("输入0，即将退出程序\n");
                        return head;
                }
                head = head_insert(head,new);
        }
}
int main()
{
        struct test *head = NULL;
        head = link_create(head);
        printlink(head);                //通过传递首元素的地址
}

在这里插入图片描述

动态链表之尾插法

include <stdlib.h>
#include <stdio.h>
struct test
{
        int data;
        struct test *next;
};
void printlink(struct test *head)
{
        struct test *point =head;
        while(1){
                if(point != NULL){                               //不是空指针，打印数值，并指针向后偏移
                        printf("%d ",point->data);
                        point = point->next;
                }else{                                                  //指针为空，则跳出程序
                        putchar('\n');
                        break;
                }
        }
}
struct test *tail_insert(struct test *head,struct test *new)		//尾插链表
{
        struct test *point =head;

        if(head == NULL){			//判断链表是否为空
                head = new;			//若为空，则将新节点 为 链表头
                return head;
        }
        while(point -> next != NULL){	//判断链表的下一个是否为空
                point = point -> next;	//若不为空，直至走到链表节点的尾巴
        }								//退出循环
                point -> next = new;  	//将新节点存储到链表尾巴
        return head;
}
struct test *link_create(struct test *head)
{
        struct test *new;
        while(1){
                new = (struct test *)malloc(sizeof(struct test));
                printf("请输入新节点：");
                scanf("%d",&(new->data));
                if(new->data ==0){
                        free(new);
                        printf("输入0，即将退出程序\n");
                        return head;
                }
                head = tail_insert(head,new);
        }
}
int main()
{
        struct test *head = NULL;
        head = link_create(head);
        printlink(head);                //通过传递首元素的地址
}

在这里插入图片描述

鸠鸠不会编程
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
C语言——（静态）链表
m0_69211839的博客
03-02 156
C语言——（静态）链表
C语言---动态链表
qq_45796096的博客
02-01 423
#动态链表 静态链表和动态链表的区别： ##静态链表和动态链表是线性表链式存储结构的两种不同的表示方式 1、静态链表是用类似于数组方法实现的，是顺序的存储结构，在物理地址上是连续的，而且需要预先分配地址空间大小。所以静态链表的初始长度一般是固定的，在做插入和删除操作时不需要移动元素，仅需修改指针。 2、动态链表是用内存申请函数（malloc/new）动态申请内存的，所以在链表的长度上没有限制。动态...
C语言——链表
m0_62386635的博客
11-20 2万+
C语言——链表 链表是一种基础的数据结构类型，一种能够动态维护数据的线性数据表。链表的数据以结点形式存储信息，并通过结点之间的指针实现结点之间的衔接。 为什么要用链表？ 链表和数组类似，但是功能比数组强大得多，数组的空间是固定的，在定义数组的时候，数组的大小已经被固定，在使用时有可能会造成空间的浪费或者面临空间不够的风险，而链表的空间是动态的，则避免了这一问题。 我们来看最基础的单向链表： 1.首先要定义结构体作为链表的结点： typedef struct node { int data; struct
c语言——静态链表和动态链表
e891377的专栏
05-21 294
c语言——静态链表 链表结点类型定义 如何遍历链表 #define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<string.h> #include<stdlib.h> //链表结点类型定义 struct LinkNode { int data; struct LinkNode *next; }; void test() { struct LinkNode node1 = { 10, NULL };
静态链表/动态链表C语言实现
weixin_37515325的博客
03-20 656
静态链表：1.静态链表和动态链表的区别： 静态链表要预先申请一整块足够内存的空间，其能存储的元素个数在创建的那一刻就不能再更改了。 动态链表：之前实现的单链表，双链表，循环链表都属于动态链表，可以在使用过程中动态申请内存。 2.静态链表是一种用数组描述的链表，其实是为了给没有指针的高级语言设计的一种实现单链表功能的方法（大话数据结构）。 3.静态链表其实包括两个链表，一个是数据链表，一个是空闲链表。 3.静态链表的第一个节点和最后一个节点作为特殊元素处理， 第一个节点作为备用链表的表头，其cur...
C语言动态链表经典程序,C语言静态链表和动态链表
weixin_39972996的博客
05-18 194
1. 静态链表结构体中的成员可以是各种类型的指针变量，当一个结构体中有一个或多个成员的基类型是本结构体类型时，则称这种结构体为“引用自身的结构体”。如：struct link{char ch;struct link *p;} a;p是一个可以指向 struct link 类型变量的指针成员。因此，a.p = &a 是合法的表达式，由此构成的存储结构如图1所示。图1 引用自身的结构体例1 一...
数据结构回顾——静态链表操作详解及C语言实现
只要思想不滑坡，想法总比问题多。
08-26 2439
使用静态数组表示的链表称为静态链表。静态链表综合了顺序表和链表的优点，既有高效的查找操作，又能快速增删元素节点。
C语言静态链表和动态链表
09-02
链表是计算机科学中一种重要的数据结构，尤其在C语言中，它被广泛用来处理动态数据集合。链表分为静态链表和动态链表，两者的...在C语言编程中，理解和掌握静态链表与动态链表的原理和使用方法是非常基础且重要的技能。
C语言实现静态链表
08-18
C语言实现静态链表 C语言实现静态链表是指在C语言中使用静态数组来实现链表结构的方法。静态链表是一种特殊的链表结构，它的内存是事先分配好的，链表的每个结点都是一个固定长度的结构体，而不是像动态链表那样...
C_linked_list_data.zip_C语言 链表_链表
09-22
在C语言中，链表不像是数组那样在内存中连续存储元素，而是通过指针连接一系列节点，每个节点包含数据和指向下一个节点的指针。这种数据结构允许高效地插入和删除元素，特别是在动态变化的数据集合中。 链表的每个...
c语言编程题之链表操作设计链表.zip
最新发布
03-30
链表是一种重要的数据结构，在...通过解决此类链表操作的编程题目，你可以深入理解链表数据结构，提高C语言编程能力，同时对动态内存管理和指针操作有更清晰的认识。实践中不断练习，才能更好地掌握这些核心概念。
静态链表C语言实现
qq_54517101的博客
04-29 730
#include "string.h" #include "ctype.h" #include "stdio.h" #include "stdlib.h" #include "math.h" #include "time.h" #define maxlen 1000 typedef struct node { int data; int cur; /* 游标(Cursor) ，为0时表示无指向 */ } node, StaticLinkList[ma.
C语言：静态数组&动态数组
huhuhuhuhuhuha的博客
05-04 5057
无
动态链表和静态链表的实现
qq_36684096的博客
02-22 235
线性表分为顺序表和链表，顺序表可以简单理解成“数组”，而链表又可以划分为动态链表和静态链表。 这里主要讲解动态、静态链表的数据结构和实现。 动态链表 动态链表是通过指针来连接位置的，所以其数据结构应该包含数据域和指针域， 可以定义如下： struct node{ node *next; datatype data; }; 定义完之后，需要创建链表和删除、插入结点下面就要介绍这几个函数，由于链...
静态链表和动态链表的区别
热门推荐
我的博客
10-10 5万+
静态链表和动态链表的区别： 静态链表和动态链表是线性表链式存储结构的两种不同的表示方式。 1、静态链表是用类似于数组方法实现的，是顺序的存储结构，在物理地址上是连续的，而且需要预先分配地址空间大小。所以静态链表的初始长度一般是固定的，在做插入和删除操作时不需要移动元素，仅需修改指针。 2、动态链表是用内存申请函数（malloc/new）动态申请内存的，所以在链表的长度上没有限制。动态链表
【C语言】动态链表和静态链表的创建
奇峰小筑
05-02 2518
动态链表和静态链表 #include #include #include struct wep{ //char name[16]; int pwt; float price; struct wep *next; }; /** 创建动态链表 **/ struct wep * create(){ struct wep *p1,*p2,*head; int n = 0; p1 = p2
静态链表和动态链表 区别
微电子学与固体电子学-俞驰
07-06 416
使用C语言描述静态链表和动态链表 静态链表和动态链表是线性表链式存储结构的两种不同的表示方式。 静态链表的初始长度一般是固定的，在做插入和删除操作时不需要移动元素，仅需修改指针，故仍具有链式存储结构的主要优点。 动态链表是相对于静态链表而言的，一般地，在描述线性表的链式存储结构时如果没有特别说明即默认描述的是动态链表。 下面给出它们的简单实现，关于线性表更为详尽的C语言的实现，可以参考http://www.cnblogs.com/choon/p/3876606.html 静态链表 .
使用C语言描述静态链表和动态链表
α-geek的专栏
10-09 882
原文  http://www.cnblogs.com/choon/p/3915706.html 静态链表和动态链表是线性表链式存储结构的两种不同的表示方式。 静态链表的初始长度一般是固定的，在做插入和删除操作时不需要移动元素，仅需修改指针，故仍具有链式存储结构的主要优点。 动态链表是相对于静态链表而言的，一般地，在描述线性表的链式存储结构时如果没有特别说明即默认描述的是动态链
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值