线性表的链式存储实现

最新推荐文章于 2022-11-08 22:20:39 发布
转载 最新推荐文章于 2022-11-08 22:20:39 发布 · 224 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：https://my.oschina.net/niithub/blog/3017079
文章标签：

#数据结构与算法 #python

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

1. 基础操作

/**
 *  遍历输出单链表
 */
void print(LinkList H) {
	LinkList p = H->next;
	while (p) {
		printf("%c", p->data);
		p = p->next;
	}
}

/**
 * 初始化链表
 */
void initList(LinkList *H) {
	/* 产生头结点,并使L指向此头结点 */
	*H = (LinkList)malloc(sizeof (List));
	(* H)->next = NULL;
}
/**
 * 初始条件：顺序线性表L已存在。
 * 操作结果：若L为空表，则返回TRUE，否则返回FALSE
 */
int listEmpty(LinkList L) {
	if(L->next) {
		return ERROR;
	} else {
		return OK;
	}
}

/**
 * 初始条件：顺序线性表L已存在。
 * 操作结果：将L重置为空表
 */
int clearList(LinkList *L) {
	LinkList p,q;
	p = (*L)->next;           /*  p指向第一个结点 */
	while(p) {              /*  没到表尾 */
		q = p->next;
		free(p);
		p = q;
	}
	(*L)->next = NULL;        /* 头结点指针域为空 */
	return OK;
}

/**
 * 初始条件：顺序线性表L已存在。
 * 操作结果：返回L中数据元素个数
 */
int listLength(LinkList L) {
	int i = 0;
	LinkList p = L->next; /* p指向第一个结点 */
	while(p) {
		i++;
		p = p->next;
	}
	return i;
}

2、以头插法建立单链表

/**
 * 以头插法建立单链表
 * 以"#"符为结束符
 */
void createFromHead(LinkList H) {
	List *node;
	ElementType type;
	int flag = 1;
	while (flag) {
		type = getchar();
		if ('#' != type) {
			node = (List *)malloc(sizeof(List));
			node->data = type;
			node->next = H->next;
			H->next = node;
		} else {
			flag = 0;
		}
	}
}

3、以尾插法建立单链表

/**
 * 以尾插法建立单链表
 * 以"#"符为结束符
 */
void createFromEnd(LinkList H) {
	List *node;
	ElementType type;
	int flag = 1;
	while(flag) {
		type = getchar();
		if ('#' != type ) {
			node = (List *)malloc(sizeof(List));
			node->data = type;
			H->next = node;
			H = node;
		} else {
			flag = 0;
			H->next = NULL;
		}
	}
}

4、在单链表L中查找第i个结点

/**
 * 在单链表L中查找第i个结点
 */
List *get(LinkList L, int i) {
	List *list  = L->next;
	int index = 1;
	while (index != i && list->next != NULL) {
		index++;
		list = list->next;
	}
	return list;
}

5、在单链表L中查找值等于key的个结点

/**
 * 在单链表L中查找值等于key的个结点
 */
List *locate(LinkList L, ElementType key) {
	List *list  = L->next;
	while (list->data != key && list->next != NULL) {
		list = list->next;
	}
	return list;
}

6、在单链表的第i位插入元素e

/**
 * 在单链表的第i位插入元素e
 */
int insertList(LinkList L, int i, ElementType e) {
	List *list = L, *p;
	int index = 0;
	while (index < i - 1 && list->next != NULL)  {
		index++;
		list = list->next;
	}
	/**
	 * 跳出循环是因为list在链表最后或i<1，所以一定是插入位置不合法
	 */
	if (index != i -1) {
		printf("插入位置不合法！");
		return ERROR;
	}
	p = (List *)malloc(sizeof(List));
	p->data = e;
	p->next = list->next;
	list->next = p;
	return OK;
}

7、删除单链表的第i位元素

/**
 * 删除单链表的第i位元素,并将删除的元素保存至元素e中
 */
