数据结构之线性表

最新推荐文章于 2024-10-17 20:50:47 发布
最新推荐文章于 2024-10-17 20:50:47 发布
阅读量190 收藏
点赞数 4
分类专栏： 笔记 c语言笔记 文章标签： 数据结构 链表 算法 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56551150/article/details/117263857
版权
本文详细介绍了线性表的两种常见实现方式：顺序表和链表。顺序表包括静态和动态两种，前者使用固定大小数组，后者使用动态分配内存。链表分为单链表和双向链表，它们在存储和操作上各有特点，如链表支持快速插入删除但不支持随机访问。文章还提供了各种操作的实现代码，并分析了它们的时间复杂度和优缺点。
摘要由CSDN通过智能技术生成

前言
线性表是最常用且最简单的一种数据结构。简言之，一个线性表是n 个数据元素的有限序列。线性表在逻辑上是一种线性结构，也就是说连续的一条直线，但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构存储。

目录

二、线性表

2.1顺序表

2.1.1顺序表的实现

  • 概念及结构
    顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构一般情况下采用数组存储。在数组上完成增删查改。
    在这里插入图片描述

  • 顺序表一般可以分为：
    1.静态顺序表：使用定长数组存储。

#define N 100
typedef int SQDataType;//定义数据类型
typedef struct SeqList
{
    SQDataType array[N];//数组长度
    size_t size;//有效数据的个数
}SeqList;

静态顺序表的初始化、增、删、查、改等基本操作：

void SeqListInit(SeqList* psl)//初始化，传地址
{
    memset(psl->a,0,sizeof(SQDataType)*N);
    psl->size=0;
}
//头插
void SeQListPushBack(SeqList* psl,SQDataType x)
{
    if(psl->size>=N)
    {
        printf("SeqList is Full");
        return;
    }
    psl->a[psl->size]=x;
    psl->size++;
}

问题：给少了不够用，给多了造成浪费
2.动态顺序表：使用动态开辟的数组存储。

typedef int SLDataType;
typedef struct SeqList
{
	SLDataType* a;
	int size;//有效数据的个数
	int capacity;//容量		
}SL;

动态顺序表的初始化、增、删、查、改等基本操作：

void SeqListInit(SL* ps)
{
	ps->a = NULL;
	ps->size = 0;
	ps->capacity = 0;	
}
void SeqListPushBack(SL* ps, SLDataType x)//尾插
{
	SeqListCheak(ps);//检查是否需要扩容
	ps->a[ps->size] = x;
	ps->size++;
}
void SeqListPrint(SL* ps)//打印
{
	assert(ps->size>0);
	for (int i = 0;i < ps->size;++i)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}
void SeqListCheak(SL* ps)//检查是否需要扩容
{
	if (ps->size >= ps->capacity)
	{
		ps->capacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		ps->a = (SLDataType*)realloc(ps->a, sizeof(SLDataType) * ps->capacity);
		if (ps->a == NULL)
		{
			printf("扩容失败\n");			
			exit(-1);
		}
	}
}
void SeqListPopBack(SL* ps)//尾删
{
	assert(ps->size>0);
	//ps->a[ps->size - 1];//无意义
	ps->size--;
}
void SeqListPushFront(SL* ps, SLDataType x)//头插
{
	SeqListCheak(ps);
	int end = ps->size-1;
	while (end >= 0)
	{
		ps->a[end + 1] = ps->a[end];
		--end;
	}
	ps->a[0] = x;
	ps->size++;
}
void SeqListPopFront(SL* ps)//头删
{
	int start = 0;
	while (start<=ps->size-1)
	{
		ps->a[start] = ps->a[start+1];
		++start;
	}	
	ps->size--;
}
void SeqListInsert(SL* ps, int pos, SLDataType x)//任意位置的插入删除
{
	assert(pos<=ps->size);
	SeqListCheak(ps);
	int end = ps->size - 1;
	while (end >= pos-1)
	{
		ps->a[end + 1] = ps->a[end];
		--end;
	}
	ps->a[pos-1] = x;
	ps->size++;

}
void SeqListErase(SL* ps, int pos)
{
	assert(pos < ps->size);
	int start = pos-1;
	while (start <= ps->size - 1)
	{
		ps->a[start] = ps->a[start + 1];
		++start;
	}
	ps->size--;
}
void SeqListFind(SL* ps, SLDataType x)//顺序表查找
{
	for (int i = 0;i < ps->size;++i)
	{
		if (ps->a[i] == x)
		{
			printf("找到了，下标是%d \n", i);
			return i;
		}
	}
	return -1;
}
void SeqListSort(SL* ps)//顺序表的排序
{
	for (int i = 0;i < ps->size - 1;++i)
	{
		int flag = 1;
		for (int j = 0;j < ps->size - 1 - i;++j)
		{
			if (ps->a[j] > ps->a[j + 1])
			{
				int tmp = ps->a[j];
				ps->a[j] = ps->a[j + 1];
				ps->a[j + 1] = tmp;
				flag = 0;
			}
		}	
		if (flag == 1)
			break;
	}

}
void SeqListBinaryFind(SL* ps,SLDataType x)//二分查找
{
	int left = 0;
	int right = ps->size-1;
	int mid = 0;
	while (left <= right)
	{
		mid = (left + right) / 2;
		if (ps->a[mid] < x)
		{
			left = mid + 1;
		}
		else if (ps->a[mid]> x)
    	{
			right = mid -1;
		}
		else
		{
			printf("找到了下标是 %d \n",mid);
			break;
		}
	}
}
void SeqListDestroy(SL* ps)//顺序表摧毁
{
	free(ps->a);
	ps->size = 0;
	ps->capacity = 0;

}
  • 插入算法的时间复杂度分析：
    问题的规模为表的长度n。算法的时间复杂度主要花费在向后移动元素的循环语句上。该语句重复执行*（n-i+1）*次。

