数据结构 线性表

最新推荐文章于 2024-01-09 14:03:48 发布
最新推荐文章于 2024-01-09 14:03:48 发布
阅读量817 收藏 11
点赞数 5
分类专栏： 数据结构及算法 文章标签： 链表 线性表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/GarfieldGCat/article/details/89422726
版权

文章目录

概述

线性表是最常用、最简单的数据结构，其主要的特点就是元素间呈现线性关系，即“一个接一个的排列”。一般采用顺序或链式存储。

定义

一个线性表是 n ( n ≥ 0 ) n(n \geq 0) n(n≥0)个元素的有限序列，通常表示为 a 1 , a 2 , … , a n a_1, a_2, \dots, a_n a1​,a2​,…,an​，其定义如下：

  1. 存在唯一的“第一个”元素
  2. 存在唯一的“最后一个”元素
  3. 除“第一个”元素外，任一元素都只有一个直接前驱
  4. 除“最后一个”元素外，任一元素都只有一个直接后继

线性表的顺序存储

这是最常用的方式，即用一组地址连续的空间依次存储线性表，在编程中“数组”即是最简单的线性表。

以 L O C ( a 1 ) LOC(a_1) LOC(a1​)表示线性表中第一个元素

在顺序存储结构中，第 i i i个元素 a i a_i ai​的存储位置为： L O C ( a i ) = L O C ( a 1 ) + ( i − 1 ) × B y t e s （ 每 个 元 素 所 需 空 间 的 字 节 数 ） LOC(a_i) = LOC(a_1) + (i-1) \times Bytes（每个元素所需空间的字节数） LOC(ai​)=LOC(a1​)+(i−1)×Bytes（每个元素所需空间的字节数）。

可以看出，顺序存储最大的优点即随机存储(Random Access)，访问任一位置的元素都可以直接计算出地址，无需额外寻址的过程。

但由于连续的关系，其缺点均体现在删除、插入操作上，这俩操作都需要耗费大量的时间移动元素（以满足顺序存储的特性）。在表长为 n n n的线性表插入元素时，共有 n + 1 n+1 n+1个位置可选，在位置 a 1 a_1 a1​插入则需要将整个线性表后移以空出第一位；而在位置 a n + 1 a_{n+1} an+1​插入则无需移动任一元素；

定 P i P_i Pi​是在第 i i i个元素前插入一个元素的概率， Q i Q_i Qi​是删除第 i i i个元素的概率，可以假定在线性表任何位置上插入、删除都是等概率的，即：
P i = 1 n + 1 , Q i = 1 n P_i = \frac{1}{n+1}, \quad Q_i = \frac{1}{n} Pi​=n+11​,Qi​=n1​
每次插入、删除操作需要移动的元素个数期望值 E i n s e r t 、 E d e l e t e E_{insert}、E_{delete} Einsert​、Edelete​如下：

E i n s e r t = ∑ i = 1 n + 1 P i × ( n − i + 1 ) = 1 n + 1 ∑ i = 1 n + 1 ( n − i + 1 ) = n 2 E d e l e t e = ∑ i = 1 n Q i × ( n − i ) = 1 n ∑ i = 1 n ( n − i ) = n − 1 2 \begin{aligned} E_{insert} =& \sum_{i=1}^{n+1} P_i \times (n-i+1) \\ =& \frac{1}{n+1} \sum_{i=1}^{n+1}(n-i+1)\\ =& \frac{n}{2} \\ E_{delete} =& \sum_{i=1}^{n} Q_i \times (n-i)\\ =& \frac{1}{n} \sum_{i=1}^{n} (n-i) \\ =& \frac{n-1}{2} \end{aligned} Einsert​===Edelete​===​i=1∑n+1​Pi​×(n−i+1)n+11​i=1∑n+1​(n−i+1)2n​i=1∑n​Qi​×(n−i)n1​i=1∑n​(n−i)2n−1​​

线性表的链式存储

所谓链式，即存储的实际形式宛如链条，并不是物理上的连续，但逻辑上它仍是线性的，编程中“链表”即其实现。

在链式结构中，以结点为单位存储元素，其结构如下：

Linked list node

其中，数据域存储元素，指针域存储当前结点的前驱或后继结点的位置信息。

链式存储的结点并不要求空间是连续的，因此每个结点都需要额外存储结点之间的逻辑关系。

与顺序存储比较，链式的优点主要有：占用空间灵活，无需连续的地址，当需要一个新的结点时再申请；插入和删除无需移动大量元素，只需要将逻辑上相邻的结点的指针域修改即可；但缺点在于没有随机访问能力，由第一个（头结点）往后逐个访问；其次需要额外的空间保存指针信息；

