数据结构——线性表

最新推荐文章于 2022-06-20 15:33:54 发布
最新推荐文章于 2022-06-20 15:33:54 发布
阅读量542 收藏
点赞数
分类专栏： 数据结构 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq742143797/article/details/107444477
版权

线性表

线性表的特点如下：

  • 表中元素个数有限
  • 元素具有逻辑上的顺序性，表中元素有先后次序
  • 表中元素都是数据元素，每个元素都是单个元素，元素的数据类型相同，意味着每个元素占有相同大小的存储空间

顺序表

特点：表中元素的逻辑顺序和物理顺序是相同的

实现代码
#ifndef MaxSize
#define MaxSize 50

typedef int ElementType;
//顺序表 以数组作为内部物理存储结构，大小固定
typedef struct
{
	ElementType data[MaxSize];
	int length;
}arrayNode;


arrayNode* InitList() {
	arrayNode* l = (arrayNode*)malloc(sizeof(arrayNode));
	l->length = 0;
	for (ElementType i = 0; i < 30; i++) {
		l->data[i] = i + 10;
		l->length++;
	}
	return l;
}
ElementType length(arrayNode* L) {
	return L->length;
}
bool Empty(arrayNode* L) {
	return L->length == 0 ? true : false;
}
//按位查找
ElementType LocateElem(arrayNode* L, ElementType e) {
	if (e<1 || e>L->length)
		return -1;
	return L->data[--e];
}
//按值查找
ElementType getElem(arrayNode* L, ElementType e) {
	if (L->length == 0)
		return -1;
	int i = 0;
	while (e != L->data[i]) {
		i++;
	}
	return ++i;
}
//在指定位置i插入数据
bool ListInsert(arrayNode* L, ElementType e, ElementType i) {
	if (i<1 || i>L->length+1)
		return false;
	if (L->length >= MaxSize)
		return false;
	if (i == L->length+1)
		L->data[i-1] = e;
	else {
		for (ElementType s = L->length; s > i - 1; s--)
			L->data[s] = L->data[s - 1];
		L->data[i - 1] = e;
		L->length++;
		
	}
	return true;
}
//在指定位置上删除数据
bool ListDelete(arrayNode* L, ElementType i) {
	if (i<1 || i>L->length)
		return false;
	if (L->length == 0)
		return false;
	for (ElementType s = i; s < L->length; s++)
		L->data[s - 1] = L->data[s];
	L->length--;
	return true;
}
//打印链表
void printList(arrayNode* L) {
	for (ElementType i = 0; i < L->length; i++)
		printf("%d\n", L->data[i]);
}
//摧毁链表
void DestroyList(arrayNode* L) {
	if (L == NULL)
		return;
	free(L);
}

链表

以下所有代码全部都添加了头节点即链表的head指针域不存放数据，引入头节点具有以下好处：

  • 由于第一个数据节点的位置被存放在头结点的指针域中，所以引入头节点可以使链表的第一个位置上的操作与其他位置操作一致，无需特殊处理。
  • 无论链表是否为空，头指针指向了头结点的非空指针，因此空表和非空表的处理也得到了统一。

单链表

线性表的链式存储又称单链表，通过一组任意的存储单元来存储线性表的数据元素。
为了建立线性关系，除了存放数据元素外还会存放一个指向后继节点的指针

实现代码
#ifndef MaxSize
#define MaxSize 50
typedef int ElementType;

typedef struct _node
{
	ElementType data;
	struct _node* next;
}Node;
typedef struct
{
	//增加一个尾节点，能够增加插入的效率
	Node* tail;
	Node* head;
	int length;
}linkNode;

#include "singleLinkList.h"
#include <stdlib.h>

//单向链表，保存了头节点
//使用尾插法,速度快每次为O（1）
/*
linkNode* InitList() {
	//给链表体申请空间
	linkNode* l = (linkNode*)malloc(sizeof(linkNode));
	//申请失败则异常退出程序
	if (l == NULL)
		exit(0);
	//设置初始长度为0，同时申请一个空的表头
	l->length = 0;
	l->head = (Node*)malloc(sizeof(Node));
	l->head->data = 0;
	l->head->next = NULL;
	l->tail = l->head;
	//为这个链表设置三十个节点
	for (ElementType i = 0; i < 30; i++) {
		//临时申请一个变量为头节点方便操作
		Node* temp = (Node*)malloc(sizeof(Node));
		temp->data = i + 10;
		temp->next = NULL;
		l->tail->next = temp;
		l->tail = l->tail->next;
		l->length++;
	}
	return l;
}
*/