2.1.2顺序表刷题

问题一：
给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。
不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

来源：力扣（LeetCode）

int removeElement(int* nums, int numsSize, int val)
{
    
        int res = 0;
        for(int i = 0 ; i < numsSize; i++)
        {
            if(nums[i] == val)
            {
                
            }
            else
            {
                nums[res] = nums[i];
                res++;
            }
        }
        return res;
}

思路分析：
用i遍历数组，用res指向第一个位置，如果不是val则把值给给res指向位置res++。
问题二：
给你两个有序整数数组 nums1 和 nums2，请你将 nums2 合并到 nums1 中，使 nums1 成为一个有序数组。
初始化 nums1 和 nums2 的元素数量分别为 m 和 n 。你可以假设 nums1 的空间大小等于 m + n，这样它就有足够的空间保存来自 nums2 的元素。

void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n)
{
    int* newNum=(int *)malloc(sizeof(int)*(m+n));
    int i=0;
    int j=0;
    int min=0;
    while(i<m&&j<n)
    {
        if(nums1[i]<nums2[j])
        {
            newNum[min++]=nums1[i++];             
        }
        else
            newNum[min++]=nums2[j++];
    }
    if(i<m)
    {
        while(i<m)
        {
            newNum[min]=nums1[i];
            i++;
            min++;
        }

    }
    if(j<n)
    {
        while(j<n)
        {
            newNum[min]=nums2[j];
            j++;
            min++;
        }
    }
    for(int k=0;k<m+n;++k)
    {
        nums1[k]=newNum[k];
    }

}

来源：力扣（LeetCode）

思路分析：
开辟一个新的数组numNum，依此取出num1，num2中较小者，给给numNum，最后将num1或num2剩余元素给给numNum。

2.1.3顺序表分析

  1. 缺陷：
    1.如果空间不够增容。会造成一定的性能消耗，其次会造出一定的空间浪费。
    2.头部或者中间插入删除效率低。

2.2链表

链表：

  1. 空间上，按需给空间
  2. 不要求物理空间连续
    在这里插入图片描述

2.2.1链表的概念及结构

概念：链表是一种物理存储结构上非连续、非顺序·的存储结构，数据元素的逻辑结构是通过链表中的指针链接次序实现的。
逻辑结构：
在这里插入图片描述

2.2.2单链表的实现及基本操作

  • 单链表
typedef int SListDataType;
typedef struct SListNode
{
	SListDataType data;
	struct SListNode* next;
}SListNode;
  • 基本操作