int deleteList(LinkList L, int i, ElementType *e) {
	List *list = L, *p;
	int index = 0;
	while (index < i - 1 && list->next != NULL)  {
		index++;
		list = list->next;
	}
	/**
	 * 跳出循环是因为list在链表最后或i<1，所以一定是位置不合法
	 */
	if (index != i -1) {
		printf("位置不合法！");
		return ERROR;
	}
	p = list->next;
	*e = p->data;
	list->next = p->next;
	/*一定要记得释放删除的结点所占内存空间*/
	free(p);
	return OK;
}

8、完整实例

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

#define OK 1
#define ERROR 0
typedef char ElementType;
typedef struct Node {
	ElementType data;
	struct Node * next;
} List, *LinkList;

void print(LinkList H);
void initList(LinkList *H);
int listEmpty(LinkList L);
int clearList(LinkList *L);
int listLength(LinkList L);
void createFromHead(LinkList H);
void createFromEnd(LinkList H);
List *get(LinkList L, int i);
List *locate(LinkList L, ElementType key);
int insertList(LinkList L, int i, ElementType e);
int deleteList(LinkList L, int i, ElementType *e);
int main(int argc, char *argv[]) {
	LinkList H;
	initList(&H);
	printf("头插法实现链表：\n");
	createFromHead(H);
	printf("头插法结果：\n");
	print(H);
	List *result = get(H, 3);
	printf("\n查找第3位元素，结果：%c\n", result->data);
	printf("\n尾插法实现链表：\n");
	createFromEnd(H);
	printf("尾插法结果：\n");
	print(H);
	printf("\n往链表的第3位插入元素F：\n");
	char element = 'F';
	insertList(H, 3, element);
	printf("插入结果：\n");
	print(H);
	char e;
	deleteList(H, 4, &e);
	printf("\n删除链表的第4位元素：%c\n", e);
	print(H);
	int i = clearList(&H);
	printf("\n遍历清空后的链表：\n");
	print(H);
	printf("链表的长度length(H) = %d\n", listLength(H));
	return 0;
}

/**
 *  遍历输出单链表
 */
void print(LinkList H) {
	LinkList p = H->next;
	while (p) {
		printf("%c", p->data);
		p = p->next;
	}
}

/**
 * 初始化链表
 */
void initList(LinkList *H) {
	/* 产生头结点,并使L指向此头结点 */
	*H = (LinkList)malloc(sizeof (List));
	(* H)->next = NULL;
}
/**
 * 初始条件：顺序线性表L已存在。
 * 操作结果：若L为空表，则返回TRUE，否则返回FALSE
 */
int listEmpty(LinkList L) {
	if(L->next) {
		return ERROR;
	} else {
		return OK;
	}
}

/**
 * 初始条件：顺序线性表L已存在。
 * 操作结果：将L重置为空表
 */
int clearList(LinkList *L) {
	LinkList p,q;
	p = (*L)->next;           /*  p指向第一个结点 */
	while(p) {              /*  没到表尾 */
		q = p->next;
		free(p);
		p = q;
	}
	(*L)->next = NULL;        /* 头结点指针域为空 */
	return OK;
}

/**
 * 初始条件：顺序线性表L已存在。
 * 操作结果：返回L中数据元素个数
 */
int listLength(LinkList L) {
	int i = 0;
	LinkList p = L->next; /* p指向第一个结点 */
	while(p) {
		i++;
		p = p->next;
	}
	return i;
}

/**
 * 以头插法建立单链表
 * 以"#"符为结束符
 */
void createFromHead(LinkList H) {
	List *node;
	ElementType type;
	int flag = 1;
	while (flag) {
		type = getchar();
		if ('#' != type) {
			node = (List *)malloc(sizeof(List));
			node->data = type;
			node->next = H->next;
			H->next = node;
		} else {
			flag = 0;
		}
	}
}

/**
 * 以尾插法建立单链表
 * 以"#"符为结束符
 */
void createFromEnd(LinkList H) {
	List *node;
	ElementType type;
	int flag = 1;
	while(flag) {
		type = getchar();
		if ('#' != type ) {
			node = (List *)malloc(sizeof(List));
			node->data = type;
			H->next = node;
			H = node;
		} else {
			flag = 0;
			H->next = NULL;
		}
	}
}

