C语言--链表（静态、动态）& 链表合并练习

最新推荐文章于 2024-04-29 21:26:00 发布
最新推荐文章于 2024-04-29 21:26:00 发布
阅读量261 收藏 4
点赞数 1
分类专栏： C语言 链表 文章标签： c语言 链表 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aoteman_web/article/details/120809166
版权

1.1 概念

链表是由一系列节点组成的，每个节点包含两个域，一个域是数据域，数据域用来保存数据；另一个是指针域，保存下一个节点的地址，链表在内存中是非连续的。

1.2 特点

链表在指定位置插入和删除不需要移动元素，只需要修改指针即可。

查找效率相对于数组会低一些。

链表相对于数组来讲，多了指针域空间开销。

拿到链表的第一个节点，就相当于拿到整个链表

1.3 分类

1.3.1 分类方式一

  • 静态链表

    所有结点都是在程序中定义的，不是临时开辟的，也不能用完后释放，这种链表成为“静态链表”。

    代码示例：

    #include<stdio.h>
#include<stdlib.h>
#include<string.h>

// 链表结点类型定义
struct linkNode{
    int data;
    struct linkNode *next;
};

void test(){
    struct linkNode node1 = {10, NULL};
    struct linkNode node2 = {20, NULL};
    struct linkNode node3 = {30, NULL};
    struct linkNode node4 = {40, NULL};
    struct linkNode node5 = {50, NULL};
    struct linkNode node6 = {60, NULL};
    
    // 将链表串连起来
    node1.next = &node2;
    node2.next = &node3;
    node3.next = &node4;
    node4.next = &node5;
    node5.next = &node6;
    
    // 遍历链表
    // 先定义一个辅助指针变量
    struct linkNode *pCurrent = &node1;
    while(pCurrent != NULL){
        printf("%d ",pCurrent->data);
        // 指针移动到下一个元素的首地址
        pCurrent = pCurrent->next;
    }
}

int main(){
    test();
    return 0;
}

  • 动态链表（创建、遍历、插入、清空、删除、销毁）

        所谓“动态链表”，是指在程序执行过程中从无到有地建立起一个链表，即一个一个地开辟结    点和输入各结点数据，并建立起前后相继的关系

   代码示例：

   头文件：LinkList.h

// 定义数据结构
#define _CRT_SECURE_NO_WARNINGS
​
#pragma once  // 防止头文件重复包含
#include<stdlib.h>
#include<malloc.h>
#include<stdio.h>
​
 // 定义宏
#ifdef __cplusplus
extern "C"{
#endif
​
    // 定义结点数据类型
    struct LinkNode{
        int data;
        struct LinkNode *next;
    };
​
    // 初始化链表
    struct LinkNode *Init_LinkList();
    // 在值为oldval的地方插入一个新值newval，原数据往后挪
    void InsertByValue_LinkList(struct LinkNode *header,int oldval,int newval);     // 通过值来插入数据(链表，旧值，新值)
    // 删除值为val的结点    
    void RemoveByValue_LinkList(struct LinkNode *header,int delval);    // 传入链表和要删除的值
    // 遍历
    void Foreach_LinkList(struct LinkNode *header);
    // 销毁链表（无法插入数据）
    void Destory_LinkList(struct LinkNode *header);
    // 清空（还能插入数据）
    void Clear_LinkList(struct LinkNode *header);
​
#ifdef __cplusplus
}
#endif

LinkList.c

        

#include"LinkList.h"


// 初始化列表
struct LinkNode *Init_LinkList(){
	int val = -1;
	// 创建头节点
	struct LinkNode *header = (struct LinkNode*)malloc(sizeof(struct LinkNode));
	// 尾部的指针
	struct LinkNode *pRear = header;

	header->data = -1;
	header->next = NULL;
	
	while(1){
		// 先创建结点
		struct LinkNode *newnode = (struct LinkNode*)malloc(sizeof(struct LinkNode));
		printf("输入插入数据：\n");
		scanf("%d",&val);
		if(val==-1){
			break;
		}
		
		newnode->data = val;
		newnode->next = NULL;

		// 新结点插入到链表中
		pRear->next = newnode;

		// 更新尾部指针指向
		pRear = newnode;
	}