SListNode* BuySListNode(SListDataType x)//申请结点
{
	SListNode* NewNode = (SListNode*)malloc(sizeof(SListNode));
	if (NewNode == NULL)
	{
		printf("申请内存失败");
		exit(-1);
	}
	NewNode->data = x;
	NewNode->next = NULL;
	return NewNode;
}
void SLPushBack(SListNode** pphead,SListDataType x)//链表尾插法
{
	SListNode* NewNode = BuySListNode(x);
	if (*pphead == NULL)
	{
		*pphead = NewNode;
	}
	else
	{
		SListNode* tail = *pphead;//找尾
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
		tail->next = NewNode;
	}
}
void SLPushPop(SListNode** pphead)//链表尾删法
{
	if (*pphead == NULL)
	{
		return;
	}
	else if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SListNode* prev = NULL;
		SListNode* tail = *pphead;
		while (tail->next != NULL)
		{
			prev = tail;
			tail = tail->next;
		}
		free(tail);
		prev->next = NULL;
	}

}
void SListPrint(SListNode* phead)//遍历打印链表
{
	SListNode* cur = phead;
	while (cur != NULL)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL");
	printf("\n");
}
void SListPushFront(SListNode** pphead, SListDataType x)//头插法
{
	SListNode* NewNode = BuySListNode(x);
	if (*pphead == NULL)
	{
		*pphead = NewNode;
	}
	else
	{
		//SListNode* head = *pphead;
		NewNode->next = *pphead;
		*pphead = NewNode;
	}
}
void SListPopFront(SListNode** pphead)//头删法
{
	if (*pphead == NULL)
	{
		return;
	}
	else if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SListNode* head = (*pphead)->next;
		free(*pphead);
		(*pphead)->next = NULL;
		*pphead = head;
	}
}
void SListDelete(SListNode** pphead,int i)//任意位置删除
{
	SListNode* prev = NULL;
	SListNode* cur = *pphead;
	int size = 0;
	while (size<=i)
	{
		prev = cur;
		cur = cur->next;
		++size;
	}
	assert(i >= 0 && i <= size);
	if (*pphead == NULL)
	{
		return;
	}
	else
	{
		prev = cur->next;
		free(cur);
		cur->next = NULL;
		
	}
}

单链表存在缺陷：
在这里插入图片描述

2.3双向链表

2.3.1双向链表基本介绍

带头结点，不需要改变传过来的指针，也就是意味着不需要传二级指针

2.3.2双向链表的实现

typedef int LTDataType;
typedef struct ListNode
{
	struct ListNode* next;//尾指针
	struct ListNode* prev;//头指针
	LTDataType data;
}ListNode;

2.3.3双向链表的基本操作

void ListInit(ListNode** pphead)//初始化双向链表
{
	*pphead = BuyListNode(0);
	(*pphead)->next = *pphead;
	(*pphead)->prev = *pphead;
}
void ListPushBack(ListNode* phead, LTDataType x)//尾插
{
	assert(phead);//判断是否为空
	ListNode* tail = phead->prev;
	ListNode* newNode = BuyListNode(x);
	tail->next = newNode;
	newNode->prev = tail;
	newNode->next = phead;
	phead->prev = newNode;
}
ListNode* BuyListNode(LTDataType x)//创建新的结点
{
	ListNode* node = (ListNode*)malloc(sizeof(ListNode));
	node->next = NULL;
	node->prev = NULL;
	node->data = x;
	return node;
}
void ListNodePrint(ListNode* phead)//打印链表
{
	assert(phead);
	ListNode* cur = phead->next;
	while (cur != phead)
	{
		printf("%d ", cur->data);
		cur = cur->next;
	}
	printf("\n");
}
void ListPopBack(ListNode* phead)
{
	assert(phead);
	assert(phead->next != phead);
	ListNode* tail = phead->prev;
	ListNode* tailPrev = tail->prev;
	free(tail);
	tail = NULL;
	phead->prev = tailPrev;
	tailPrev->next = phead;
}
void ListPushFront(ListNode* phead, LTDataType x)//头插
{
	assert(phead);
	ListNode* first = phead->next;
	ListNode* newNode = BuyListNode(x);
	phead->next = newNode;
	newNode->prev = phead;
	first->prev = newNode;
	newNode->next = first;
}
void ListPopFront(ListNode* phead)//头删
{
	assert(phead);
	assert(phead->next != phead);
	ListNode* first = phead->next;
	ListNode* second = first->next;
	phead->next = second;
	second->prev = phead;
	free(first);
	first = NULL;
}
ListNode* ListFind(ListNode* phead, LTDataType x)
{
	assert(phead);
	ListNode* cur = phead->next;
	while (cur != phead)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}