/**
 * 在单链表L中查找第i个结点
 */
List *get(LinkList L, int i) {
	List *list  = L->next;
	int index = 1;
	while (index != i && list->next != NULL) {
		index++;
		list = list->next;
	}
	return list;
}

/**
 * 在单链表L中查找值等于key的个结点
 */
List *locate(LinkList L, ElementType key) {
	List *list  = L->next;
	while (list->data != key && list->next != NULL) {
		list = list->next;
	}
	return list;
}

/**
 * 在单链表的第i位插入元素e
 */
int insertList(LinkList L, int i, ElementType e) {
	List *list = L, *p;
	int index = 0;
	while (index < i - 1 && list->next != NULL)  {
		index++;
		list = list->next;
	}
	/**
	 * 跳出循环是因为list在链表最后或i<1，所以一定是插入位置不合法
	 */
	if (index != i -1) {
		printf("插入位置不合法！");
		return ERROR;
	}
	p = (List *)malloc(sizeof(List));
	p->data = e;
	p->next = list->next;
	list->next = p;
	return OK;
}

/**
 * 删除单链表的第i位元素,并将删除的元素保存至元素e中
 */
int deleteList(LinkList L, int i, ElementType *e) {
	List *list = L, *p;
	int index = 0;
	while (index < i - 1 && list->next != NULL)  {
		index++;
		list = list->next;
	}
	/**
	 * 跳出循环是因为list在链表最后或i<1，所以一定是位置不合法
	 */
	if (index != i -1) {
		printf("位置不合法！");
		return ERROR;
	}
	p = list->next;
	*e = p->data;
	list->next = p->next;
	/*一定要记得释放删除的结点所占内存空间*/
	free(p);
	return OK;
}

9、总结

  1. 一定要理清结点之间的关系
  2. 删除结点后要注意释放内存空间
  3. 插入结点或new 结点后，需要申请内存空间

转载于:https://my.oschina.net/niithub/blog/3017079

