线性表讲解

最新推荐文章于 2023-03-06 19:55:41 发布
最新推荐文章于 2023-03-06 19:55:41 发布
阅读量295 收藏 4
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wyzworld/article/details/82806281
版权 
第二章 线性表
线性结构特点 ： 在数据元素非空的有限集中
1 存在唯一一个第一和最后一个元素
2 除第一个元素之外，集合中的每个元素都只有一个前驱
3 除最好一个元素之外，集合中每个元素都只有一个后继

线性表：n 个数据元素的有限序列
抽象数据线性表定义
ADT list{
	数据对象 D ： = {......}
	数据关系
	基本操作{
	InitList(&L);   //构造一个空的线性表
    DestroyList(&L);  //销毁线性表
    ClearList(&L);    //清空线性表
    ListEmpty(L);     //判断线性表是否为空
    ListLength(L);    //求线性表长度
    GetElem(L, i, &e);   //用 e 返回线性表第 i 个元素
    LocateElem(L, e, compare());  //返回L中第 1 个与 e 满足 compare（）关系的元素
    PriorElem(L, cur_e, &pre_e);   //求 cur_e 的前驱元素
    NextElem(L, cur_e, &next_e);   //求 cur_e 的后继元素
    ListInsert(&L, i, e);   //在第 i 个位置之前插入元素 e
    ListDelete(&L, i, &e);  //删除第 i 个位置的元素，用 e 返回其值
    ListTraverse(L, visit());  //依次对L的每个元素调用函数 visit（）
}
}
稍复杂操作举例
合并线性表A,B
void unionList(&La, List Lb)
{
	//将所有在线性表Lb中但不再La的元素插入La中
	La.len = ListLength(La);  //求线性表长
	Lb.len = ListLength(Lb);
	for (int i = 1; i < Lb.len; i++)
	{
		GetElem(Lb, i, e);    //取表 Lb 第 i 个元素赋给 e
		if (!LocatElem(La, e, equal))       //La 中不存在和 e 相同的元素则插入
			ListInsert(La, ++La_len, e);
	}
}


归并线性表
//将表A,B按照非递减顺序归并成一新表C
void MergeList(List La, List Lb, List &Lc)
{
	//已知线性表La和Lb中的数据元素按值非递减排列
	//归并La和Lb
	InitList(Lc);
	i = j = 1;
	k = 0;
	La.len = ListLength(La);
	Lb.len = ListLength(Lb);
	while (i <= La.len&&j <= Lb.len)
	{
		GetElem(La, i, ai);
		GetElem(Lb, j, bj);
		if (ai <= bj)
		{
			ListInsert(Lc, ++k, ai);
			++i;
		}
		else
		{
			ListInsert(Lc, ++k, bj);
			++j;
		}
	}
	while (i <= La.len)
	{
		GetElem(La, i++, ai);
		ListInsert(Lc, ++k, ai);
	}
	while (j <= Lb, len)
	{
		GetElem(Lb, ++j, bj);
		ListInsert(Lc, ++k, bj);
	}
}


线性表的顺序结构--使用数组
#define LIST_INIT_SIZE 100   //线性表存储空间的初始分配量
#define LISTINCREMENT 10     //线性表存储空间的分配增量
typedef struct {
	ElemType *elem;     //存储空间基址
	int length;         //当前长度
	//int listsize;       //当前分配的存储容量（以sizeof（ElemType)为单位）下述测试代码不用
}SqList;
上述基本操作的实现：以顺序结构为例
/*测试结构
typedef struct{
int *data;
int length;
}SqList;
*/
SqList *InitList(void)      //创建空表，分配相应内存 
{
	SqList *L = (SqList *)malloc(sizeof(SqList));
	L->data = (int *)malloc(sizeof(int)*LIST_INIT_SIZE);
	if (!L)  //分配内存失败
	{
		printf("failure\n");
		exit(0);
	}

	L->length = 0;    //初始化表长

	return L;
}

void DestroyList(SqList *L)
{
	free(L->data);
	free(L);
}

顺序结构下的线性表插入和删除操作比较复杂，在每插入或删除一个元素之后，该元素后面的元素要做相应的移动以保持存储结构上的相邻
int ListInsert(SqList *L, int i, int e)   //插入操作 在第 i 个元素的位置上插入新元素
{
	
	for (int p = L->length; p >= i - 1; p--)
	{
		L->data[p + 1] = p;
	}
	L->data[i - 1] = e;
	L->length++;  //增加当前表长

	return OK;
}