//使用头插法
//使用这个方法创建的链表每次都是和插入顺序倒叙的但是时间复杂度也是O（1）
linkNode* InitList() {
	//给链表体申请空间
	linkNode* l = (linkNode*)malloc(sizeof(linkNode));
	//申请失败则异常退出程序
	if (l == NULL)
		exit(0);
	//设置初始长度为0，同时申请一个空的表头
	l->length = 0;
	l->head = (Node*)malloc(sizeof(Node));
	l->head->data = 0;
	l->head->next = NULL;
	//为这个链表设置三十个节点
	for (ElementType i = 0; i < 30; i++) {
		//临时申请一个变量为头节点方便操作
		Node* temp = (Node*)malloc(sizeof(Node));
		temp->data = i + 10;
		temp->next = l->head->next;
		l->head->next = temp;
		l->length++;
	}
	return l;
}
//得到链表长度
ElementType length(linkNode* L) {
	return L->length;
}
bool Empty(linkNode* L) {
	return L->length == 0 ? true : false;
}
//按位查找
ElementType LocateElem(linkNode* L, ElementType e) {
	if (e<1 || e>L->length)
		return -1;
	Node* temp = L->head;
	for (ElementType i = 0; i < e; i++) {
		temp = temp->next;
	}
	return temp->data;
}
//按值查找
Node* getElem(linkNode* L, ElementType e) {
	if (L->length == 0)
		return NULL;
	Node* temp = L->head;
	ElementType i;
	for (i = 1;temp->data!=e; i++) {
		temp = temp->next;
	}
		return temp;
}
//在指定位置i插入数据
bool ListInsert(linkNode* L, ElementType e, ElementType i) {
	if (i<1 || i>L->length+1)
		return false;
	//不能超过最大长度50
	if (L->length >= MaxSize)
		return false;
	Node* newNode = (Node*)malloc(sizeof(Node));
	newNode->data = e;
	//如果是最后一位在末尾插入
	if (i == L->length + 1) {
		newNode->next = NULL;
		L->tail->next = newNode;
		L->tail = newNode;
	}
	else {
		Node* temp = L->head;
		//我们要插入到第i个位置上，那么我们就要找到第i-1位置的数据然后插入在这个i-1位置后的位置
		for (ElementType s = 0; s < i - 1; s++) {
			temp = temp->next;
		}

		newNode->next = temp->next;
		temp->next = newNode;
	}
	L->length++;
	return true;
}
//在指定位置上删除数据
bool ListDelete(linkNode* L, ElementType i) {
	if (i<1 || i>L->length)
		return false;
	if (L->length == 0)
		return false;
	Node* temp = L->head;
	//找到这个位置的上一个节点，让上一个节点的next等于这个节点的next节点；
	for (ElementType s = 0; s < i-1; s++) {
		temp = temp->next;
	}
	Node* destenateNode = temp->next;
	temp->next = destenateNode->next;
	free(destenateNode);
	L->length--;
	return true;
}
//打印链表
void printList(linkNode* L) {
	Node* temp = L->head;
	for (ElementType i = 0; i < L->length; i++) {
		printf("%d\n", temp->next->data);
		temp = temp->next;
	}
		
}
//摧毁链表
void DestroyList(linkNode* L) {
	if (L == NULL)
		return;
	Node* temp = L->head;
	Node* deTemp;
	while (temp != NULL) {
		deTemp = temp;
		temp = temp->next;
		free(deTemp);
	}
	free(L);
}

双向链表

在单链表中只有一个指向后继节点的指针，每次访问元素都只能从头到尾依次顺序访问，双向链表在每个结点添加了一个pre结点指向前置结点，克服了上述缺点。

实现代码
#ifndef MaxSize
#define MaxSize 50

//双向链表
typedef int ElementType;
typedef struct node {
	ElementType data;
	struct node* pre;
	struct node* next;
}Node;

typedef struct bothWayLinkList {
	Node* head;
	Node* tail;
	int length;
}bothWayList;


//双向链表,保存了头节点
//使用尾插法,速度快每次为O（1）

bothWayList* InitList() {
	//给链表体申请空间
	bothWayList* l = (bothWayList*)malloc(sizeof(bothWayList));
	//申请失败则异常退出程序
	if (l == NULL)
		exit(0);
	//设置初始长度为0，同时申请一个空的表头
	l->length = 0;
	l->head = (Node*)malloc(sizeof(Node));
	l->head->next = NULL;
	l->head->pre = NULL;
	l->head->data = 0;
	l->tail = l->head;
	//为这个链表设置三十个节点
	for (ElementType i = 0; i < 30; i++) {
		Node* temp = (Node*)malloc(sizeof(Node));
		temp->data = i + 10;
		temp->next = NULL;
		l->tail->next = temp;
		temp->pre = l->tail;
		l->tail = l->tail->next;
		l->length++;
	}
	return l;
}


