我的编程空间,编程开发者的网络收藏夹
学习永远不晚

C语言超详细讲解线性表

短信预约 -IT技能 免费直播动态提醒
省份

北京

  • 北京
  • 上海
  • 天津
  • 重庆
  • 河北
  • 山东
  • 辽宁
  • 黑龙江
  • 吉林
  • 甘肃
  • 青海
  • 河南
  • 江苏
  • 湖北
  • 湖南
  • 江西
  • 浙江
  • 广东
  • 云南
  • 福建
  • 海南
  • 山西
  • 四川
  • 陕西
  • 贵州
  • 安徽
  • 广西
  • 内蒙
  • 西藏
  • 新疆
  • 宁夏
  • 兵团
手机号立即预约

请填写图片验证码后获取短信验证码

看不清楚,换张图片

免费获取短信验证码

C语言超详细讲解线性表

1. 顺序表

顺序表是指用一段连续的地址,依次存放数据元素的线性数据结构。此种存储方式使得顺序表的物理结构与逻辑结构都是连续的。

与数组的区别:函数中的数组被存放在栈段中,而栈段有系统限制的大小(可使用ulimit -s查看系统限制的大小,单位为KB),因此顺序表往往使用在堆段中操作管理动态数组的方式实现。

1.1 管理结点

在顺序表中,管理节点内部一般存放:数据域地址(*data)、**总容量(size)以及当前数据量(len)**等等。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef struct Vector {
	//数据域 
	int *data;
	//总容量 
	int size;
	//当前元素个数 或 指向末尾元素的后一位
	int len;
} Vector; 
//初始化
Vector *initVector(int size){
	Vector *v = (Vector *) malloc(sizeof(Vertor));
	v->data = (int *) malloc(sizeof(int) * size);
	v->len = 0;
	v->size = size;
	return v; 
} 
//释放
void freeVector(Vector *v){
	if(!v) return;
	free(v->data);
	free(v);
}
int main(){
	//初始化size为10的线性表
	Vector *v = initVector(10)
	return 0;
}

1.2 顺序表的插入

//插入 
//将 v->data[idx] 处变成 val 
void insert(Vector *v, int idx, int val){
	//判断 v 是否为空 返回 
	if(!v) return; 
	//判断 idx 是否合法 
	if(idx > v->len || idx < 0) return ;
	//判断 v 的容量是否已满
	if(v->len == v->size) return ; 
	//维护顺序表的特性  将 idx 及之后的元素后移 
	for(int i = v->len; i > idx ;i++){
		v->data[i] = v->data[i - 1];
	}
	//在 idx 处插入数据 
	v->data[i] = val;
	//更新当前元素个数 
	v->len++; 
} 

1.3 顺序表的删除

//删除
//将 v->data[idx] 删除 
void delete(Vector *v, int idx){
	if(!v) return ;
	if(idx >= v->len || idx < 0) return ;
	// idx 之后的元素前移
	for(int i = idx; i < v->len-1; i++){
		v->data[i] = v->data[i + 1];
	}
	v->len--;
}

1.4 顺序表的扩容

扩容:新创建 原size * 2 的空间,然后将原数据从原空间迁移到新空间

//倍增法扩容 size -> size + exsize
int expand(Vector *v){
	//扩容为 size + exSize 
	int exSize = v->size;
	int *tmp;
	while(exSize){
		//尝试向内存申请空间 
		tmp = (int *) realloc(v->data, sizeof(int) * (v->size + exSize));
		//申请成功 
		if(tmp) break;
		//申请不成功 exSize/2 继续申请 
		exSize >>= 1; 
	}
	//彻底失败 未申请到空间 
	if(!tmp) return 0;
	//扩容成功
	v->data = tmp; 
	v->size += exSize;
	return 1;
}
//插入 
//将 v->data[idx] 处变成 val 
void insert(Vector *v, int idx, int val){
	...
	if(v->len == v->size) {
		//尝试扩容 扩容成功为 1 失败为 0 
		if(!expand(v)) return; 
	} 
	...
} 

2. 链表

2.1 定义

链表是一种物理结构不连续,但可以依靠结点中的指针实现逻辑结构连续的线性数据结构。

构成链表的数据元素被称为“结点”,节点内部存放数据与指向下一个结点的指针。