int ListDelete(SqList *L, int i)  //删除操作，删除第 i 个元素，返回删除的元素值
{
	if (L == NULL)
	{
		printf("the list is null\n");
		exit(0);
	}
	int temp = L->data[i - 1];
	for (int p = i; p < L->length; p++)
	{
		L->data[p - 1] = L->data[p];
	}
	L->length--;  //减少当前表长

	return temp;
}


//上述操作的范例代码
Status ListInsert(SqList &L, int i, ElemType e)
{
	//在顺序表L中第 i 个位置之前插入新的元素 e
	// i 的合法值为 1 <= i <= ListLength(L)+1

	if (i<1 || i>L.length + 1)      // i 值不合法
		return ERROR;

	if (L.length >= L.listsize)    //当前存储空间已满，增加分配
	{
		newbase = (ElemType *)realloc(L.elem, (L.listsize + LISTINCREMENT) * sizeof(ElemType));

		if (!newbase)
			exit(OVERFLOW);

		L.elem = newbase;   //新基址
		L.listsize += LISTINCREMENT;
	}
	q = &(L.elem[i - 1]);  //q 为插入位置
	for (p = &(L.elem[L.length = 1]); p >= q; --p)
		*(p + 1) = *p;    //后移元素

	*q = e;  //插入元素
	++L.length;  //增加表长

	return OK;
}


Status ListDelete(SqList &L, int i, ElemType &e)
{
	//在顺序表 L 中删除第 i 个元素，用 e 返回其值
	// i 的合法值为 1 <= i <= ListLength(L)
	if (i<1 || i>L.length)
		return ERROR;

	p = &(L.elem[i - 1]);  //p为被删除元素位置
	e = *p; //被删除元素值赋给 e ，注意这些位置都是以地址表示的，得到值要用取地址运算符
	q = L.elem + L.length - 1;
	for (++p; p <= q; ++p)
		*(p - 1) = *p;
	--L.length;
	return OK;
}
//NOTE 在对顺序结构的线性表进行插入删除操作时较为复杂，移动元素的次数过多
//其解决方法可以采用链式结构的线性表，或者对顺序结构做处理，增加标记元素，但是这样会造成逻辑结构与存储结构的不一致
//扩展如静态链表

//在上例中用到的LocateElem()操作
int LocateElem(SqList *L, ElemType e, Status(*compare)(ElemType, ElemType))
{
	//在顺序表 L 中查找第 1 个值与 e 满足 compare() 元素的位序
	//若找到返回其在 L 中的位序，否则返回 0
	i = 1;   // i 的初值位第一个元素的位序
	p = L.elem;  //p 的初值为第一个元素的存储位置
	while (i <= L.length && !(*compare)(*p++, e))
		++i;

	if (i <= L.length)
		return i;
	else
		return 0;
}


//MergeList的第二种写法
void MergeList(SqList La, SqList Lb, SqList *Lc)
{
	//已知线性表La和Lb中的数据元素按值非递减排列
	//归并La和Lb
	pa = La.elem;
	pb = Lb.elem;
	Lc.listsize = Lc.length = La.lengt + Lb.length;
	pc = Lc.elem = (Elemtype*)malloc(Lc.listsize * sizeof(ElemType));
	if (!Lc.elem)
		exit(OVERFLOW);

	pa.last = La.elem + La.length - 1;
	pb.last = Lb.elem + Lb.length - 1;
	while (pa <= pa.last&&pb <= pb.last)  //归并
	{
		if (*pa <= *pb)
			*pc++ = *pa++;
		else
			*pc++ = *pb++;
	}
	//插入剩下元素
	while (pa <= pa.last)
		*pc++ = *pa++;
	while (pb <= pb.last)
		*pc++ = *pb++;
}
NOTE 以线性表合并进行集合的各种运算最好先进行排序，这样可以减少部分算法的时间复杂度



顺序表的链式结构--使用指针索引
typedef struct LNode{
	int data;
	struct LNode *next;
}LNode,*LinkList;
//GetElem 在链表中的实现
//由于链表的每个结点数据在存储位置上没有必然联系，只能通过索引指针来进行元素索引
int GetElem(LinkList L, int i)
{
	//L为带头结点的单链表头指针
	//存在第 i 个元素时，返回其值，否则返回 ERROR
	LinkList p = L->next;
	int count = 0;
	if (i > L.length)
	{
		printf("ERROR");
		return ERROR;
	}
	
	while (count < i)
	{
		p = p->next;
		count++;
	}

	return p->data;
}
//范例代码
Status GetElem(LinkList L, int i, ElemType &e)
{
	p = L->next;
	j = 1;
	while (p&&j < i)
	{
		p = p->next;
		j++;
	}
	if (!p || j > i)
		return ERROR;
	e = p->data;
	return OK;
}