还有特殊的表现形势如双链表、循环链表等，前者主要优势在于提供了倒序访问能力，但缺点显而易见，需要多保存一个指针。后者则在特殊场景中应用方便，符合逻辑。

其具体的逻辑体现如下图：

Linklist structure

图片来自互联网

C语言实现

顺序存储

很早以前学习的时候曾经做过比较完整的基于数组的线性表，但没实现为存储类型无关，供参考，其分为了三个文件：

  • Linear_list.c 函数的实现
  • Linear_list.h 函数头文件，包含函数功能及其说明
  • Linear_list_elemset.h 定义数据类型，用户可在此处定义线性表存储的数据类型
//Linear_list_elemset.h
#ifndef _LINEAR_LIST_ELEMSET_H_
#define _LINEAR_LIST_ELEMSET_H_
#define NAMELEN 20
/* 
	在下面定义数据域，示例：
	typedef int Linear_ElemSet_Data;
			or
	typedef struct {
		int a;
		char b;
		char Name[20];
	} Linear_ElemSet_Data;
*/

typedef struct {
	unsigned short Stu_Id;
	float Stu_Score[3];
	float Stu_Total;
	char Name[NAMELEN];
} Linear_ElemSet_Data;

/* 下方为内部实现需要，不能更改 */
typedef struct {
	Linear_ElemSet_Data *Elem;
	unsigned int List_length;
	unsigned int List_pit;
	unsigned int List_realloc;
	unsigned int List_BufferLen;
} Linear_ElemSet;

typedef Linear_ElemSet LinearList;
typedef Linear_ElemSet_Data LinearListData;
#endif

//Linear_list.h
#ifndef _LINEAR_LIST_H_
#define _LINEAR_LIST_H_
#include "Linear_list_elemset.h"
/*  
	数据结构 2.1 线性表
	建立时间：2015-4-13
	概述：
		线性表(Linear list)是最常用且最简单的一种数据结构。简言之，一个线性表是n个数据元素的有限序列。
	至于每个数据元素的具体含义，在不同的情况下各不相同，它可以是一个数或者是一个符号，也可以是一页
	书，甚至其他更复杂的信息。

	D={ Ai | Ai∈ElemSet, i=1,2,…,n, n≥0 }
	R={ <Ai-1, Ai> | Ai-1, Ai∈D, i=2,…,n }
*/
#define FALSE FALSE
#define TRUE TRUE
typedef enum STATE
{ 
	FALSE, TRUE 
}state;

state LINEAR_InitList( Linear_ElemSet *L , int count );
	//初始化线性表
	//操作结果：构造一个空的线性表L，count为线性表长度阀值(不得低于10)，当数据量超出会自动扩展一倍，返回state表示操作是否成功
state LINEAR_DestroyList( Linear_ElemSet *L );
	//销毁线性表
	//初始条件：线性表L已存在
	//操作结果：销毁线性表L，返回state表示操作是否成功
state LINEAR_ClearList( Linear_ElemSet *L );
	//重置(清空)线性表
	//初始条件：线性表L已存在
	//操作结果：将L重置为空表，返回state表示操作是否成功
__inline state LINEAR_ListEmpty( Linear_ElemSet L ) { return L.List_length == 0 ? TRUE: FALSE; }
	//检查线性是否为空
	//初始条件：线性表L已存在
	//操作结果：若L为空表，则返回TRUE，否则返回FALSE
__inline int LINEAR_ListLength( Linear_ElemSet L ) { return L.List_length; }
	//返回线性表长度
	//初始条件：线性表L已存在
	//操作结果：返回L中数据元素个数
state LINEAR_ListEmpty( Linear_ElemSet L );
	//检查线性是否为空
	//初始条件：线性表L已存在
	//操作结果：若L为空表，则返回TRUE，否则返回FALSE
int LINEAR_ListLength( Linear_ElemSet L );
	//返回线性表长度
	//初始条件：线性表L已存在
	//操作结果：返回L中数据元素个数
state LINEAR_GetElem( Linear_ElemSet L, int i, Linear_ElemSet_Data *e );
	//获取元素
	//初始条件：线性表L已存在，1≤i≤ListLength(L)
	//操作结果：用e返回L中第i个数据元素的值。并返回state表示操作是否成功