void ListInsert(ListNode* pos, LTDataType x)
{
	assert(pos);
	ListNode* posPrev = pos->prev;
	ListNode* newNode = BuyListNode(x);
	posPrev->next = newNode;
	newNode->prev = posPrev;
	newNode->next = pos;
	pos->prev = newNode;
}
void ListErase(ListNode* pos)
{
	assert(pos);
	assert(pos->next != pos);
	ListNode* posPrev = pos->prev;
	ListNode* posNext = pos->next;
	free(pos);
	pos = NULL;
	posPrev->next = posNext;
	posNext->prev = posPrev;
}
void ListDestory(ListNode* phead)
{
	assert(phead);
	ListNode* cur = phead->next;
	while (cur != phead)
	{
		ListNode* next = cur->next;
		free(cur);
		cur = next;
	}

	free(phead);
	phead = NULL;
}

双向链表的结构虽然复杂了，但是操作反而简单了

2.3顺序表与链表分析

  • 顺序表：
    优点：
    空间连续、支持随机访问
    缺点：
    中间或前面部分插入时间复杂度O（n）
    增容代价较大

  • 链表（带头双向循环）
    缺点：以结点为储存单位，不支持随机访问
    优点：
    任意位置插入删除时间复杂度为O（1）
    没有增容消耗，按需申请节点空间，不用了直接释放。

