数据结构 线性表

最新推荐文章于 2024-01-09 14:03:48 发布
最新推荐文章于 2024-01-09 14:03:48 发布
阅读量775 收藏 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
关注
  • 5
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构线性表
04-08
线性表是最基本、最简单、也是最常用的一种数据结构。线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的（注意，这句话只适用大部分线性表，而不是全部。
数据结构之顺序储存插入
weixin_42746203的博客
01-22 389
本文内容摘自大话数据结构，以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){
数据结构入门--笔记
cw961590280的专栏
09-09 396
一、基本概念 1.数据：被计算机操作的信息载体。例如字符串、声音 2.数据元素：数据的基本单位。例如一个字符串，一段声音 3.数据结构：数据之间的组织形式 二、数据结构 1.逻辑结构：是抽象的数学模型。链表有指针域，数据域。 2.存储结构：是数据实际在硬件上的表现形式。 3.数据运算： 4.分类（逻辑）： 线性结构：一个接一个。例如栈、队列 非线性结构：多对多，不固定。树、图
数据结构：第二章 线性表(顺序表)
一路生花
01-18 1758
相同的算法、两种操作。
向一个有N个元素的顺序表中插入一个元素，平均要移动的次数为多少
热门推荐
weixin_44023015的博客
06-29 1万+
N个元素的顺序表可插入的位置有N+1个， 移动次数总数为0+1+2…+n=(0+n)*(n+1)/2 平均次数为 总数/(N+1）= n/2
算法与数据结构 --- 线性表 --- 顺序表示和实现
qq_51947882的博客
09-13 1058
list是线性表的英文名字，Elemset1. initialization 初始化2.销毁线性表的本质是将线性表从内存中删除3.置为空表的意思是将线性表中的元素全都删除1.数据元素判断函数的返回值类型是bool类型，当函数返回一个 true 时表示函数满足，返回一个false 时表示函数不满足2.这个函数会将我们传进来的 e 作为左参数，同时将 线性表中的每个元素依次作为右参数，左右参数进行比较，右参数依次变换，直到返回true为止，若比完了最后一个元素后仍无true则结束。
c语言数据结构线性表创建删除插入
06-30
本主题聚焦于C语言中的数据结构——线性表，这是数据结构的基础概念之一，适用于初学者学习。线性表是一种逻辑上一维、元素之间具有线性关系的数据结构。下面将详细阐述线性表的创建、删除和插入操作。 1. **线性表...
数据结构线性表的C语言代码
06-27
适合学习数据结构的同学
数据结构线性表思维导图
08-01
线性结构是数据结构的基础，它包括了线性表、栈、队列、数组和串等多种类型。线性表是一种由零个或多个数据元素组成的有限序列，其逻辑结构具有单一的表头和表尾，每个元素除了表头和表尾外，都有且只有一个直接前驱...
数据结构线性表完成版示例
05-16
数据结构线性表完成版示例 数据结构是计算机科学技术学院的一门重要课程，线性表是数据结构的基础概念之一。本实验报告的目的是掌握线性表的概念、抽象数据类型和特点，以及线性表的顺序存储结构和链式存储结构的...
数据结构线性表学习资源
07-28
数据结构线性表学习资源
数据结构线性表代码
11-06
纯版c语言实现的数据结构代码，里面多以指针为基础编写代码
数据结构线性表实验
06-09
根据给定的信息，我们可以深入探讨线性表在数据结构中的实现与应用。线性表是计算机科学中最基本的数据结构之一，它由具有相同特性的数据元素组成，这些元素按照一定的顺序排列。本篇将详细解释如何通过C语言来实现...
数据结构 线性表 代码
12-08
线性表是数据结构中的基本概念，它是一种有序的数据集合，其中每个元素都有一个前驱和后继（除了首元素和尾元素）。线性表的实现方式主要有两种：顺序表和链表。 首先，我们来看顺序表。顺序表是将数据元素存放在一...
数据结构学习day02——线性表
jjw_lyf的博客
10-08 673
文章目录一、线性表的（类型）定义和特点二、类C语言有关操作补充说明1.元素类型说明2.数组定义3.C语言的内存动态分配4.C++的动态内存分配5.C++中的参数传递三、线性表的顺序表示和实现1.顺序存储结构2.顺序表基本操作的实现 一、线性表的（类型）定义和特点 线性表是具有相同特性的数据元素的一个有限序列。 逻辑特征： 有且经有一个开始节点，仅有一个直接后继； 有且经有一个结束节点，仅有一个直接前驱； 其余的内部节点都有且经有一个直接前驱和一个直接后继。 抽象数据类型线性表的定义： AD
数据结构D={e1,e2,e3|e1,e2,e3｝属于ElemSet是什么意思
2301_80103251的博客
10-06 124
数据结构。
【数据结构专题】「基础数据算法」史上手把手带你认识一下数据结构的基本概念与术语
最新发布
世界上并没有完美的程序，但是我们并不因此而沮丧，因为写程序就是一个不断追求完美的过程。
01-09 1092
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 254
早期的计算机主要用于数值计算，现在，计算机主要用于非数值计算，包括处理字符，表格和图像等具有一定结构的数据。这些数据内容存在着某种联系，只有分清楚数据的内在联系，合理地组织数据，才能对它们进行有效的处理，设计出高效的算法。如何合理地组织数据、高效地处理数据，这就是“数据结构”主要研究的问题。本章简要介绍有关数据结构的基本概念和算法分析方法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值