int LINEAR_LocateElem( Linear_ElemSet L, Linear_ElemSet_Data e, int (*compare)(Linear_ElemSet_Data, Linear_ElemSet_Data) );
	//定位元素
	//初始条件：线性表L已存在，compare()是数据元素的判定函数(返回0为FALSE,其余为TRUE)
	//操作结果：返回L中第1个与e满足关系compare()的数据元素的位序，若这样的数据元素不存在，则返回值为0
state LINEAR_PriorElem( Linear_ElemSet L, int i, Linear_ElemSet_Data *pre_e );
	//返回目标元素的前一个元素
	//初始条件：线性表L已存在，2≤i≤ListLength(L)
	//操作结果：用pre_e返回L中第i个数据元素的前一个元素的值。并返回state表示操作是否成功
state LINEAR_NextElem( Linear_ElemSet L, int i, Linear_ElemSet_Data *next_e );
	//返回目标元素的后一个元素
	//初始条件：线性表L已存在，1≤i≤( ListLength(L) - 1 )
	//操作结果：用next_e返回L中第i个数据元素的后一个元素的值，并返回state表示操作是否成功
int LINEAR_ListAddElem( Linear_ElemSet *L, Linear_ElemSet_Data e );
	//为线性表添加一个元素
	//初始条件：线性表L已存在
	//操作结果：在L中的尾部插入一个新的数据元素e，L的长度加1。并返回添加后线性表长度
state LINEAR_ListInsert( Linear_ElemSet *L, int i, Linear_ElemSet_Data e );
	//为线性表插入一个元素
	//初始条件：线性表L已存在，1≤i≤( ListLength(L) +1 )
	//操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1。并返回state表示操作是否成功
state LINEAR_ListDelete( Linear_ElemSet *L, int i, Linear_ElemSet_Data *e );
	//为线性表删除一个元素
	//初始条件：线性表L已存在且非空，1≤i≤ListLength(L)
	//操作结果：删除L的第i个元素，并用e返回被删除元素的值，L的长度减1。并返回state表示操作是否成功
state LINEAR_ListElemCover( Linear_ElemSet *L, int i, Linear_ElemSet_Data *e );
	//对线性表一个指定元素执行覆盖
	//初始条件：线性表已存在且非空，1≤i≤ListLength(L)
	//操作结果：使用e覆盖L的第i个元素，返回state表示操作是否成功
state LINEAR_ListTraverse( Linear_ElemSet L, int (*visit)(Linear_ElemSet_Data) );
	//历遍线性表
	//初始条件：线性表L已存在且非空
	//操作结果：依次对线性表里的每一个数据元素执行visit()函数，一旦visit返回0(FALSE)，则操作失败。并返回state表示操作是否成功
#endif

//Linear_list.c
#include "Linear_list.h"
#include <malloc.h>
#include <stdio.h>

static state LINEAR_ReallocList( Linear_ElemSet *L )
{
	Linear_ElemSet_Data *pNew = ( Linear_ElemSet_Data *) realloc( (*L).Elem, sizeof(Linear_ElemSet_Data) * ( (*L).List_pit + (*L).List_pit * (*L).List_realloc ) );
	if( pNew == NULL )
		return FALSE;

	(*L).Elem = pNew;
	(*L).List_BufferLen += (*L).List_pit;
	(*L).List_realloc++;
	return TRUE;
}

state LINEAR_InitList( Linear_ElemSet *L , int count )
{
	(*L).List_length = 0;
	(*L).List_pit = count;
	(*L).List_realloc = 1;
	(*L).List_BufferLen = count;

	if( count < 10 )
	{
		fprintf( stderr, "LINEAR_InitList Function Error\n" );
		fprintf( stderr, "the List Pit can't lower than 10\n" );
		return FALSE;
	}

	if( ( (*L).Elem = ( Linear_ElemSet_Data *) malloc( sizeof(Linear_ElemSet_Data) * (*L).List_pit ) ) == NULL )
	{
		fprintf( stderr, "LINEAR_InitList Function Error\n" );
		fprintf( stderr, "Can't allocate Memory!\n" );
		return FALSE;
	}
	return TRUE;
}
	//初始化线性表
	//操作结果：构造一个空的线性表L，count为线性表长度阀值(不得低于10)，当数据量超出会自动扩展一倍，返回state表示操作是否成功
state LINEAR_DestroyList( Linear_ElemSet *L )
{
	if( (*L).Elem == NULL )
	{
		fprintf( stderr, "LINEAR_DestroyList Function Error\n" );
		fprintf( stderr, "This Linear has been free!\n" );
		return FALSE;
	}
	free( (*L).Elem );
	(*L).List_length = 0;
	return TRUE;
}
	//销毁线性表
	//初始条件：线性表L已存在
	//操作结果：销毁线性表L，返回state表示操作是否成功