//链表的插入与删除
//由于链表是由指针索引，插入与删除操作只需断开结点后再续接即可，不需要对大量元素进行移动，时间复杂度较低
int listInsert(LinkList L, int i, int e)
{
	LinkList P = L->next;
	LinkList q = L;
	if (i > L.length)
		return ERROR;

	int count = 1;
	while (count < i)
	{
		p = p->next;  
		q = q->next;
		count++;
	}
	//结束循环后 p 指向第 i 个位置 ，q 指向 i - 1 的位置，初始 count = 0 时该条件会使使指针溢出

	/*在第 i 个位置之前插入元素 e -- 需要对 q 指针做操作
	LinkList temp = (LinkList)malloc(sizeof(LNode));  //申请新结点
	if (!temp)
		exit(0);
	temp->data = e;
	temp->next = NULL;

	q->next = temp;  //续接指针
	temp->next = p;
	*/

	/*在第 i 个位置之后插入元素 e -- 需要对 p 指针操作
	LinkList temp = (LinkList)malloc(sizeof(LNode));  //申请新结点
	if (!temp)
		exit(0);
	temp->data = e;
	temp->next = NULL;

	temp->next = p->next;
	p->next = temp;
	*/

	return OK;
}

int listDelete(LinkList L, int i)   //删除第 i 个结点
{
	LinkList p = L->next;
	LinkList q = L;

	//删除位置不合理
	if (p == NULL)
		return ERROR;
	else if (i > L.length)
		return ERROR;

	int count = 1;
	while (count < i)
	{
		p = p->next;
		q = q->next;
		count++;
	}
	q->next = p->next;
	free(p);

	return OK;
}
//esp 上述代码中的L.length表示 L 的长度，在该链表结构中并没有存储其值，在此处仅做形象表示，
//可以通过函数计算或则在创建的时候存储在头节点的数据域中
//范例代码
Status ListInsert(LinkList &L, int i, ElemType e)
{
	//在带头结点的单链表L中第 i 个位置之前插入元素 e
	ListLink p = L;
	int j = 0;
	while (p&&j < i - 1)
	{
		p = p->next;
		j++;
	}

	if (!p || j > i)
		return ERROR;

	LinkList s = (LinkList)malloc(sizeof(LNode));
	if (!s)
		exit(0);
	s->data = e;
	s->next = p->next;
	p->next = s;

	return OK;
}

Status ListDelete(LinkList &L, int i, ElemType &e)
{
	//在带头结点的单链表L中删除第 i 个元素并用 e 返回其值
	LinkList p = L;
	int j = 0;
	while (p->next&&j < i - 1)  //寻找第 i 个结点，并令 p 指向其前驱
	{
		p = p->next;
		j++;
	}

	if (!p->next || j > i - 1)
		return ERROR;

	LinkList q = p->next;
	p->next = q->next;
	e = q->data;
	free(q);

	return OK;
}

//链表是一种动态存储结构，使用时要分配相应内存，销毁时要对相应内存进行释放
//由于是动态结构，相较于顺序结构的链表，在存储上具有优势，可以任意的添加或删除元素
//下面提供几种创建链表的方法
void creatListFIFO(LinkList *L)  //先进先出
{
	*L = (LinkList)malloc(sizeof(LNode));
	if (!(*L))
		exit(0);
	(*L)->next = NULL;

	LinkList current = NULL, last = NULL;
	int e;
	while (scanf("%d", &e) == 1)
	{
		current = (LinkList)malloc(sizeof(LNode));
		if (!current)
			exit(0);
		else
		{
			current->next = NULL;
			current->data = e;
			if ((*L)->next == NULL)
			{
				(*L)->next = current;
				last = current;
			}
			else
			{
				last->next = current;
				last = current;
			}
		}
	}
	if (last)
		last->next = NULL;
}