//使用头插法
//使用这个方法创建的链表每次都是和插入顺序倒叙的但是时间复杂度也是O（1）
/*
bothWayList* InitList() {
	//给链表体申请空间
	bothWayList* l = (bothWayList*)malloc(sizeof(bothWayList));
	//申请失败则异常退出程序
	if (l == NULL)
		exit(0);
	//设置初始长度为0，同时申请一个空的表头
	l->length = 0;
	l->head = (Node*)malloc(sizeof(Node));
	l->head->data = 0;
	l->head->next = NULL;
	l->head->pre = NULL;
	//为这个链表设置三十个节点
	for (ElementType i = 0; i < 30; i++) {
		Node* temp = (Node*)malloc(sizeof(Node));
		temp->data = i + 10;
		temp->next = l->head->next;
		temp->pre = l->head;
		l->head->next = temp;
		l->tail = temp->next;
		l->length++;
	}
	return l;
}
*/

//得到链表长度
ElementType length(bothWayList* L) {
	return L->length;
}
bool Empty(bothWayList* L) {
	return L->length == 0 ? true : false;
}
//按位查找
ElementType LocateElem(bothWayList* L, ElementType e) {
	if (e<1 || e>L->length)
		return -1;
	Node* temp = L->head;
	for (ElementType i = 0; i < e; i++) {
		temp = temp->next;
	}
	return temp->data;
}
//按值查找
Node* getElem(bothWayList* L, ElementType e) {
	if (L->length == 0)
		return NULL;
	Node* temp = L->head;
	ElementType i;
	for (i = 1; temp->data != e; i++) {
		temp = temp->next;
	}
	if (temp == NULL)
		return temp;
}
//在指定位置i插入数据
bool ListInsert(bothWayList* L, ElementType e, ElementType i) {
	if (i<1 || i>L->length + 1)
		return false;
	//不能超过最大长度50
	if (L->length >= MaxSize)
		return false;
	Node* temp = L->head;
	//我们要插入到第i个位置上，那么我们就要找到第i-1位置的数据然后插入在这个i-1位置后的位置
	for (int s = 0; s < i - 1; s++) {
		temp = temp->next;
	}
	Node* newNode = (Node*)malloc(sizeof(Node));
	newNode->data = e;
	newNode->next = temp->next;
	temp->next->pre = newNode;
	newNode->pre = temp;
	temp->next = newNode;
	L->length++;
	return true;
}
//在指定位置上删除数据
bool ListDelete(bothWayList* L, ElementType i) {
	if (i<1 || i>L->length)
		return false;
	if (L->length == 0)
		return false;
	Node* temp = L->head;
	//找到这个位置的上一个节点，让上一个节点的next等于这个节点的next节点；
	for (ElementType s = 0; s < i - 1; s++) {
		temp = temp->next;
	}
	Node* destenateNode = temp->next;
	temp->next = destenateNode->next;
	destenateNode->next->pre = temp;
	free(destenateNode);
	L->length--;
	return true;
}
//打印链表
void printList(bothWayList* L) {
	Node* temp = L->head;
	Node* temp2 = L->tail;
	for (int i = 0; i < L->length; i++) {
		printf("%d\n", temp->next->data);
		temp = temp->next;
	}
	for (int i = 0; i < L->length; i++) {
		printf("%d\n", temp2->data);
		temp2 = temp2->pre;
	}

}
//摧毁链表
void DestroyList(bothWayList* L) {
	if (L == NULL)
		return;
	Node* temp = L->head;
	Node* deTemp;
	while (temp != NULL) {
		deTemp = temp;
		temp = temp->next;
		free(deTemp);
	}
	free(L);
}

双向循环列表

普通链表只能从头到尾遍历链表的节点，但是循环链表可以从整个链表的各个节点开始遍历链表的结点。

实现代码
#ifndef MaxSize
#define MaxSize 50
typedef int ElementType;

typedef struct _node
{
	ElementType data;
	struct _node* next;
	struct _node* pre;
} Node;
typedef struct
{
	//增加一个尾节点，能够增加插入的效率
	Node* tail;
	Node* head;
	int length;
}doubleCircleLinkList;