state LINEAR_ClearList( Linear_ElemSet *L )
{
	if( LINEAR_ListEmpty(*L) )
	{
		fprintf( stderr, "LINEAR_ClearList Function Error\n" );
		fprintf( stderr, "The Linear is emtpy!\n" );
		return FALSE;
	}
	(*L).List_length = 0;
	return TRUE;
}
	//重置(清空)线性表
	//初始条件：线性表L已存在
	//操作结果：将L重置为空表，返回state表示操作是否成功
state LINEAR_GetElem( Linear_ElemSet L, int i, Linear_ElemSet_Data *e )
{
	if( LINEAR_ListEmpty(L) || i > LINEAR_ListLength(L) || i <= 0 )
	{
		fprintf( stderr, "LINEAR_GetElem Function Error\n" );
		fprintf( stderr, "Out of bound! List length is %d, i is %d\n", LINEAR_ListLength(L), i );
		return FALSE;
	}
	*e = L.Elem[i-1];
	return TRUE;
}
	//获取元素
	//初始条件：线性表L已存在，1≤i≤ListLength(L)
	//操作结果：用e返回L中第i个数据元素的值。并返回state表示操作是否成功
int LINEAR_LocateElem( Linear_ElemSet L, Linear_ElemSet_Data e, int (*compare)(Linear_ElemSet_Data, Linear_ElemSet_Data) )
{
	int i;

	if( LINEAR_ListEmpty(L) )
	{
		fprintf( stderr, "LINEAR_LocateElem Function Error\n" );
		fprintf( stderr, "The Linear is empty!\n" );
		return FALSE;
	}

	for( i = 0; i < LINEAR_ListLength(L); i++ )
	{
		if( compare( L.Elem[i], e ) != FALSE )
			return i+1;
	}
	return 0;
}
	//定位元素
	//初始条件：线性表L已存在，compare()是数据元素的判定函数(返回0为FALSE,其余为TRUE)
	//操作结果：返回L中第1个与e满足关系compare()的数据元素的位序，若这样的数据元素不存在，则返回值为0
state LINEAR_PriorElem( Linear_ElemSet L, int i, Linear_ElemSet_Data *pre_e )
{
	if( LINEAR_ListEmpty(L) || i > LINEAR_ListLength(L) || i <= 1 ) 
	{
		fprintf( stderr, "LINEAR_PriorElem Function Error\n" );
		fprintf( stderr, "Out of bound! List length is %d, i is %d\n", LINEAR_ListLength(L), i );
		return FALSE;
	}

	*pre_e = L.Elem[i-2];
	return TRUE;
}
	//返回目标元素的前一个元素
	//初始条件：线性表L已存在，2≤i≤ListLength(L)
	//操作结果：用pre_e返回L中第i个数据元素的前一个元素的值。并返回state表示操作是否成功
state LINEAR_NextElem( Linear_ElemSet L, int i, Linear_ElemSet_Data *next_e )
{
	if( LINEAR_ListEmpty(L) || i >= LINEAR_ListLength(L) || i <= 0 ) 
	{
		fprintf( stderr, "LINEAR_NextElem Function Error\n" );
		fprintf( stderr, "Out of bound! List length is %d, i is %d\n", LINEAR_ListLength(L), i );
		return FALSE;
	}

	*next_e = L.Elem[i];
	return TRUE;
}
	//返回目标元素的后一个元素
	//初始条件：线性表L已存在，1≤i≤( ListLength(L) - 1 )
	//操作结果：用next_e返回L中第i个数据元素的后一个元素的值，并返回state表示操作是否成功
state LINEAR_ListInsert( Linear_ElemSet *L, int i, Linear_ElemSet_Data e )
{
	int j;
	if( LINEAR_ListLength(*L) >= (*L).List_BufferLen )
	{
		if( LINEAR_ReallocList(L) == FALSE )
		{
			fprintf( stderr, "LINEAR_ListInsert Function Error\n" );
			fprintf( stderr, "Can't realloc the memory! list length is %d, list buffer len is %d\n", LINEAR_ListLength(*L), (*L).List_BufferLen );
			fprintf( stderr, "Cancle the Insert opeartion!\n" );
			return FALSE;
		}
	}
	if( LINEAR_ListEmpty(*L) || i > LINEAR_ListLength(*L) || i<= 0 )
	{
		fprintf( stderr, "LINEAR_ListInsert Function Error\n" );
		fprintf( stderr, "Can't insert in that postion! Listlength is %d, i is %d\n", LINEAR_ListLength(*L), i );
		return FALSE;
	}

	for( j=LINEAR_ListLength(*L); j>=i; j-- )
	{
		(*L).Elem[j] = (*L).Elem[j-1];
	}
	(*L).Elem[i-1] = e;
	(*L).List_length++;
	return TRUE;
}
	//为线性表插入一个元素
	//初始条件：线性表L已存在，1≤i≤( ListLength(L) +1 )
	//操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1。并返回state表示操作是否成功