	return header;   // 返回头结点   相当于返回链表

}

// 在值为oldval的后面插入一个新的数据newval
void InsertByValue_LinkList(struct LinkNode *header,int oldval,int newval){     // 通过值来插入数据(链表，旧值，新值)
	// 定义两个辅助指针变量
	struct LinkNode *pPrev = header;
	struct LinkNode *pCurrent = pPrev->next;

	// 创建新结点
	struct LinkNode *newnode = (struct LinkNode*)malloc(sizeof(struct LinkNode));
	
	if(NULL == header){
		return;    // 如果链表不存在，直接返回
	}

	while (pCurrent != NULL){
		if(pCurrent->data == oldval){   // 如果找到了传递过来的旧值，停止循环
			break;
		}
		// 如果没找到，pPrev和pCurrent各向后挪一位
		pPrev = pCurrent;
		pCurrent = pCurrent->next;
	}

#if 0        // 当找不到oldval时，添加的值放在链表的尾部
	// 如果pCurrent为空，说明不存在值为oldval的结点
	if(pCurrent == NULL){
		return;
	}
#endif

	newnode->data = newval;
	newnode->next = NULL;

	// 新结点插入到链表中
	newnode->next = pCurrent;
	pPrev->next = newnode;


}   

// 删除值为val的结点    
void RemoveByValue_LinkList(struct LinkNode *header,int delval){        // 传入链表和要删除的值
	
	// 两个父组指针变量
	struct LinkNode *pPrev = header;
	struct LinkNode *pCurrent = pPrev->next;

	if(NULL == header){
		return;    // 如果链表不存在，直接返回
	}

	while(pCurrent != NULL){
		if(pCurrent->data == delval){
			break;
		}
		
		// 移动两个指针
		pPrev = pCurrent;
		pCurrent = pCurrent->next;
	}

	if(NULL == pCurrent){
		return;
	}

	// 重新建立待删除结点的前驱和后继结点关系
	pPrev->next = pCurrent->next;
	// 释放删除结点内存
	free(pCurrent);
	pCurrent = NULL;
} 

// 遍历

void Foreach_LinkList(struct LinkNode *header){
	// 定义辅助指针变量
	struct LinkNode *pCurrent = header->next;

	if(NULL == header){
		return;    // 如果链表不存在，直接返回
	}

	
	//printf("%d ",pCurrent->data);
	while(pCurrent != NULL){
		printf("%d ",pCurrent->data);    // 输出当前节点的数据
		pCurrent = pCurrent->next;   // 指针后移
	}

}

// 销毁链表（无法插入数据）
void Destory_LinkList(struct LinkNode *header){

	// 定义辅助指针变量
	struct LinkNode *pCurrent = header->next;

	if(NULL == header){
		return;    // 如果链表不存在，直接返回
	}

	while(pCurrent != NULL){
		// 先保存当前结点的下一结点的地址
		struct LinkNode *pNext = pCurrent->next;

		// 释放当前结点内存
		free(pCurrent);

		// 指针向后移动
		pCurrent = pNext;
	}
}

// 清空（还能插入数据,只剩一个头结点）
void Clear_LinkList(struct LinkNode *header){
	// 定义辅助指针变量
	struct LinkNode *pCurrent = header->next;

	if(NULL == header){
		return;    // 如果链表不存在，直接返回
	}

	while(pCurrent != NULL){
		// 保存当前结点的下一个结点地址
		struct LinkNode *pNext = pCurrent->next;

		// 释放当前结点内存
		free(pCurrent);

		// pCurrent指向下一个结点
		pCurrent = pNext;
	}

	// 清空最后一个数据
	header->next = NULL; 
}

 TestLinkList.c

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include"LinkList.h"