//使用头插法
doubleCircleLinkList* InitList() {
	//给链表体申请空间
	doubleCircleLinkList* l = (doubleCircleLinkList*)malloc(sizeof(doubleCircleLinkList));
	//申请失败则异常退出程序
	if (l == NULL)
		exit(0);
	//设置初始长度为0，同时申请一个空的表头
	l->length = 0;
	l->head = (Node*)malloc(sizeof(Node));
	l->head->data = 0;
	l->head->next = NULL;
	l->head->pre = NULL;
	l->tail = l->head;
	//为这个链表设置三十个节点
	for (ElementType i = 0; i < 30; i++) {
		//为新的节点开辟空间存储
		Node* temp = (Node*)malloc(sizeof(Node));
		temp->data = i + 10;
		l->tail->next = temp;
		temp->pre = l->tail;
		l->tail = temp;
		l->tail->next = l->head;
		l->head->pre = l->tail;
		l->length++;
	}
	return l;
}
//得到链表长度
ElementType length(doubleCircleLinkList* L) {
	return L->length;
}
bool Empty(doubleCircleLinkList* L) {
	return L->length == 0 ? true : false;
}
//按位查找
ElementType LocateElem(doubleCircleLinkList* L, ElementType e) {
	if (e<1 || e>L->length)
		return -1;
	Node* temp = L->head;
	for (ElementType i = 0; i < e; i++) {
		temp = temp->next;
	}
	return temp->data;
}
//按值查找
Node* getElem(doubleCircleLinkList* L, ElementType e) {
	if (L->length == 0)
		return NULL;
	Node* temp = L->head;
	ElementType i;
	for (i = 1; temp->data != e; i++) {
		temp = temp->next;
	}
	return temp;
}
//在指定位置i插入数据
bool ListInsert(doubleCircleLinkList* L, ElementType e, ElementType i) {
	if (i<1 || i>L->length + 1)
		return false;
	//不能超过最大长度50
	if (L->length >= MaxSize)
		return false;
	Node* newNode = (Node*)malloc(sizeof(Node));
	newNode->data = e;
	//如果插入的位置是最后一个位置的话就直接在表尾添加
	if (i == L->length + 1) {
		L->tail->next = newNode;
		newNode->pre = L->tail;
		L->tail = newNode;
		L->tail->next = L->head;
		L->head->pre = L->tail;
	}
	else {
		//其余位置就采用普通的单链表插入方法
		Node* temp = L->head;
		//我们要插入到第i个位置上，那么我们就要找到第i-1位置的数据然后插入在这个i-1位置后的位置
		for (ElementType s = 0; s < i - 1; s++) {
			temp = temp->next;
		}
		newNode->next = temp->next;
		newNode->pre = temp;
		temp->next->pre = newNode;
		temp->next = newNode;
	}
	L->length++;
	return true;
}
//在指定位置上删除数据
bool ListDelete(doubleCircleLinkList* L, ElementType i) {
	if (i<1 || i>L->length)
		return false;
	if (L->length == 0)
		return false;
	Node* temp = L->head;
	//找到这个位置的上一个节点，让上一个节点的next等于这个节点的next节点；
	for (ElementType s = 0; s < i - 1; s++) {
		temp = temp->next;
	}
	Node* destenateNode = temp->next;
	temp->next = destenateNode->next;
	destenateNode->next->pre = temp;
	free(destenateNode);
	L->length--;
	return true;
}
//打印链表
void printList(doubleCircleLinkList* L) {
	Node* temp = L->head;
	for (ElementType i = 0; i < L->length + 1; i++) {
		printf("%d\n", temp->next->data);
		temp = temp->next;
	}

}
//摧毁链表
void DestroyList(doubleCircleLinkList* L) {
	if (L == NULL)
		return;
	Node* temp = L->head->next;
	Node* deTemp;
	while (temp != L->head) {
		deTemp = temp;
		temp = temp->next;
		free(deTemp);
	}
	free(L->head);
	free(L);
}

顺序表和链表的比较

1.存取方式
顺序表可以顺序存储和随机存储，链表只能从表头顺序存取元素
2.逻辑结构和物理结构
采用顺序表存储，逻辑上相邻的元素，在物理上的存储位置也相邻。而采用链式存储时，逻辑相邻的元素物理存储位置往往不相邻。
3.空间分配
顺序表在静态存储分配时，一旦存储空间满了就不能扩充，继续存储会导致内存溢出。因此预分配需要足够大，但是如果过大会导致内存浪费。动态存储分配可以分配，但需要大量的移动元素，操作效率很低，而且可能内存中没有如此大的连续存储空间，导致分配失败，但是链式存储就不会出现这些问题，只要内存有空间就可以分配

顺序表和链表的选取策略

  • 难以估计存储规模采取链式存储。
  • 建表后需要频繁的插入删除操作时链表的性能更好，选取链表。但是如果需要频繁的查找元素，顺序表更佳
  • 顺序表更容易实现，逻辑上相对简单。