int LINEAR_ListAddElem( Linear_ElemSet *L, Linear_ElemSet_Data e )
{
	if( LINEAR_ListLength(*L) >= (*L).List_BufferLen )
	{
		if( LINEAR_ReallocList(L) == FALSE )
		{
			fprintf( stderr, "LINEAR_ListAddElem Function Error\n" );
			fprintf( stderr, "Can't realloc the memory! list length is %d, list buffer len is %d\n", LINEAR_ListLength(*L), (*L).List_BufferLen );
			fprintf( stderr, "Cancle the Add opeartion!\n" );
			return LINEAR_ListLength(*L);
		}
	}
	(*L).Elem[LINEAR_ListLength(*L)] = e;
	++(*L).List_length;
	return LINEAR_ListLength(*L);
}
	//为线性表添加一个元素
	//初始条件：线性表L已存在
	//操作结果：在L中的尾部插入一个新的数据元素e，L的长度加1。并返回state表示操作是否成功
state LINEAR_ListDelete( Linear_ElemSet *L, int i, Linear_ElemSet_Data *e )
{
	int j;
	if( LINEAR_ListEmpty(*L) || i > LINEAR_ListLength(*L) || i<= 0 )
	{
		fprintf( stderr, "LINEAR_ListDelete Function Error\n" );
		fprintf( stderr, "Can't delete in that postion! Listlength is %d, i is %d\n", LINEAR_ListLength(*L), i );
		return FALSE;
	}

	*e = (*L).Elem[i-1];
	for( j=i; j<LINEAR_ListLength(*L); j++ )
	{
		(*L).Elem[j-1] = (*L).Elem[j];
	}
	(*L).List_length--;
	return TRUE;
}
	//为线性表删除一个元素
	//初始条件：线性表L已存在且非空，1≤i≤ListLength(L)
	//操作结果：删除L的第i个元素，并用e返回被删除元素的值，L的长度减1。并返回state表示操作是否成功
state LINEAR_ListElemCover( Linear_ElemSet *L, int i, Linear_ElemSet_Data *e )
{
	if( LINEAR_ListEmpty(*L) || i > LINEAR_ListLength(*L) || i<= 0 )
	{
		fprintf( stderr, "LINEAR_ListElemCover Function Error\n" );
		fprintf( stderr, "Can't Cover in that postion! Listlength is %d, i is %d\n", LINEAR_ListLength(*L), i );
		return FALSE;
	}

	(*L).Elem[i] = *e;
	return TRUE;
}
	//对线性表一个指定元素执行覆盖
	//初始条件：线性表已存在且非空，1≤i≤ListLength(L)
	//操作结果：使用e覆盖L的第i个元素，返回state表示操作是否成功
state LINEAR_ListTraverse( Linear_ElemSet L, int (*visit)(Linear_ElemSet_Data) )
{
	int i;

	if( LINEAR_ListEmpty(L) )
	{
		fprintf( stderr, "LINEAR_ListTraverse Function Error\n" );
		fprintf( stderr, "List is empty!\n" );
		return FALSE;
	}

	for( i=0; i<LINEAR_ListLength(L); i++ )
	{
		if( visit(L.Elem[i]) == FALSE )
		{
			fprintf( stderr, "Visit Error in %d element!\n", i+1 );
			return FALSE;
		}
	}

	return TRUE;
}
	//历遍线性表
	//初始条件：线性表L已存在且非空
	//操作结果：依次对线性表里的每一个数据元素执行visit()函数，一旦visit返回0(FALSE)，则操作失败。并返回state表示操作是否成功

链式存储

采用的简单单链表及无头结点实现，有两个文件。实际上通过设计一个头结点会使得代码更简单易懂，并且对链表的维护更容易。

//Link_list.h
#ifndef _LINK_LIST_H_
#define _LINK_LIST_H_
#include <stdio.h>
#include <malloc.h>