//定义结点 
typedef struct Node{
	int val;
	struct Node *next;
} Node; 
//结点初始化 
Node *initNode(int val){
	Node *node = (Node *) malloc(sizeof(Node));
	node->val = val;
	node->next = NULL;
	return node;
} 
//释放结点
void freeNode(Node *node){
	if(!node) return ;
	free(node);
} 

只有单一结点指针的链表的全程是“单链表”,经常被简称为链表。

链表的管理结点一般仅需要存放头结点指针(*head)。

如果需要频繁获取链表长度,管理结点中可以额外存放链表长度(len)。

//定义链表 管理结点 
typedef struct List{
	Node *head;
	int len;
} List;
//初始化链表
List *initList() {
	List *list = (List *) malloc(sizeof(List));
	list->head = NULL;
	list->len = 0;
	return list;
}

2.2 头部插入

头插法:将新插入的节点放在 head 后,时间复杂度O(1)

//头部插入
void insertToHead(List *list, int val){
	if(!list) return ;
	Node *node = initNode(val);
	node->next = list->head;
	list->head = node;
	list->len++;
} 

2.3 尾部插入

尾插法:找到最后一个结点,将新节点插入。如果没有设计尾指针,则时间复杂度为O(n)。

//尾部插入 
void insertToTail(List *list, int val){
	if(!list) return ;
	Node *node = initNode(val);
	//如果list为空 则node为第一个结点 让head等于node
	//判断条件可更改为list->len == 0 
	if(list->head == NULL){
		list->head = node;
		list->len++;
		return ;
	}
	Node *p = list->head;
	while(p->next != NUll){
		p = p->next;
	}
	p->next = node;
	list->len++;
}
//测试
int main(){
	List *list1 = initList();
	List *list2 = initList();
	for(int i = 0;i <= 10;i += 2){
		insertToHead(list1,i);
	}
	Node *p = list1->head;
	while(p){
		printf("%d -> ",p->val);
		p = p->next;
	}
	printf("\n");
	for(int i = 1;i <= 10;i += 2){
		insertToTail(list2,i);
	}
	Node *q = list2->head;
	while(q){
		printf("%d -> ",q->val);
		q = q->next;
	}
	printf("\n");
	return 0;
}

输出结果:

2.4 任意位置插入

//任意位置的插入
// idx = 0 待插入结点为头结点
// idx > 0 插入至第 i 个结点后
void insert(List *list, int idx, int val){
	if(!list) return ;
	if(idx > list->len || idx < 0) return ;
	if(idx == 0){
		//头插法 
		insertToHead(list,val);
		return;
	}
	Node *node = initNode(val);
	//结点索引为 0 
	Node *p = list->head;
	//p 找到第 idx - 1个结点
	// i = 1  结点索引为 1 
	// i = 2 结点索引为 2
	// i = idx - 1 结点索引为 idx - 1 
	for(int i = 1;i <= idx - 1;i++){
		p = p->next;
	} 
	//插入
	node->next = p->next;
	p->next = node;
	list->len++;
}

2.5 任意位置删除

//任意位置的删除 
void remove(List *list, int idx){
	if(!list) return ;
	if(idx > list->len || idx < 0) return ;
	//p为0号索引结点
	Node *p = list->head;
	//删除索引为 0 的结点 更改head 
	if(idx == 0){
		list->head = p->next; 
		list->len--;
		freeNode(p);
		return;
	}
	//找到idx-1个结点
	for(int i = 1;i <= idx - 1;i ++){
		p = p->next;
	}
	Node *node = p->next;
	//删除 
	p->next = p->next->next;
	list->len--;
	freeNode(node);
} 

2.6 虚头结点

在需要特殊处理头结点的时候,可以实现一个带有虚头结点的链表。在链表初始化或在某些操作执行时,将一个额外的结点放在头指针执行的地方。虚头结点可以使得整个链表永远不空,永远有头。所以拥有虚头结点的链表在处理各类结点操作时会更加便捷。

任意位置插入:不需要特殊考虑插入位置是否在链表头部。

任意位置删除:不需要特殊考虑删除的结点是否是链表的第一个结点。

//结点部分没有改动
//定义结点 
typedef struct Node{
	int val;
	struct Node *next;
} Node; 
//结点初始化 
Node *initNode(int val){
	Node *node = (Node *) malloc(sizeof(Node));
	node->val = val;
	node->next = NULL;
	return node;
} 
//释放结点
void freeNode(Node *node){
	if(!node) return ;
	free(node);
}