实现一个链式存储的线性表
konnisan的博客
11-05 5515
实现一个链式存储的线性表任务描述相关知识编程要求测试说明代码实现 任务描述 本关任务：完成一个链接存储的线性表的小程序。 相关知识 线性表的存储也可以采用链接存储方式来实现。链接存储方式包括单链表、双链表和循环链表等形式。 下面描述了一种基于单链表的线性表实现方案： 为了讨论简单，假设数据元素的类型为整型： typedef int T; 在链表中，每个数据元素为一个链表结点，结点的具体定义为： struct LinkNode { T data; LinkNode* next; }; 如
线性表的实现（链式存储）
shi_xiao_xuan的博客
10-30 603
线性表的实现1.结构体定义-链式2.表长3.查找（按序号）4.查找（按值）5.插入6.删除7.打印整表测试完整代码 1.结构体定义-链式 typedef struct LNode { ElementType Data; struct LNode* next; }*List; List PtrL; 或者 typedef struct LNode *List; struct LNode ...
数据结构实验-链式存储和顺序存储实现两个集合的交并操作
12-22
数据结构线性表操作的一个实验： 实验要求 顺序和链式存储的线性表的创建、获取元素、插入和删除元素等基本操作的实现。 题目要求： 输入：一组整型数据A，一组整型数据B 输出：A与B的交集，以及A与B的并集 要求：A和B使用两种存储方式：顺序存储和链式存储。
数据结构之线性表（链式存储结构）
weixin_33785972的博客
05-15 441
线性表的实现分顺序存储结构和链式存储结构 上一节我们主要介绍了顺序存储结构，在最后我们还分别总结了顺序存储结构的优缺点， 对于顺序结构的缺点，我们有没有什么好的解决方法呢？ 我们今天要介绍的线性表的链式存储结构就可以很好的解决顺序结构的缺点，一起来看。 顺序结构最大的缺点就是在进行插入和删除操作的时候，如果插入位置不理想，那么我们需要移动大量的元素，那产生这一问题的原因是什么呢？ 仔细分...
线性表的链式存储和实现
12-22
　下面分享链式存储实现的代码，希望对你的学习有帮助 　// 测试.cpp : 定义控制台应用程序的入口点。 　// 　#include "stdafx.h" 　#include "stdlib.h" 　#include "iostream" 　using namespace std; 　...
数据结构实验报告2线性表的链式存储结构.pdf
09-30
本实验报告详细介绍了线性表的链式存储结构，通过编程实践深入理解了链表的逻辑结构、基本操作以及链表算法的实现过程。 线性表作为一种常见的数据结构，其特点是元素之间存在一对一的线性关系。线性表中数据元素...
python线性表顺序链式存储实现_线性表的链式存储(C代码实现)
weixin_42548888的博客
02-10 602
线性表的链式存储结构线性表的实现分顺序存储结构和链式存储结构。上一节我们学学习了线性表的实现分顺序存储结构，并实现解顺序存储的基本操作。这一节我们来学习线性表链式存储结构，那我们再想象一下我为什么我们要引入链式存储结构，万物存在必有其道理主要还是因为线性存储结构存在着这样一个问题：当我们需要插入和删除元素时，就必须挪动大量与之无关的元素，因为线性存储结构结点与节点之间的关系是相邻关系，一个节点挨着...
链表的C++实现（线性表的链式存储C++实现）
04-05
使用C++类模板实现了线性表的链式存储结构（链表），类中包含了线性表的常用方法：向线性表中插入一个元素、删除一个元素、清空线性表、获取一个元素、获取线性表长度等。大致实现了STL中的链表的基本功能，通过对比...
线性表的链式存储与实现
07-29
通过理解和熟练掌握链式存储线性表的实现，可以为解决许多实际问题打下坚实的基础。在实际编程中，我们可以结合具体需求选择单链表或双向链表，并根据所使用的编程语言特性，如C、C++、Java或Python等，实现相应的...
线性表——链式存储实现
qq_44923545的博客
05-21 614
什么是链式存储： 1：用一组任意的存储单元存储线性表的数据元素，这组存储单元可以存在内存中未被占用的任意位置。 2：链式存储结构中，除了要存储数据元素信息外，还要存储它的后继元素的存储地址（指针）。 3：存储数据元素信息的域称为数据域，把存储直接后继位置的域称为指针域。这两部分信息组成数据元素称为存储映像，称为结点(Node)。 单链表的删除插入操作： 代码实现：查找，初始化，插入，删除—操作实现 /*srand(time(0))?;//先设置种子 rand();//然后产生随机数 Srand是种下
线性表的链式存储方式
微风
06-04 7288
今天这一篇是我动手实现的第三个数据结构的存储类型，真的收获很多，觉得数据结构其实是数据和它的存储结构的总和，一个数据没有存储结构那仫他在计算机中就如同没有稳定的“家”，此时我们是没有办法访问它的，今天就分享一下我实现链式表的一些心得希望能帮助那些数据结构的初学者。
线性表的链式储存实现
m0_74183164的博客
11-08 224
3）然后修改指针，插入结点（p之后插入新结点是s）2）再用指针s指向要被删除的结点（p的下一个结点）2）再找到链表的第i-1个结点，用p指向。1）先找到链表的第i-1个结点，用p指向。3）然后修改指针，删除s所指结点。4）最后释放s所指结点的空间。1）先构造一个新结点s。
线性表链式存储的实现
qq_38008690的博客
02-04 339
线性表链式存储的实现 学了一遍数据结构感觉和没学一样好多代码还不会写，刚好最近出不了门，慢慢敲。我看的是《大话数据结构》这本书 这些代码是看这本书附赠的代码写出来的，有很多不足希望各位大佬看到能热心指出。 这里是一些定义 #include <iostream> #include "stdio.h" #include "string.h" #include "ctype.h" ...
线性表链式存储实现
qq_63913499的博客
10-17 638
线性表存储实现
链式存储实现线性表操作
在这个例子中，线性表的链式实现使用了链表，链表的每个节点包含一个`Student`结构体，用于存储学生信息。链表的每个节点还有一个指针`next`，它链接到下一个节点，这样就形成了一个链式的序列。 1. **链表创建（ ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值