typedef struct {
	int data;
	struct LLNode *Next;
}LLNode, *LLHead;

typedef int DataType;
/*
初始化LLHead。
*/
void LL_Initialize(LLHead *p);

/*
插入元素：将elem插入到pos的位置（0为第一位）
初始条件：p已初始化，pos为有效位置（≥0，若大于链表长度不论为多少默认为最后）
操作结果：成功返回1，否则返回0
*/
int LL_Insert(LLHead *p, int pos, DataType elem);

/*
删除元素：删除pos位置的元素
初始条件：p已初始化，pos为有效位置（≥0且≤链表长度-1）
操作结果：成功返回1，否则返回0
*/
int LL_Delete(LLHead *p, int pos);

/*
查找元素：查找elem元素的位置
初始条件：p已初始化
操作结果：若元素存在于链表中，返回位置pos；否则返回-1
*/
int LL_Find(LLHead p, DataType elem);

/*
查找元素：查找位于pos的元素
初始条件：p已初始化，pos为有效位置（≥0且≤链表长度-1）
操作结果：若pos有效，将修改outElem中内容为该位置元素并返回1；否则返回0。
*/
int LL_FindAt(LLHead p, int pos, DataType *outElem);

#endif

//Link_list.c
#include "Link_list.h"

static LLNode* NewNode(DataType dat, LLNode *next)
{
	LLNode *p = malloc(sizeof(LLNode));
	if (p == NULL)
	{
		fprintf(stderr, "Can't allocate memory!");
		return NULL;
	}
	p->data = dat;
	p->Next = next;

	return p;
}

void LL_Initialize(LLHead * p)
{
	*p = NULL;
}

//由于该链表不存在单独的头结点，LLHead是指向头结点的指针变量，插入或删除有时候需要修改头指针变量，因此参数为LLHead *。
int LL_Insert(LLHead * p, int pos, DataType elem)
{
	if (pos < 0)
		return 0;

	LLNode *pcur = *p;
	LLNode *prev = NULL;	//保留前继指针方便修改

	if (pcur == NULL)	//当p为NULL意味着是一个新的链表，直接插入并修改头指针
		*p = NewNode(elem, NULL);
	else if (pos == 0) //当pos为0时意味着插入到链表头，同样直接插入并修改头指针
		*p = NewNode(elem, pcur);
	else
	{
		while (pcur != NULL && pos-- >= 0)	//循环完毕后要么已经到了链表的尾部，要么到达了pos的位置
		{
			prev = pcur;
			pcur = pcur->Next;
		}
		prev->Next = NewNode(elem, pcur);
	}

	return 1;
}

int LL_Delete(LLHead * p, int pos)
{
	if (*p == NULL)
	{
		fprintf(stderr, "Empty List!");
		return 0;
	}

	if (pos == 0) //如若删除链表第一个，则需要修改头指针
	{
		*p = (*p)->Next;
		return 1;
	}

	LLNode *pcur = *p;
	LLNode *prev = NULL;

	while (pcur != NULL && pos-- >= 0)
	{
		prev = pcur;
		pcur = pcur->Next;
	}

	if (pos >= 0) //如果pos仍然≥0，则说明pos长度大于链表最大长度。
	{
		fprintf(stderr, "Out of Bound!");
		return 0;
	}

	//删除第n位链表结点，实际上就是使第n-1位结点指向n+1位结点。
	prev->Next = pcur->Next;
	free(pcur);
	return 1;
}

int LL_Find(LLHead p, DataType elem)
{
	if (p == NULL)
	{
		fprintf(stderr, "Empty List!");
		return 0;
	}

	int pos = 0;

	while (p != NULL)
	{
		if (p->data == elem)
			return pos;

		pos++;
		p = p->Next;
	}
	//循环结束如果尚未返回证明链表中不存在该元素

	return -1;
}