//定义链表 管理结点 
typedef struct List{
	Node *head;
	int len;
} List;
//初始化链表
List *initList() {
	List *list = (List *) malloc(sizeof(List));
	//变动  :初始化的时候赋予一个结点 任意数值都可以 
	list->head = initNode(-1);
	list->len = 0;
	return list;
}
//头部插入
void insertToHead(List *list, int val){
	if(!list) return ;
	Node *node = initNode(val);
	// 变动
	node->next = list->head->next;
	// 变动
	list->head->next = node;
	list->len++;
} 
//尾部插入 
void insertToTail(List *list, int val){
	if(!list) return ;
	Node *node = initNode(val);
	//变动 删除对链表是否为空的判断  可以直接进行插入
	//此处可以谢伟 Node *p = list->head->next; 
	Node *p = list->head;
	while(p->next != NULL){
		p = p->next;
	}
	p->next = node;
	list->len++;
}
//任意位置的插入
void insert(List *list, int idx, int val){
	if(!list) return ;
	if(idx > list->len || idx < 0) return ;
	//变动 : 删除对链表是否为空的判断 
	Node *node = initNode(val);
	Node *p = list->head;
	for(int i = 1;i <= idx;i++){
		p = p->next;
	} 
	//插入
	node->next = p->next;
	p->next = node;
	list->len++;
} 
//任意位置的删除 
void remove(List *list, int idx){
	if(!list) return ;
	if(idx > list->len || idx < 0) return ;
	Node *p = list->head;
	for(int i = 1;i <= idx;i ++){
		p = p->next;
	}
	Node *node = p->next;
	//删除 
	p->next = p->next->next;
	list->len--;
	freeNode(node);
}

到此这篇关于C语言超详细讲解线性表的文章就介绍到这了,更多相关C语言线性表内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网!

免责声明:

① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的,并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据,供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

C语言超详细讲解线性表

下载Word文档到电脑,方便收藏和打印~

下载Word文档

猜你喜欢

C语言哈希表概念超详细讲解

哈希是一种很高效的存储数据的结构,它是利用的一种映射关系,它也是STL中unordered_map和unordered_set 的底层结构。本文,主要讲解哈希的原理,哈希的实现,里面关键点在于如何解决哈希冲突
2023-02-09

C语言超详细讲解双向带头循环链表

带头双向循环链表:结构最复杂,一般用在单独存储数据。实际中使用的链表数据结构,都是带头双向循环链表。另外这个结构虽然结构复杂,但是使用代码实现以后会发现结构会带来很多优势,实现反而简单
2023-02-14

编程热搜

  • Python 学习之路 - Python
    一、安装Python34Windows在Python官网(https://www.python.org/downloads/)下载安装包并安装。Python的默认安装路径是:C:\Python34配置环境变量:【右键计算机】--》【属性】-
    Python 学习之路 - Python
  • chatgpt的中文全称是什么
    chatgpt的中文全称是生成型预训练变换模型。ChatGPT是什么ChatGPT是美国人工智能研究实验室OpenAI开发的一种全新聊天机器人模型,它能够通过学习和理解人类的语言来进行对话,还能根据聊天的上下文进行互动,并协助人类完成一系列
    chatgpt的中文全称是什么
  • C/C++中extern函数使用详解
  • C/C++可变参数的使用
    可变参数的使用方法远远不止以下几种,不过在C,C++中使用可变参数时要小心,在使用printf()等函数时传入的参数个数一定不能比前面的格式化字符串中的’%’符号个数少,否则会产生访问越界,运气不好的话还会导致程序崩溃
    C/C++可变参数的使用
  • css样式文件该放在哪里
  • php中数组下标必须是连续的吗
  • Python 3 教程
    Python 3 教程 Python 的 3.0 版本,常被称为 Python 3000,或简称 Py3k。相对于 Python 的早期版本,这是一个较大的升级。为了不带入过多的累赘,Python 3.0 在设计的时候没有考虑向下兼容。 Python
    Python 3 教程
  • Python pip包管理
    一、前言    在Python中, 安装第三方模块是通过 setuptools 这个工具完成的。 Python有两个封装了 setuptools的包管理工具: easy_install  和  pip , 目前官方推荐使用 pip。    
    Python pip包管理
  • ubuntu如何重新编译内核
  • 改善Java代码之慎用java动态编译

目录