如有错误欢迎留言指正，非常感谢

qq742143797
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线性表（顺序储存）
m0_60610120的博客
06-20 182
动态类型：可以动态增加空间 顺序结构储存线性表 顺序存储 顺序指用一组地址连续的储存单元依次存储数据元素，数据元素之间的关系是一对一的关系优点：可以随机存取线性表中任一元素缺点：插入和删除操作所移动的元素较多静态类型的长度固定，动态类型不够存放可以加上一部分分别给出了静态以及动态的常用函数实现，以代码可以作为测试用......
线性表的详解
最新发布
gongjunbox的博客
12-04 8472
线性表是算法题命题的重点。这类算法题实现起来比较容易且代码量较少，但是要求具有最优的性能（时间复杂度、空间复杂度)，才能获得满分。因此，应牢固掌握线性表的各种基本操作（基于两种存储结构)，在平时的学习中多注重培养动手能力。另外，需要提醒的是，算法最重要的是思想!考场上的时间紧迫，在试卷上不一定要求代码具有实际的可执行性，因此应尽力表达出算法的思想和步骤，而不必过于拘泥每个细节。注意算法题只能用C/C++语言实现。
数据结构与算法——线性表（链表篇）
热门推荐
小田是个程序员的博客欢迎你的到来呀~
06-20 2万+
本篇文章，主要详细解读和总结线性表的链式存储结构——链表，包括单链表、双链表、静态链表以及循环链表，讲解较为全面，图文并茂，总结各链表的特性以及基本操作，干货满满，各位小伙伴们请细细品读，你会收获你想要的知识的！.........
数据结构003 - 线性表（单链表）
疯狂的豆子的博客
04-20 1175
数据结构003 - 线性表（单链表）
数据结构——线性表的实现.zip
09-18
本资料包“数据结构——线性表的实现.zip”着重介绍了线性表的两种常见实现方式：链表和数组。 1. 链表实现： 链表是一种物理存储单元非连续、非顺序的存储结构，它通过节点间的指针链接来表示元素之间的逻辑关系...
数据结构——线性表(选择题).docx
07-11
数据结构——线性表（选择题） 1.线性表是（）。 简单，线性表的概念与性质，02702001 [单选题] A、一个有限序列，可以为空(正确答案) B、一个无限序列，不可以为空 C、一个无限序列，可以为空 D、一个无限序列，不...
数据结构-线性表及其实现
04-09
数据结构的讲义之线性表及其实现
线性表
06-08
线性表线性表线性表线性表线性表线性表线性表线性表线性表线性表线性表线性表线性表线性表线性表线性表
线性表顺序结构申请动态空间学生管理C++
03-09
C++实现简易学生管理系统，可添加删除。
数据结构——线性表类模板
12-19
数据结构——线性表类模板 数据结构——线性表类模板 数据结构——线性表类模板
数据结构线性表
02-26
数据结构线性表课件 讲述线性表的定义等
数据结构——线性表分享.pdf
01-01
数据结构——线性表分享 一、顺序存储结构 在数据结构中，顺序存储结构是一种常用的存储方式，它将线性表的每个元素存储在一块连续的存储空间中。这种存储方式的优点是可以快速访问任意一个元素，但缺点是插入或...
线性表，线性表和链表的区别
weixin_30588729的博客
09-21 2302
存储类别 顺序存储结构单链表 存储分配方式 用一段连续的存储单元依次存储线性表的数据元素 采用链式存储结构，用一组任意的存储单元存放线性表的元素 时间性能 查找O（1）、插入和删除O（n） 查找O（n）、插入和删除O（1） 空间性能 需要预分配存储空间，分大了浪费，小了容易发生上溢 不需要分配存储空间，只要有就可以分配，元素个数不受限制...
【线性表】动态分配空间的实现
weixin_30843605的博客
03-27 356
实现了一个简易的动态分配内存的线性表结构，实现了插入、删除、重载赋值运算符、拷贝构造函数（有bug，编译不过去） 1 2 #ifndef NULL 3 #define NULL 0 4 #endif 5 6 template<class T> 7 class CSQList 8 { 9 public: 10...
2.1线性表的概述
09-10
根据王红梅教材《数据结构》C++版，第二章线性表的第一讲。主要介绍线性表的基本知识，如线性表逻辑结构特点、线性表的存方法、线性表的抽象数据定义等概念性知识。
U201614532 吕鹏泽2
08-08
2.置表长为0 2.置表指针为空操作结果：销毁线性表L时间复杂度：O(1)流程图：图1-5 DestroyList()流程图ClearList(&L)算法思想：

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值