int LL_FindAt(LLHead p, int pos, DataType *outElem)
{
	if (p == NULL)
	{
		fprintf(stderr, "Empty list!");
		return 0;
	}
	if (outElem == NULL)
	{
		fprintf(stderr, "outElem is NULL!");
		return 0;
	}
	if (pos < 0)
	{
		fprintf(stderr, "Out of Bound!");
		return 0;
	}

	while (p != NULL && pos-- > 0)
		p = p->Next;

	if (pos >= 0)
	{
		fprintf(stderr, "Out of Bound!");
		return 0;
	}
	
	*outElem = p->data;
	return 1;
}
GarfieldGCat
关注
专栏目录
数据结构入门--笔记
cw961590280的专栏
09-09 413
一、基本概念 1.数据：被计算机操作的信息载体。例如字符串、声音 2.数据元素：数据的基本单位。例如一个字符串，一段声音 3.数据结构：数据之间的组织形式 二、数据结构 1.逻辑结构：是抽象的数学模型。链表有指针域，数据域。 2.存储结构：是数据实际在硬件上的表现形式。 3.数据运算： 4.分类（逻辑）： 线性结构：一个接一个。例如栈、队列 非线性结构：多对多，不固定。树、图
算法与数据结构 --- 线性表 --- 顺序表示和实现
qq_51947882的博客
09-13 1256
list是线性表的英文名字，Elemset1. initialization 初始化2.销毁线性表的本质是将线性表从内存中删除3.置为空表的意思是将线性表中的元素全都删除1.数据元素判断函数的返回值类型是bool类型，当函数返回一个 true 时表示函数满足，返回一个false 时表示函数不满足2.这个函数会将我们传进来的 e 作为左参数，同时将 线性表中的每个元素依次作为右参数，左右参数进行比较，右参数依次变换，直到返回true为止，若比完了最后一个元素后仍无true则结束。
数据结构之顺序储存插入
weixin_42746203的博客
01-22 405
本文内容摘自大话数据结构，以php方式表述。 引用线性表数据插入3.5.2.我以php数组的方式进行实现。 1.数组指定位置的插入，线性表类似。 public function index(){ $array =[1,2,3,4,5,6,7,8,9];//数组 $array_num =count($array);//定义最大值数组 $i =1;//插入的位置 if($i<1 || $i >$array_num){
数据结构：第二章 线性表(顺序表)
一路生花
01-18 1869
相同的算法、两种操作。
线性表的元素查找、插入与删除
qq_56805519的博客
09-06 2745
ElemType在数据结构中通常指element type（元素的类型），本文使用typedef自定义ElemType和Status为int类型。 typedef int ElemType; typedef int Status; 查找： int LocateElem(SqList L, ElemType e, Status(*compare)(ElemType , ElemType )) //查找顺序表中的特定元素 { int i = 1; int *p = L.elem;
向一个有N个元素的顺序表中插入一个元素，平均要移动的次数为多少
weixin_44023015的博客
06-29 1万+
N个元素的顺序表可插入的位置有N+1个， 移动次数总数为0+1+2…+n=(0+n)*(n+1)/2 平均次数为 总数/(N+1）= n/2
数据结构线性表
04-08
线性表是最基本、最简单、也是最常用的一种数据结构。线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的（注意，这句话只适用大部分线性表，而不是全部。
c语言数据结构线性表创建删除插入
06-30
本主题聚焦于C语言中的数据结构——线性表，这是数据结构的基础概念之一，适用于初学者学习。线性表是一种逻辑上一维、元素之间具有线性关系的数据结构。下面将详细阐述线性表的创建、删除和插入操作。 1. **线性表...
数据结构线性表的C语言代码
06-27
适合学习数据结构的同学
数据结构 线性表PPT学习教案.pptx
10-05
数据结构中的线性表是一种基础且重要的数据组织形式，它由一个有序的元素序列组成，这些元素可以是任何数据类型。线性表的抽象数据类型（ADT）定义了对这种数据结构的操作集，包括创建、销毁、检查是否为空、获取...
数据结构学习day02——线性表
jjw_lyf的博客
10-08 804
文章目录一、线性表的（类型）定义和特点二、类C语言有关操作补充说明1.元素类型说明2.数组定义3.C语言的内存动态分配4.C++的动态内存分配5.C++中的参数传递三、线性表的顺序表示和实现1.顺序存储结构2.顺序表基本操作的实现 一、线性表的（类型）定义和特点 线性表是具有相同特性的数据元素的一个有限序列。 逻辑特征： 有且经有一个开始节点，仅有一个直接后继； 有且经有一个结束节点，仅有一个直接前驱； 其余的内部节点都有且经有一个直接前驱和一个直接后继。 抽象数据类型线性表的定义： AD
数据结构D={e1,e2,e3|e1,e2,e3｝属于ElemSet是什么意思
2301_80103251的博客
10-06 282
数据结构。
【数据结构专题】「基础数据算法」史上手把手带你认识一下数据结构的基本概念与术语
最新发布
世界上并没有完美的程序，但是我们并不因此而沮丧，因为写程序就是一个不断追求完美的过程。
01-09 1219
C是含两个实数的集合{c1,c2}；R={P}，而Ｐ是定义在集合C上的一种关系{}，其中有序偶表示c1是复数的实部，c2是复数的虚部。数据对象：D={e1,e2,e3 l e1,e2,e3 -> ElemSet(定义了关系运算的某个集合) }数据关系：R1={,}基本操作：操作结果：构造了三元组T，元素e1,e2和e3分别被赋以参数vl,v2和v3的值。操作结果：三元组T被销毁。初始条件：三元组T已存在，1≤i≤3。
数据结构（第二版）笔记
Fantasy4040的博客
09-25 314
早期的计算机主要用于数值计算，现在，计算机主要用于非数值计算，包括处理字符，表格和图像等具有一定结构的数据。这些数据内容存在着某种联系，只有分清楚数据的内在联系，合理地组织数据，才能对它们进行有效的处理，设计出高效的算法。如何合理地组织数据、高效地处理数据，这就是“数据结构”主要研究的问题。本章简要介绍有关数据结构的基本概念和算法分析方法。
初学数据结构——从零开始的数据结构学习总结篇（线性表）
Lazy_ChessPlayer的博客
04-10 1012
前言 简介： 线性表是一种最简单也最常用的数据结构，它包括顺序表和链表两种实现方式。 在这篇博客中，我将介绍线性表的定义、特点、操作以及它们之间的优缺点和比较。我希望通过这篇博客，能够帮助大家更好地理解和掌握线性表这一重要的数据结构。 注： 本博客为本人在学习数据结构路途上的知识整理，如觉得对有你有所帮助，还希望不要吝啬你的赞，整理知识点是真的很累|*´Å`)ﾉ。由于博主只是一名大一新生，在文章难免会出现错误，还希望指正。如果想要转载，附上链接就行。 本文中的颜色标记 红色部分为重点内容 蓝
数据结构线性表定义附带代码（线性表第二章）
m0_65428217的博客
03-14 595
2.1线性表的类型定义 线性表是最常用且最简单的一种数据结构。简言之，一个线性表是n个数据元素的有限序列。 在稍复杂的线性表中，一个数据元素可以由软干个数据项组成。在这种情况下，常把数据元素称为记录，含有大量记录的线性表又称文件。 线性表是线性结构的基础。 抽象数据类型线性表的定义如下： ADT List{ 数据对象：D={ai|ai-ElemSet，i=1，2，3······n，n>=0} 数据关系：R1={《ai-1，ai》|ai-1，a-D，i=1，2，3······n} 基..
数据结构--线性表详解（一）
热门推荐
William
11-15 4万+
这里写链接内容1、前言 线性表是最常用且是最简单的一种数据结构。形如：A1、A2、A3….An这样含有有限的数据序列，我们就称之为线性表。2、线性表的两种表示形式 顺序表示（其实就是数组） 链表表示（本博客重点将重点介绍的部分） 3、线性表一般操作的介绍 线性表一般包含如下几种操作：线性表的操作包括如下几种 （1） InitList(& L) //构造一个空的线性表
超清晰-数据结构之线性表
MClink的博客
05-25 3万+
鸟哥说，坚持学习基础才能有出人头地的一天。不能只专注于练武功了，内功也得练。 本篇文章是讲数据结构的第一篇，跟着书好好再过一篇基础。 一、线性表 线性表是n个数据特性相同的元素的组成有限序列，是最基本且常用的一种线性结构(线性表，栈，队列，串和数组都是线性结构），同时也是其他数据结构的基础。 对于非空的线性表或者线性结构的特点： （1）存在唯一的一个被称作“第一个”的数据元素； （2）...
C语言数据结构
B85951005的博客
04-08 1万+
1.什么是数据结构 一般来说,用计算机解决一个具体问题时,大致需要经过下列几个步骤:首先要从具体问题抽象出一个适当的数学模型,然后设计一个解此数学模型的算法,最后编出程序，进行测试,调整直至得到最终解答。寻求数学模型的实质是分析问题,从中提取操作的对象,并找出这些操作对象之间含有的关系,然后用数学的语言加以描述。例如,求解梁架结构中应力的数学模型为线性方程组;预报人口增长情况的数学模型为微分方程。然而，更多的非数值计算问题无法用数学方程加以描述。下面请看3个例子。 例1-1图书...
数据结构线性表：逻辑结构与存储实现
"数据结构线性表的讨论，包括逻辑结构特点、顺序存储与链式存储的特性，以及数据结构课程的知识框架。" 线性表是数据结构的基础，它的逻辑结构特点是每个元素都有且仅有一个直接前驱和一个直接后继，除了首元素和尾...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值