void test(){
	// 初始化链表
	struct LinkNode *header = Init_LinkList();
	// 打印链表
	Foreach_LinkList(header);
	// 插入数据
	InsertByValue_LinkList(header,1000,666);
	// 打印链表
	printf("\n----------------\n");
	Foreach_LinkList(header);
	// 清空链表
	Clear_LinkList(header);
	// 打印链表
	printf("\n----------------\n");
	Foreach_LinkList(header); 
	// 插入数据
	InsertByValue_LinkList(header,1000,111);
	// 插入数据
	InsertByValue_LinkList(header,1000,222);
	// 插入数据
	InsertByValue_LinkList(header,1000,333);
	// 打印链表
	printf("\n----------------\n");
	Foreach_LinkList(header); 

	RemoveByValue_LinkList(header,222);
	// 打印链表
	printf("\n----------------\n");
	Foreach_LinkList(header); 

	// 销毁链表
	Destory_LinkList(header);

}


int main(){
	test();

	system("pause");
	return EXIT_SUCCESS;
}

链表合并

已有a、b两个链表，每个链表中的结点包括学号、成绩。要求把两个链表合并，按学号升序排列。

输入：第一行，a、b两个链表元素的数量N、M,用空格隔开。 接下来N行是a的数据 然后M行是b的数据 每行数据由学号和成绩两部分组成

输出:按照学号升序排列的数据

样例输入

2 3    // a链表的元素数量 b链表的元素数量
5 100  // a链表中的元素
6 89   // a
3 82    // b链表中的元素
4 95    // b
2 10    // b

样例输出：

2 10
3 82
4 95
5 100
6 89

代码演示：

#include<stdio.h>
#include<malloc.h>
​
struct student{   // 设计结点
    double number;   // 数据域--学号
    double score;       // 数据域--成绩
    struct student *next;    // 指针域
};
​
struct student *create(int n);     // 创建链表函数
​
void output(struct student *header);   // 链表输出函数
​
void order(struct student *header1,struct student *header2);   // 链表排序函数
​
int main()
{
    int n,m;   // n为a链表的元素数量，m为b链表中的元素的数量
    struct student *header1,*header2;   // 创建两个链表的头结点 
    
    if(scanf("%d %d",&n,&m) == 2){   // 对数量值进行输入
        header1 = create(n);    // 创建链表a  元素数量为n个
        header2 = create(m);    // 创建链表b  元素数量为m个
        order(header1,header2); // 对两个链表进行排序
    }
    return 0;
}
​
struct student *create(int n){     // 创建链表函数
    struct student *header;    // 创建头结点指针
    header = (struct student*)malloc(sizeof(struct student));  // 创建头结点
    header->next = NULL;    // 将头结点的指针域指向NULL
    struct student *q = header;    // 创建指针q，指向头结点
    struct student *p;          // 创建结点指针p
    
    for(int i=0;i<n;i++){     // 遍历数量
        p = (struct student*)malloc(sizeof(struct student));   // 创建结点
        if(scanf("%lf %lf",&(p->number),&(p->score)) == 2){   // 给结点输入学号和成绩
            p->next = NULL;     // 采用尾插法插入结点
            q->next = p;   // 第一轮里把头结点的指针域指向了新建的结点p
            q = p;      // 将p赋值给q，以便进行下一次循环
        }
    }
    