但愿此生，从未邂逅
关注
专栏目录
数据结构之线性表讲解，助力软件设计师考试
08-11
数据结构之线性表讲解，助力软件设计师考试数据结构之线性表讲解，助力软件设计师考试数据结构之线性表讲解，助力软件设计师考试数据结构之线性表讲解，助力软件设计师考试数据结构之线性表讲解，助力软件设计师考试...
数据结构之线性表.rar
04-07
在本资料“数据结构之线性表.rar”中，我们将探讨如何使用C++实现线性表，并涵盖增、删、改、查等基本操作。 1. **线性表的概念**： 线性表的每个元素都有一个唯一的序号，称为位置或者索引。元素之间存在一对一的...
数据结构——线性表
manxianglin的博客
01-09 678
数据结构——线性表 概念介绍 线性表是一种最简单常用的基本数据结构，线性表在计算机中可以用顺序存储和链式存储 两种存储结构表示。用顺序存储结构表示的线性表为顺序表，用链式存储结构表示的线性表为链表 。 线性表是由n（n>=0）个数据元素所构成的有限序列，通常表示为（a0,a1,…,ai,…an-1),i表示位序号，n表示线性表的表长。所以我们所熟知的数组就是一种线性表。 线性表的抽象类型描述 1、什么是抽象类型描述？ 抽象数据类型包含一般数据类型的概念，但含义比一般数据类型更广、更抽象。抽象数据类型通
数据结构：线性表之顺序表和链表（Java实现）
sc179的博客
12-24 473
1 线性表简介 线性表是最基本、最简单、也是最常用的一种数据结构，一个线性表是若干个具有相同特性的数据元素的有限序列； 数据元素之间具有一种“一对一”的逻辑关系； 前驱元素：若A元素在B元素的前面，则称A为B的前驱元素； 后继元素：若B元素在A元素的后面，则称B为A的后继元素； 第一个数据元素没有前驱，这个数据元素被称为头结点； 最后一个数据元素没有后继，这个数据元素被称为尾结点； 除了第一个和最后一个数据元素外，其他数据元素有且仅有一个前驱和一个后继； 2 线性表分类 线性表数据存储的方式有两种：顺序
实验一 线性表的顺序存储与实现_数据结构-链表（链表的基本实现C++）
weixin_39677203的博客
11-20 224
​线性表是最常用而且简单的一种数据结构，一个线性表是n个数据元素的有限序列。当线性表需要频繁查找，较少插入和删除时，通常采用顺序存储结构，若需要频繁插入和删除，通常采用基于链表的形式；当线性表的元素个数变化较大或不确定时，最好用链表，这样不需要考虑存储空间大小问题，当事先知道线性表的大小长度，用顺序存储结构效率会高一些。1、线性表的顺序表示和实现顺序表，基于数组的一种实现，一组地址连续的存储单元。...
数据结构--线性表
qq_45189707的博客
12-16 228
1、前言 线性表是最常用且是最简单的一种数据结构。形如：A1、A2、A3….An这样含有有限的数据序列，我们就称之为线性表。 2、线性表的两种表示形式 ①顺序表示（其实就是数组） ②链表表示（单项/双向，带头/不带头，循环/不循环） 可组成八种不同的链表形式 3 、 最简单基本的不带头单项不循环链表 ①基本运算的实现 #include<stdio.h> #include<stdl...
python数据结构之线性表
m0_71417856的博客
04-12 1445
python线性表的一些基本操作，包括顺序表和单链表
数据结构之线性表的应用——完整代码实现
weixin_64618739的博客
11-15 1583
数据结构之线性表的应用——完整代码实现
数据结构之线性表插入与删除运算
AIMing_byte的博客
02-19 1728
线性表，或称表，是一种非常灵便的结构，可以根据需要改变表的长度，也可以在表中任何位置对元素进行访问、插入或删除等操作。另外，还可以将多个表连接成一个表，或把一个表拆分成多个表。例如，26个英文字母的字母表：（A，B，C，......，Z）就是一个线性表，表中的数据元素是单个字母。在稍复杂的线性表中，一个数据元素可以包含若干个数据项。例如在学生基本信息表中，每个学生为一个数据元素，包括学号、姓名、性别、籍贯、专业等数据项。
数据结构之线性表 Python实现
525小白菜的博客
07-12 2209
Python实现线性表
数据结构之线性表教程3.zip
01-02
在这个“数据结构之线性表教程3.zip”压缩包中，很可能是对线性表的深入讲解和实践应用的资源集合。 线性表是一种一维数组结构，其中的元素按照特定顺序排列。每个元素都有一个唯一的索引，通常从0或1开始。线性表...
数据结构之线性表的实现.rar
07-27
在这个压缩包“数据结构之线性表的实现.rar”中，我们可以找到关于线性表实现的详细内容，特别是针对严蔚敏版数据结构的实现。 线性表的常见实现方式有两种：顺序表和链表。在顺序表中，元素在内存中是连续存储的，...
数据结构之线性表的定义 定义线性表节点的结构.pdf
04-18
数据结构之线性表的定义和结构 数据结构是计算机科学中的一门重要学科，它研究的是数据的存储、组织和操作，旨在提高数据处理的效率和性能。在数据结构中，线性表是最基本和最重要的一种数据结构形式。本文将详细...
【数据结构】宜宾大学-计院-实验三
2303_80737493的博客
10-17 769
线性表的应用——实现两多项式的相加 课前准备： 实验学时：2 实验目的： 实验内容： 实验结果： 实验报告:（及时撰写实验报告） 实验测试结果： 代码实现：（C/C++）【含注释】
《数据结构》学习系列——树（中）
Kenjuan的博客
10-17 1184
通过遍历二叉树可得到一个结点的一个线性序列，在线性序列中，除第一个结点外, 每个结点有且仅有一个前驱，除最后一个结点外，每个结点有且仅有一个后继，但是在二叉树中只能找到结点的左孩子、右孩子，结点在线性序列中的前驱和后继只有在遍历过程中才能得到为了与结点在二叉树中所具有的前驱(即父结点)和后继(即子结点)区别开来，通常把某种序列中结点的前驱或后继冠以某种遍历的名称，如把中根序列中结点的前驱称作中根前驱，结点的后继称作中根后继设 T是由增加某种遍历顺序的线索域的结点所构成的一棵二叉树，在 T。
数据结构 —— 链式二叉树（C语言讲解）
最新发布
知其然 知其所以然
10-17 1100
本篇文章主要讲解链式存储的二叉树，如果读者不清楚二叉树的基础知识，推荐阅读数据结构——树和二叉树简介。对于二叉树这种数据结构的学习，重点不是增删改查，而是学习这种结构，所以，主要讲解一些链式二叉树的操作。
结构体通讲——数据结构解惑
weixin_73236117的博客
10-17 473
结构：一个变量里包含很多变量。
数据结构之线性表详解：顺序表和链表
线性表是数据结构中的一种基本结构，指的是n（≥0）个数据元素的有限序列。线性表的特点是：同一线性表中元素具有相同特性；相邻数据元素之间存在序偶关系；除第一个元素外，其他每一个元素有一个且仅有一个直接前驱...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值