LinkList creatListFIFO(void)  //先进先出，无参数
{
	LinkList L = (LinkList)malloc(sizeof(LNode));
	if (!L)
		exit(0);
	L->next = NULL;

	LinkList current = NULL, last = NULL;
	int e;
	while (scanf("%d", &e) == 1)
	{
		current = (LinkList)malloc(sizeof(LNode));
		if (current != NULL)
		{
			current->data = e;
			if (L->next == NULL)
			{
				L->next = current;
				last = current;
			}
			else
			{
				last->next = current;
				last = current;
			}
		}
	}
	if (last)
		last->next = NULL;

	return L;
}

void creatListFILO(LinkList *L)  //先进后出，有参数
{
	*L = (LinkList)malloc(sizeof(LNode));
	if (!(*L))
		exit(0);
	(*L)->next = NULL;

	LinkList current = NULL;
	int e;
	while (scanf("%d", &e) == 1)
	{
		current = (LinkList)malloc(sizeof(LNode));
		if (current != NULL)
		{
			current->data = e;
			current->next = (*L)->next;
			(*L)->next = current;
		}
	}
}

LinkList creatListFILO(void)  //先进后出，无参数
{
	LinkList L = (LinkList)malloc(sizeof(LNode));
	if (!L)
		exit(0);
	L->next = NULL;

	LinkList current = NULL;
	int e;
	while (scanf("%d", &e) == 1)
	{
		current = (LinkList)malloc(sizeof(LNode));
		if (current != NULL)
		{
			current->data = e;
			current->next = L->next;
			L->next = current;
		}
	}

	return L;
}
//示例代码
void CreatList(LinkList &L, int n)
{
	//逆位序输入n个元素值，建立带头结点的单链表
	L = (LinkList)malloc(sizeof(LNode));
	L->next = NULL;
	for (int i = n; i > 0; i--)
	{
		LinkList p = (LinkList)malloc(sizeof(LNode));
		scanf(&p->data);
		p->next = L->next;
		L->next = p;
	}
}


//归并有序链表
void MergeList(LinkList &La, LinkList &Lb, LinkList &Lc)
{
	LinkList pa = La->next;
	LinkList pb = Lb->next;
	LinkList pc = La;
	Lc = pc;
	while (pa&&pb)
	{
		if (pa->data <= p->data)
		{
			pc->next = pa;
			pc = pa;
			pa = pa->next;
		}
		else
		{
			pc->next = pb;
			pc = pb;
			pb = pb->next;
		}
	}
	pc->next = pa ? pa : pb;
	free(Lb);
}



循环链表--将最后一个结点接入头结点上形成一个环

双向链表
//双向链表的存储结构--在每个结点里增添了一个指向前驱的指针
typedef struct DuLNode {
	ElemType data;
	struct DuLNode *prior;
	struct DuLNode *next;
}DuLNode,*DuLinkList;
NOTE 在双向链表的计算表长，取元素和检索元素之类的操作与单链表基本一致，但是插入删除等操作设计了两个指针，就有很大不同
//示例代码
Status ListInsert(DuLinkList &L, int i, ElemType e)
{
	//在带头结点的双循环链表中第 i 个位置之前插入元素 e
	// i 的合法值为 1 <= i <= 表长 + 1
	if (!(p = GetElem(L, i)))   // 在 L 中确定插入位置
		return ERROR;           //p = NULL，插入位置不合法

	if (!(s = (DuLinkList)malloc(sizeof(DuLNode))))
		return ERROR;
	s->data = e;
	s->prior = p->prior;
	p->prior->next = s;
	s->next = p;
	p->prior = s;
	return OK;

}

Status ListDelete(DuLinkList &L, int i, ElemType e)
{
	//删除带头结点的双循环链表的第 i 个元素，i 的合法值为 1 <= i <= 表长
	if (!(p == GetElem(L, i)))
		return ERROR;
	e = p->data;
	p->prior->next = p->next;
	p->next->prior = p->prior;
	free(p);
	return OK;
}



单链表的应用--一元多项式的表示及相加
在计算机中表示一元多项式可由一个线性表来表示 P = (p0, p1, p2...pn);
每一项的指数 i 隐含在其系数 pi 的序号里
假设Q是一元m次多项式，同样可以用线性表Q表示：Q = (q0, q1, q2...qm);
一般，设 m < n 则两个多项式相加有 Rn = Pn + Qm;
R = （p0 + q0, p1 + q1, p2 + q2...pm + qm, ...pn);
抽象数据类型一元多项式的定义如下
ADT Polynomial{
	数据对象
	数据关系
	基本操作
	creatPolyn(&P,m)  //输入 m 项的系数和指数，建立一元多项式
    DestroyPolyn(&P)  //销毁一元多项式
	PrintPolyn(P)     //打印一元多项式
	PolynLength(P)    //返回一元多项式的项数
	AddPolyn(&Pa,&pb) //相加并销毁 Pb
	SubtractPolyn(&Pa,&Pb) //相减并销毁 Pb
	MultiplyPolyn(&Pa,&Pb) //相乘并销毁 Pb
}

 