    return(header);    // 返回链表
}
​
void output(struct student *header){     // 输出链表每个结点的信息
    header = header->next;    // 将header指向下一个结点 
    struct student *q;     // 定义一个结点指针（辅助）
    while(header != NULL){    // 当结点存在时进行打印
        printf("%.0f %.0f\n",header->number,header->score);   // 打印结点数据
        q = header;    // 记录下当前结点的指针
        header = header->next;    // 指向下一个结点，以便循环
        free(q);   // 释放内存
    }
}
​
void order(struct student *header1,struct student *header2){   // 链表排序
    struct student *q;    // 定义辅助指针变量
    q = header1;     // 将q指向链表a的头结点
    header2 = header2->next;   // 链表b的结点下移，header2不再是头结点
    
    while(q->next != NULL){   // 如果链表a的结点的指针域不为空
        q = q->next;     // 则将下一个结点赋值给q，直到最后一个结点
    }
    q->next = header2;    // 表a的最后一个结点的next指向链表b的首结点完成连接
    q = header1->next;   // 再次把q指向表a的头结点
    
    struct student *min;   // 定义指向最小学号的指针
    
    int t;    // 保存最小学号的变量
    int n,g;   // 交换学号、成绩的中间变量
    struct student *p;    // 定义辅助指针变量p
    while(q != NULL){    // 开始遍历，排序选择最外层
        p = q;     // 令p等于查找的结点q
        t = p->number;   // 令t等于开始查找的第一个结点的学号
        min = p;  // 令最小学号结点指针指向p
        while(p!=NULL){     // 如果p不为空
            if(p->number < t){    // 判断当前遍历的结点的学号是否小于第一个结点的学号(也就是预设的最小学号)
                t = p->number;   // 如果小于，就把t的值换成小于它的p->number
                min = p;   // 将最小学号的结点换成p
            }
            p = p->next;  //  如果不是，则把p往后挪
        }
        // 交换学号
        n = q->number;    // n等于第一个结点的学号
         // 将最小学号结点的学号与第一个结点的学号进行交换
        q->number = min->number;  
        min->number = n;
        
        // 同理交换成绩
        g = q->score;
        q->score = min->score;
        min->score = g;
        
        // 第一遍排序完后q后移，也就是选择排序开始排第二遍时的第一个数
        q = q->next;
    }
    output(header1);
}

奥奥奥曼
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
单链表的创建C语言数据结构---（头插法和尾插法）
qq_44208167的博客
02-20 1243
单链表的创建C语言数据结构—（头插法和尾插法） 基本上每一个关键句子都有注释 ----------------------------------------------------------头插法------------------------------------------------------------------ #include<stdio.h> #include<stdlib.h> #define NULL 0 //定义链表结点的结构体 typedef s
顺序表的链式实现（C语言）
weixin_43849783的博客
09-03 144
顺序表的链式实现（C语言） //头文件 #include<stdio.h> #include<malloc.h> //定义结点 typedef struct node { int data; struct node *next; }Node,*LinkList; //初始化 void InitList(LinkList *L) { *L=(LinkList)malloc(sizeof(Node)); (*L)->next=NULL; } //头插法 void HeadI
c语言之动态链表
最新发布
2301_81968528的博客
04-29 516
这段代码是一个循环体，假如说student_number不等于0，首先检查n的值，n=n+1，首次执行，n=1，执行if语句里的内容是true语句，指针head指向指针p1，这时候student_number不为0，n=1+1=2，执行if语句里else段的语句。首先是p2指针指向结构体里面指针next，next指针又指向p1，也就是说p1,p2这两个指针指向下一个链表，然后p2又指向p1，p1又通过malloc函数分配结构体空间，再次执行输入结构体内容。当指针p1不指向null时，循环打印链表内容。
C语言学习-13-链表-练习01-删除、插入、释放动态链表
qq_45111959的博客
01-12 1463
本文介绍C语言-数据结构之链表的动态删除、插入与释放，包含示意图和示例源码，分享给大家。
c语言 链表知识分享 --学生管理系统详解
qq_63982739的博客
09-21 1060
链表的基础知识详解，基本动态函数的使用；链表构造学生管理系统创建，查找，删除，插入 图书管理系统类似
C语言动态链表的实现
Alexanderyy的博客
11-18 1226
首先呢，我们考虑下链表的定义，我单纯的采用了单项动态链表。（事实上这个动态链表并不好，我在弹出链表的地方没有处理的很合理，没有free（懒了））。 由于个人能力限制，发现链表的表头很难采用void类函数进行更改（很麻烦）。 萌新在此采用了表头特殊化处理，表头元素直接丢进主函数，在主函数中进行处理。 我个人将函数的功能写在注释里了。 链表的思想很像你去玩铁索。如果各位见过铁链的加工过程的话，会很容易的理解，就是在原有的铁链上加一个环节。那么我们只需要在储存数据的结构体中加上下一链的地址就能轻松寻找到我
数据结构与算法 c语言 线性表-静态链表
04-27
数据结构与算法 c语言 线性表-静态链表 静态链表源码
C语言静态链表和动态链表
09-02
链表是计算机科学中一种重要的数据结构，尤其在C语言中，它被广泛用来处理动态数据集合。链表分为静态链表和动态链表，两者的...在C语言编程中，理解和掌握静态链表与动态链表的原理和使用方法是非常基础且重要的技能。
数据结构(C语言版)---静态链表
09-21
静态链表是一种特殊的链式数据结构，它与常规动态链表有所不同，主要在于存储方式和内存分配。 静态链表，顾名思义，与动态链表相对，其链表节点是在编译时静态分配的，而不是在运行时动态分配。这种设计减少了动态...
C语言数组-C语言实现使用动态数组来构建循环链表.zip
03-02
在“C语言数组_C语言实现使用动态数组来构建循环链表”这个主题中，我们将探讨如何使用动态数组来实现循环链表的主要步骤： 1. **定义节点结构体**：首先，我们需要定义一个结构体来表示链表节点，通常包括数据域和...
LinkList 单链表的实现
Spades_J 的博客
07-27 5417
LinkList.h#include "stdio.h" #include "math.h" #include "malloc.h" #include "stdlib.h"//typedef int DataType;//LinkNode是链表的结点类型，LinkList是指向链表的指针类型 //如果定义了 LinkList L;则定义了一个链表，L指向该链表的第一个结点 //不带头结点，链表为空，
c语言创建动态链表代码
10-16
//编写一个C程序,功能是: //能接收用户从键盘输入一串正整数,然后建立动态链表; //(注:用户的输入用"－1"表示结束;) //运行示例如下: //请输入: 1 2 3 4 5 6 7 8 9 -1 //结果是: 1->2->3->4->5->6->7->8->9->NULL
链表的C语言实现之动态内存分配
08-03
所谓动态内存分配就是指在程序执行的过程中动态地分配或者回收存储空间的分配内存的方法。动态内存分配不象数组等静态内存分配方法那样需要预先分配存储空间，而是由系统根据程序的需要即时分配，且分配的大小就是程序要求的大小。
简单c语言的静态链表测试
07-04
c基础 自己编的代码 这个需要积分大兄弟我也没办法吧随便拿了一个自己弄的练习 见谅哈
C语言动态链表的建立
10-16
动态链表的建立程序，用C语言编写，供技术与编程人员参考
C语言链表详解
qq_28576837的博客
06-02 4842
C语言链表详解
链表经典练习题
热门推荐
erwuhuoche的博客
04-16 2万+
链表经典练习题 一、从尾到头打印单链表 因为单链表是有指向的，前一节点只能指向下一节点，因此为了实现从尾到头打印链表可以使用一种非常简单的方法就是递归，先遍历再输出。 代码实现： void LinkListReversePrint(LinkNode* head){ 85 if(head == NULL){ 86 return;//空链表 8...
链表的各种题目整理(C语言实现)
yinshiwei2000lh的专栏
11-07 1502
链表的各种题目整理(C语言实现)   这里处理的全部是单链表: typedef struct node { char *data; struct node *next; } node_t; 我们约定一个打印链表的函数: void list_display(node_t *head) { for (; head; head = he
链表合并算法
切梦
08-19 296
题目 已知两个有序链表，试合并这两个链表，使得合并后的链表仍然有序（注：这两个链表没有公共结点，即不交叉）。 分析 既然两个链表都是有序的，所以合并它们跟合并两个有序数组没有多少区别，只是链表操作涉及到指针，不能大意。 方法一：非递归方法 使用2个指针list1和list2分别遍历两个链表，将较小值结点归并到结果链表中。如果有一个链表归并结束后另一个链表还有结点，则把另一个链表剩下部...
C语言动态数据结构：链表与动态内存分配
"C语言-动态数据结构" 这份资料是关于动态数据结构的讲解，共计61张PPT，主要聚焦于链表结构及其操作，包括创建、查找、插入和删除元素等内容，旨在帮助学习者理解动态存储结构的概念并能熟练运用。 在静态数据结构...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值