rasotae
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构：线性表讲解
dabing113的博客
11-20 658
1.1线性表的基本概念 数据元素之间具有的逻辑关系为线性关系的数据元素结合，称为线性表，n为线性表的长度，长度为0的线性表称为空表 线性表的基本操作 创建一个新的线性表 求线性表的长度 检索线性表中第i个数据元素（1<=i<=n） 根据数据元素的某数据项（通常称为关键字）的值求该数据元素在线性表的位置 在线性表第i个位置上存入一个新的的数据元素 在线性表第i个位置上...
线性表的详解
gongjunbox的博客
12-04 9081
线性表是算法题命题的重点。这类算法题实现起来比较容易且代码量较少，但是要求具有最优的性能（时间复杂度、空间复杂度)，才能获得满分。因此，应牢固掌握线性表的各种基本操作（基于两种存储结构)，在平时的学习中多注重培养动手能力。另外，需要提醒的是，算法最重要的是思想!考场上的时间紧迫，在试卷上不一定要求代码具有实际的可执行性，因此应尽力表达出算法的思想和步骤，而不必过于拘泥每个细节。注意算法题只能用C/C++语言实现。
线性表的讲解
创作不易，请多支持，将为本站提供更多「有价值的文章」。
07-06 1018
线性表是最基本、最简单、也是最常用的一种数据结构。线性表（linearlist）是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的（注意，这句话只适用大部分线性表，而不是全部。比如，循环链表逻辑层次上也是一种线性表（存储层次上属于链式存储，但是把最后一个数据元素的尾指针指向了首位结点）。将表中元素一个接一个的存入一组连续的存储单元中，这种存储结构是顺序结构。声明顺序表类型变量。.....
线性表（链表，顺序表）讲解_legend
legend050709的专栏
05-23 925
线性表(linearList) （1）线性表的定义： 节点（node）之间具有一对一的前驱后继关系 （2）线性表的存储结构： （2.1）顺序表 （sequenceList）: （2.2）链式表 （linkList）: （3）顺序表的常见操作： （初始化+增删改查+表的状态判断） （3.0）追加（appendNode/addNode）一个节点(
线性表综合讲解（思想、实现）
qwer1234mnbv_的博客
05-02 791
目录 一、顺序表 （一）非动态版本 （二）动态版本 二、链表 （一）单链表 (二)双向链表 三、栈 四、队列 线性表中的数据都像是被串起来一样，具有单一线性关系 一、顺序表 思想：在内存中数据连续存储 这就是一块连续存储的数据。 （一）非动态版本 #define MAX_CAPACITY 100 //定义存储上限 #include<stdio.h> #include<stdlib.h> typedef struct Sequencechart
线性表
chen
06-03 1738
线性表ADT定义如下： ADT 线性表 (List) Data Operation void initList(L); //创建并初始化一个空线性表，如果成功返回true，修改表传指针 bool listEmpty(L); //判断一个线性表是否为空，不修改表传值 void clearList(L); //清空一个线性表，成功返回true bool getElem(L,i,e); /
数据结构之线性表讲解，助力软件设计师考试
最新发布
08-11
数据结构之线性表讲解，助力软件设计师考试数据结构之线性表讲解，助力软件设计师考试数据结构之线性表讲解，助力软件设计师考试数据结构之线性表讲解，助力软件设计师考试数据结构之线性表讲解，助力软件设计师考试...
线性表讲解PPT
01-19
线性表讲解PPT
数据结构： 线性表讲解实例
11-03
数据结构： 线性表讲解实例。针对线性表的深入讲解。
数据结构 线性表算法例题讲解.docx
02-08
在本文件中，我们主要讨论了三种线性表操作的算法：合并线性表、有序线性表的合并以及顺序线性表的插入。 **例1：合并LA、LB中的元素到LA中** 这个算法的目标是将线性表LB中的所有元素添加到线性表LA中，同时确保...
数据结构--一看就懂的线性表讲解
雨不会一直下，但是一直会下雨
11-13 516
线性表是我们日常中用到的最多的数据结构，它的最基本的特点是它最多只有一个前驱，最多只有一个后驱，只有第一个节点没有前驱，只有最后一个节点没有后驱。 简言之：线性表就是n 个元素的有限序列，其一般描述为 A = (a1,a2,a3…) 线性表的存储结构分为：顺序存储和非顺序存储，其中顺序存储又叫向量存储，也叫一维数组存储。 1.顺序存储 线性表的顺序存储也叫向量存储，也叫一维数组存储。线性表中节点存放的物理顺序 和逻辑顺序是一样的，A = (a1,a2,a3…)对应的存储结构图如下： 线性表中第一个元素的位
线性表详解
adaizzz的博客
02-23 178
线性表的讲解 我们先定义用户自定义类型 typedef int USER_TYPE; // 用户也可根据具体情况，替换int类型。 typedef struct LINEAR { USER_TYPE *data; //声明了一个名为data的长度不确定的数组，也叫“动态数组” int capacity; //空间容量 int count; //有效元素个数 }LINE...
线性结构之线性表
Black_carbon的博客
07-17 501
线性结构的特点： 存在唯一的一个被称做“第一个”的数据元素； 存在唯一的一个被称做“最后一个”的数据元素； 除第一个之外，集合中的每个数据元素均只有一个前驱； 除最后一个之外，集合中每个数据元素均只有一个后继； 线性表：一个线性表是n个数据元素的有限序列。 线性表再物理结构的表示上可以分为（1）顺序表示和（2）链式表示。 （1）线性表的顺序表示：线性表的顺序表示指的是用一组地址连续的存...
数据结构第二章——线性表的定义和特点
haust_允谦的博客
11-08 7899
数据结构第二章——线性表的定义和特点 线性表的定义和特点 线性表是具有相同特性的数据元素的一个有限序列 其中数据元素的个数n定义为表的长度 当n = 0时称为空表 线性表的逻辑特征： 在非空的线性表，有且仅有一个开始结点a1,他没有直接前驱，儿仅有一个直接后继a2 有且仅有一个终端结点an,它没有直接后继，而仅有一个直接前驱an-1 其余的内部结点ai(2 <= i <= n - 1)都仅有一个直接前驱ai-1和一个直接后继ai+1 线性表的顺序存储表示 线性表的顺序表示又称为顺序存储
ADT线性表List的定义和顺序表示及实现
m0_53360850的博客
03-06 2025
线性表是最常用且最简单的一种数据结构。简言之，一个线性表是n个数据元素的有限序列。至于每个数据元素的具体含义，在不同的情况下各不相同，它可以是一个数字或者一个符号，也可以是一列数字的集合(例如二维数组)，亦或是一串字符(例如字符串数组)，甚至其他更复杂的信息。例如，26个英文字母的字母表：（A，B，C，···，Z）是一个线性表，表中的数据元素是单个字母字符。又如：(6, 17, 28, 50, 92, 188)表中的数据元素是整数。在稍微复杂的线性表中，一个数据元素可以又若干个数据项。
线性表简介
zxq2574043697的专栏
07-23 389
一： 线性表是一种最简单的线性结构 线性结构的基本特征为: 是一个数据元素的有序(次序)集 1．集合中必存在唯一的一个“第一元素”； 2．集合中必存在唯一的一个“最后元素” ； 3．除最后元素在外，均有唯一的后继； 4．除第一元素之外，均有唯一的前驱； 二：遍历线性表 ListTraverse(List L，visit()) if (ListEmpt
C++ 数据结构 线性链表
CHYabc123456hh的博客
03-15 700
#pragma once 减少头文件组合，降低编译出错的概率 作用等效于 #ifndef FUNC_H #define FUNC_H 代码主体 #endif 线性表的定义 排队问题 简单的线性表 (物理 或者逻辑结构) 1，数组 2，链表 线性表相关操作： 1，线性表初始化 2，线性表遍历 3，线性表插入元素 4，线性表删除元素 代码 #include <stdio.h> #include <stdlib.h> #define KS..
线性表讲解：顺序创建带头结点的单链表
"该资源为一个关于线性表讲解的PPT，重点介绍了如何顺序建立带头结点的单链表。内容涵盖了线性表的逻辑结构、顺序存储结构、链式存储结构以及应用实例。" 在计算机科学中，线性表是一种基本的数据结构，它由n（n...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值