数据结构--线性表

最新推荐文章于 2023-09-17 20:19:44 发布
最新推荐文章于 2023-09-17 20:19:44 发布
阅读量196 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45189707/article/details/103558670
版权

1、前言

线性表是最常用且是最简单的一种数据结构。形如：A1、A2、A3….An这样含有有限的数据序列，我们就称之为线性表。

2、线性表的两种表示形式

①顺序表示（其实就是数组）
②链表表示（单项/双向，带头/不带头，循环/不循环）
可组成八种不同的链表形式

3 、 最简单基本的不带头单项不循环链表

①基本运算的实现
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#define ERROR 0;
typedef struct LNode
{
	int data;
	struct LNode *next;
}LNode,*LinkList;
LinkList InitList(LinkList L)
{
	LinkList node = NULL;
	node=(LinkList)malloc(sizeof(LNode));
	if(!node)
	{
		return ERROR;
	}
	node->next=NULL;
	L=node;
	return L;
}
int ListLength(LinkList L)
{
	LinkList p=NULL;
	
	int count=0;
	p=L;
	while(p->next)
	{
		count++;
		p=p->next;
	}
	return count;
}
LinkList CreateList_L(LinkList L,int n)
{
	int i;
	LinkList p=NULL;
	for(i=n;i>0;i--)
	{
		p=(LinkList)malloc(sizeof(LNode));
		
		scanf("%d",&p->data);
		
		p->next=L->next;
		
		L->next=p;
	}
	return L;
}
LinkList ListInsert(LinkList L,int i,int e)
{
	int j=0;
	LinkList s=NULL,p=NULL;
	p=L;
	while(p&&j<i-1)
	{
		p=p->next;
		j++;
	}
	if(!p||j>i-1)
	{
		printf("输入的位置不合法！\n");
		return L;
	}
	s=(LinkList)malloc(sizeof(LNode));
	s->data=e;
	s->next=p->next;
	p->next=s;
	return L;
}
LinkList ListDelete(LinkList L,int i)
{
	int j;
	LinkList q=NULL,p=NULL;
	p=L;
	j=0;
	while(p->next&&j<i-1)
	{
		p=p->next;
		j++;
	}
	if(!(p->next)||j>i-1)
	{
		printf("输入的位置不合法！！\n");
		return L;
	}
	q=p->next;
	p->next=q->next;
	free(q);
	return L;
}
int GetElem(LinkList L,int i)
{
	int j,e;
	LinkList p=NULL;
	if(i<1||i>ListLength(L))
	{
		printf("输入的位置不合法！\n");
		return false;
	}
	p=L->next;
	j=1;
	while(j<i)
	{
		p=p->next;		
		j++;
	}
	e=p->data;
	printf("第%d位的数据元素为%d\n",i,e);
}
void menu(){
	printf("*************目录**************\n");
	printf("输出单链表中的各元素值1\n");
	printf("在单链表中插入数据元素2\n");
	printf("在单链表中删除数据元素3\n");
	printf("取出单链表中的数据元素4\n");
	printf("结束程序0\n");
	printf("*******************************\n");
}
void main()
{
	int n,m,i,e;
	LinkList L=NULL,p=NULL;
	L=InitList(L);
	printf("请输入元素个数：");
	scanf("%d",&n);
	printf("依次输入%d个数据元素：",n);
	L=CreateList_L(L,n);
	do
	{
		printf("\n\n");
		menu();
		printf("请输入你的选择：");
		scanf("%d",&m);
		switch(m)
		{
		case 1:
			printf("现在链表的元素为：");
			p=L->next;
			while(p!=NULL)
			{
				printf("%d ",p->data);
				p=p->next;
			}
			printf("\n");
			break;
		case 2:
			printf("依次输入插入位置和数据元素(空格隔开)：");
			scanf("%d%d",&i,&e);
			L=ListInsert(L,i,e);
			break;
		case 3:
			printf("输入需要删除的元素的位置：");
			scanf("%d",&i);
			L=ListDelete(L,i);
			break;
		case 4:
			printf("输入需要取出的元素的位置：");
			scanf("%d",&i);
			GetElem(L,i);
			break;
		case 0:
			printf("已结束程序！！！\n");
			break;
		default:
			printf("输入错误！！！\n");
		}
	}while(m!=0);
}

4 、双向带头循环链表

①概念
双向循环链表的节点包含一个数据域，两个指针域，一个指针域指向上一个节点，另一个指针域指向下一个节点，这样双向循环链表构成了两个相反方向遍历的圆环，双向循环链表与单链表相比，提高了访问的效率，也付出了多维护一个指针的代价，双向循环链表的插入和删除操作比单向链表复杂，查找和修改和单向链表的算法一样
②代码实现


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "DoubleList.h"

/**
 * @函数名: initialList
 * @函数功能: 初始化链表
 * @参数: size: 链表节点的空间大小
 * @返回值: 初始化成功返回链表类型的指针，失败返回NULL
 */
List_t *initialList(int size)
{
	List_t *temp;

	/* 分配链表空间 */
	temp = malloc(sizeof(List_t));
	if (temp == NULL)
	{
		return NULL;
	}
	
	/* 初始化链表 */
	temp->size = size;
	temp->n = 0;
	temp->head.next = &temp->head; 
	temp->head.prev = &temp->head;

	return temp;
}

/**
 * @函数名: insertNode
 * @函数功能: 双向链表新节点插入函数，只需提供新节点的前后节点地址
 *            就可以把节点插入到链表之中
 * @参数: P:新节点的前一个节点的地址  N:新节点的后一个节点的地址 
 *        newNode:新节点地址
 * @返回值: void
 */
void insertNode(Node_t *P, Node_t *N, Node_t *newNode)
{
	/* 先改变自己 */
	newNode->next = N;	// 后向指针指向后节点
	newNode->prev = P;	// 前向指针指向前节点
	
	/* 再改变别人 */
	N->prev = newNode;	// 后节点的前向指针指向自己
	P->next = newNode;	// 前节点的后向指针指向自己
}

/**
 * @函数名: appendListTop
 * @函数功能: 把节点以头插入方式挂载到链表中
 * @参数: list:链表地址  data:数据地址
 * @返回值: 插入成功返回0，失败返回非零
 */
int appendListTop(List_t *list, void *data)
{
	Node_t *newNode;

	/* 第一步：分配新节点空间 */
	newNode = malloc(sizeof(Node_t));
	if (NULL == newNode)
	{
		return -1;
	}

	/* 第二步：给节点中的数据地址分配空间 */
	newNode->datap = malloc(list->size);
	if (NULL == newNode->datap)
	{
		free(newNode);  // 不要忘记释放前面申请成功的空间
		return -2;
	}

	/* 第三步：把新数据复制到节点中的数据地址 */
	memmove(newNode->datap, data, list->size);

	/* 第四步：把数据挂载到链表头 */
	insertNode(&list->head,list->head.next,newNode);

	/* 第五步：链表节点数+1 */
	list->n += 1;

	return 0;	// 成功返回0
}

/**
 * @函数名: appendListTail
 * @函数功能: 把节点以尾插入方式挂载到链表中
 * @参数: list:链表地址  data:数据地址
 * @返回值: 插入成功返回0，失败返回非零
 */
int appendListTail(List_t *list, void *data)
{
	Node_t *newNode;

	/* 第一步：分配新节点空间 */
	newNode = malloc(sizeof(Node_t));
	if (NULL == newNode)
	{
		return -1;
	}

	/* 第二步：给节点中的数据地址分配空间 */
	newNode->datap = malloc(list->size);
	if (NULL == newNode->datap)
	{
		free(newNode);  // 不要忘记释放前面申请成功的空间
		return -2;
	}

	/* 第三步：把新数据复制到节点中的数据地址 */
	memmove(newNode->datap, data, list->size);

	/* 第四步：把数据挂载到链表尾 */
	insertNode(list->head.prev,&list->head,newNode);

	/* 第五步：链表节点数+1 */
	list->n += 1;

	return 0;	// 成功返回0	
}

/**
 * @函数名: sortInsert
 * @函数功能: 以从小到大的顺序把节点插入到链表中
 * @参数: list:链表地址  func:用于比较数据的回调函数  data:数据地址
 * @返回值: 插入成功返回0，失败返回非零
 */
int sortInsert(List_t *list, compare_t *func, void *data)
{
	Node_t *newNode;

	/* 第一步：分配新节点空间 */
	newNode = malloc(sizeof(Node_t));
	if (NULL == newNode)
	{
		return -1;
	}

	/* 第二步：给节点中的数据地址分配空间 */
	newNode->datap = malloc(list->size);
	if (NULL == newNode->datap)
	{
		free(newNode);  // 不要忘记释放前面申请成功的空间
		return -2;
	}

	/* 第三步：把新数据复制到节点中的数据地址 */
	memmove(newNode->datap, data, list->size);

	/* 第四步：找到合适的插入点 */
	Node_t *i;	
	for (i = list->head.next; i != &list->head; i = i->next)
	{
		if (func(i->datap,data) >= 0)
		{			
			break;
		}
	}
	
	/* 第五步：把新节点插入到合适的插入点中 */
	insertNode(i->prev,i,newNode);
	
	/* 第六步：链表节点数+1 */
	list->n += 1;

	return 0;	// 成功返回0
}

/**
 * @函数名: searchListOneByItem
 * @函数功能: 根据条件查找节点，如果有多个匹配则查找第一个
 * @参数: list:链表地址  func:用于比较数据的回调函数  item:条件地址
 * @返回值: 查找成功返回节点地址，失败返回NULL
 */
void *searchListOneByItem(List_t *list, compare_t *func, void *item)
{
	Node_t *i;

	i = list->head.next; 
	while (i != &list->head)
	{		
		if (func(i->datap, item) == 1) // 回调函数返回1表示条件匹配
		{
			return i->datap;
		}
		i = i->next;
	}

	return NULL;
}

/**
 * @函数名: searchListByItem
 * @函数功能: 根据条件查找节点，如果有多个匹配则全部查找
 * @参数: list:链表地址  func:用于比较数据的回调函数  item:条件地址
 * @返回值: 查找成功返回结果链表地址，失败返回NULL
 */
List_t *searchListByItem(List_t *list, compare_t *func, void *item)
{
	List_t *result;
	Node_t *i;

	/* 创建查找的结果链表 */
	result = initialList(list->size);
	if (NULL == result)
	{
		return NULL;
	}

	/* 遍历查找匹配的节点 */
	i = list->head.next; 
	while (i != &list->head)
	{
		if (func(i->datap, item) == 1)	// 回调函数返回1表示条件匹配
		{
			appendListTail(result, i->datap);
		}
		i = i->next;
	}
	
	/* 判断查找是否成功 */
	if (0 == result->n)
	{
		return NULL;
	}
	
	return result;
}

/**
 * @函数名: deleteListOneByItem
 * @函数功能: 根据条件删除节点，如果有多个匹配则删除第一个
 * @参数: list:链表地址  func:用于比较数据的回调函数  item:条件地址
 * @返回值: 删除成功返回0，失败返回非零
 */
int deleteListOneByItem(List_t *list, compare_t *func, void *item)
{
	Node_t *i = list->head.next;		// 第一个节点

	/* 查找删除 */
	while (i != &list->head)
	{
		if (func(i->datap, item) == 1)	// 回调函数返回1表示条件匹配
		{
			i->next->prev = i->prev;
			i->prev->next = i->next;
			free(i->datap);				// 删除节点中的数据
			free(i);					// 删除节点本身
			list->n -= 1;				// 记得修改节点个数
			return 0;
		}
		i = i->next;
	}
	
	return -1;
}

/**
 * @函数名: deleteListByItem
 * @函数功能: 根据条件删除节点，如果有多个匹配则删除全部
 * @参数: list:链表地址  func:用于比较数据的回调函数  item:条件地址
 * @返回值: 返回成功删除的个数
 */
int deleteListByItem(List_t *list, compare_t *func, void *item)
{
	int count = 0; 		 // 统计删除的个数
	Node_t *i, *next;

	/* 查找删除 */
	i = list->head.next; //	第一个节点
	while (i != &list->head)
	{
		if (func(i->datap, item) == 1)	// 回调函数返回1表示条件匹配
		{
			next = i->next;				// 先保存好下一个节点
			
			/* 删除 */
			i->next->prev = i->prev;	
			i->prev->next = i->next;
			free(i->datap);				// 删除节点中的数据
			free(i);					// 删除节点本身
			list->n -= 1;				// 记得修改节点个数
			
			count++;					// 累加删除个数
			i = next;					// 下一个继续
			continue;
		}
		i = i->next;
	}

	return count;						// 返回成功删除的个数
}

/**
 * @函数名: sortList
 * @函数功能: 对链表进行排序
 * @参数: list:链表地址  func:用于比较数据的回调函数
 * @返回值: void
 */
void sortList(List_t *list, compare_t *func)
{
	Node_t *i, *j;
	void *temp;

	/* 冒泡排序法 */
	for (i = list->head.next; i != &list->head; i = i->next)
	{	
		for (j = i->next; j != &list->head; j = j->next)
		{
			if (func(i->datap, j->datap) == 1)	// 排列顺序有回调函数决定
			{
				/* 交换节点中的数据地址 */
				temp = i->datap;
				i->datap = j->datap;
				j->datap = temp;
			}
		}
	}		
}

/**
 * @函数名: saveListToFile
 * @函数功能: 把链表保存到文件中
 * @参数: list:链表地址  file:用于保存链表的文件名
 * @返回值: 成功保存返回0，失败返回非零
 */
int saveListToFile(List_t *list, char *file)
{
	FILE *fout;
	int ret;

	/* 打开文件用于写操作 */
	fout = fopen(file,"w");
	if (NULL == fout)
	{
		return -1;
	}

	/* 保存链表节点中的数据空间大小 */
	ret = fwrite(&list->size,sizeof(int),1,fout);
	if (ret != 1)
	{
		fclose(fout);
		return -2;
	}

	/* 保存链表节点数据 */
	Node_t *i = list->head.next;
	while (i != &list->head)
	{
		ret = fwrite(i->datap,list->size,1,fout);
		if (ret != 1)
		{
			fclose(fout);
			return -3;
		}
		i = i->next;
	}

	/* 关闭文件保存退出 */
	fclose(fout);
	return 0;
}

/**
 * @函数名: loadListFromFile
 * @函数功能: 从文件中加载链表
 * @参数: file:用于加载链表的文件名
 * @返回值: 加载成功返回链表地址，失败返回NULL
 */
List_t *loadListFromFile(char *file)
{
	List_t *result;
	FILE *fin;
	int ret;

	/* 打开文件用于加载链表数据 */
	fin = fopen(file, "r");
	if (NULL == fin)
	{
		goto exit1;
	}

	/* 初始化结果链表 */
	result = initialList(0);
	if (NULL == result)
	{
		goto exit2;
	}

	/* 加载链表节点中的数据空间大小 */
	ret = fread(&result->size,sizeof(int),1,fin);
	if (1 != ret)
	{
		goto exit3;
	}

	/* 加载数据节点 */
	void *data = malloc(result->size);
	if (NULL == data)
	{
		goto exit3;
	}
	while (1)
	{
		ret = fread(data,result->size,1,fin);

		/* 判断读是否出错或读到文件尾了 */
		if (ferror(fin))
		{
			goto exit4;
		}
		else if (feof(fin))
		{
			break;
		}

		/* 把节点添加到链表尾 */
		ret = appendListTail(result,data);
		if (ret != 0)
		{
			goto exit4;
		}
	}

	/* 加载数据成功 */
	fclose(fin);
	free(data);

	return result;

/* 出错后的层次退出 */
exit4: 
	free(data);
exit3:
	destroyList(result);
exit2:
	fclose(fin);
exit1:
	return NULL;
}

/**
 * @函数名: traverseListForward
 * @函数功能: 前向遍历链表
 * @参数: list:链表地址  func:用于打印数据的回调函数
 * @返回值: void
 */
void traverseListForward(List_t *list, void (*func)(void *data))
{
	Node_t *i;

	for (i = list->head.next; i != &list->head; i = i->next)
	{
		func(i->datap);		// 调用回调函数打印结果
	}
}

/**
 * @函数名: traverseListBackward
 * @函数功能: 后向遍历链表
 * @参数: list:链表地址  func:用于打印数据的回调函数
 * @返回值: void
 */
void traverseListBackward(List_t *list, void (*func)(void *data))
{
	Node_t *i;
	
	for (i = list->head.prev; i != &list->head; i = i->prev)
	{
		func(i->datap);		// 调用回调函数打印结果
	}
}

/**
 * @函数名: isEmptyList
 * @函数功能: 判断链表是否为空
 * @参数: list:需要判断的链表地址
 * @返回值: 链表为空返回1，不为空返回0
 */
int isEmptyList(List_t *list)
{
	return list->head.next == &list->head &&
		   list->head.prev == &list->head;
}

/**
 * @函数名: destroyList
 * @函数功能: 销毁链表
 * @参数: list:需要销毁的链表地址
 * @返回值: 无
 */
void destroyList(List_t *list)
{
	Node_t *i, *next;

	i = list->head.next;
	while (i != &list->head)
	{
		next = i->next;		// 先保存下一个节点

		free(i->datap);		// 释放节点中的数据空间
		free(i);			// 释放节点

		i = next;
	}

	free(list);				// 释放链表
}
柒辰
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
线性表顺序表示、链式表示实现方法及其异同点
Baimax的博客
05-10 1184
线性表是最常用且最简单的一种数据结构，按存储单元排列可分为顺序表示和链式表示两种方式。 本文采用C++实现两种表示方法。 目录 顺序表示和链式表示的区别： 创建方式： 时间复杂度： 顺序表示和链式表示的相同点： 删除内存空间： 代码实现： 顺序表示方法： 结构体定义 初始化 增加元素 删除元素 销毁列表 链式表示方法 结构体定义 初始化 增加节点 删除节点 显示链表 销毁链表 顺序表示和链式表示的区别： 创建方式： 顺序表示方法单次创建多个存储单元，相邻
数据结构-- 线性表
06-09
线性表（linear list）是最基本、最简单、也是最常用的一种数据结构 线性表中数据元素之间的关系是一对一的关系， 即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的 特征1：集合中必存在唯一的一个...
数据结构——线性表
manxianglin的博客
01-09 659
数据结构——线性表 概念介绍 线性表是一种最简单常用的基本数据结构，线性表在计算机中可以用顺序存储和链式存储 两种存储结构表示。用顺序存储结构表示的线性表为顺序表，用链式存储结构表示的线性表为链表 。 线性表是由n（n>=0）个数据元素所构成的有限序列，通常表示为（a0,a1,…,ai,…an-1),i表示位序号，n表示线性表的表长。所以我们所熟知的数组就是一种线性表。 线性表的抽象类型描述 1、什么是抽象类型描述？ 抽象数据类型包含一般数据类型的概念，但含义比一般数据类型更广、更抽象。抽象数据类型通
数据结构：线性表之顺序表和链表（Java实现）
sc179的博客
12-24 454
1 线性表简介 线性表是最基本、最简单、也是最常用的一种数据结构，一个线性表是若干个具有相同特性的数据元素的有限序列； 数据元素之间具有一种“一对一”的逻辑关系； 前驱元素：若A元素在B元素的前面，则称A为B的前驱元素； 后继元素：若B元素在A元素的后面，则称B为A的后继元素； 第一个数据元素没有前驱，这个数据元素被称为头结点； 最后一个数据元素没有后继，这个数据元素被称为尾结点； 除了第一个和最后一个数据元素外，其他数据元素有且仅有一个前驱和一个后继； 2 线性表分类 线性表数据存储的方式有两种：顺序
实验一 线性表的顺序存储与实现_数据结构-链表（链表的基本实现C++）
weixin_39677203的博客
11-20 180
​线性表是最常用而且简单的一种数据结构，一个线性表是n个数据元素的有限序列。当线性表需要频繁查找，较少插入和删除时，通常采用顺序存储结构，若需要频繁插入和删除，通常采用基于链表的形式；当线性表的元素个数变化较大或不确定时，最好用链表，这样不需要考虑存储空间大小问题，当事先知道线性表的大小长度，用顺序存储结构效率会高一些。1、线性表的顺序表示和实现顺序表，基于数组的一种实现，一组地址连续的存储单元。...
数据结构之线性表
qq_56551150的博客
05-26 176
前言 线性表是最常用且最简单的一种数据结构。简言之，一个线性表是n 个数据元素的有限序列。线性表在逻辑上是一种线性结构，也就是说连续的一条直线，但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构存储。 目录二、线性表2.1顺序表2.1.1顺序表的实现 二、线性表 2.1顺序表 2.1.1顺序表的实现 概念及结构 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构一般情况下采用数组存储。在数组上完成增删查改。 顺序表一般可以分为： 1.静态顺序表：使用定长数组存储。 2
数据结构--线性表问题总结
qq_74896248的博客
09-17 463
for循环语句中的逻辑错误，在这个逻辑中其实只循环了一次，第一次如果判断成功，不报错，而只要不是第一次能判断成功，那么都回到else语句中，直接return -1。问题：在find函数中，for循环中不可以写作int i=0；应该在for循环外部定义再在for循环赋值。而当查找为1时，即第一次if内语句未实现，而else语句实现，就会报错。一种可能，vs2010支持不是c99，无法在for中定义。
数据结构--线性表顺序存储
Seinlvan的博客
09-29 652
1 线性表定义 由零个或多个数据元素组成的有限序列。 数学定义 若将线性表记为（a1,…,ai-1,ai,ai+1,…an）,则表中ai-1领先于ai,ai领先于ai+1,称ai-1是ai的直接前驱元素,ai+1是ai的直接后继元素。 所以线性表元素的个数n(n>=0)定义为线性表的长度，当n=0时，称为空表。 2 抽象数据类型 ADT 一个数学模型及定义在该模型上的一组操作。抽象数据类型的定义仅取决于它的一组逻辑特性，而与其在计算机内部如何表示和实现无关。 ADT 抽象数据类型名 Data 数据元素
大话数据结构--线性表
全网粉丝10W+、全栈领域优质创作者、掘金、阿里云等社区博客专家、专注于全栈领域和毕业项目实战
11-13 1048
线性表总目录前言三、线性表3.1 线性表的定义3.1.1实例3.2线性表的抽象数据类型3.3 线性表的顺序存储结构3.3.1 顺序存储定义3.3.2顺序存储方式3.3.3数据长度与线性表长度区别3.3.4 地址计算方法3.4 顺序存储结构的插入与删除3.4.1 获得元素操作3.4.2 插入操作3.4.3 删除操作3.4.4 线性表顺序存储结构的优缺点3.5 线性表的链式存储结构3.5.1 顺序存储结构不足的解决办法3.5.2线性表链式存储结构定义1.数据域和指针域2.头指针3.5.3 头指针与头结点的异同3
数据结构--线性表--思维导图.pdf
08-29
数据结构--线性表--思维导图.pdf 该资源主要讲解了数据结构中的线性表，包括线性表的定义、基本操作、顺序表和链表的存储方式、操作效率比较等。 线性表的定义： 线性表是一种逻辑结构，表示元素之间一对一相邻的...
数据结构--线性表.cpp
03-08
数据结构--线性表.cpp
数据结构-线性表-PPT
02-04
"数据结构-线性表-PPT" 数据结构是一门研究非数值计算的程序设计问题的学科，它研究的是计算机存储、表示、操作和保护非数值信息的方法和技术。线性表是数据结构的一种基本结构，它是一种线性结构，只有一个首结点...
数据结构-线性表-xmind思维导图
05-13
串、栈、队列的区分度在于数据的运算和逻辑结构，而他们的存储结构常用的都是顺序表和链表。 广义表和数组都是更抽象的线性表，数组对数据元素要求更严苛，广义表则是放开了数据元素的限定。他们都可以是递归定义，...
数据结构--线性表的顺序存储结构（c语言实现）
06-17
c语言实现的线性表顺序存储结构，包括初始化，设置线性表的值，增，删，改，查。
数据结构-线性表的链式存储
09-17
线性表是计算机科学中一种基础且重要的数据结构，它由有限个相同类型元素组成，按照线性顺序排列。在实际应用中，线性表的数据元素可以是数字、字符串、对象等各种类型。线性表的链式存储是数据结构课程中的核心概念...
线性表及其表现
FZUMRWANG的博客
03-31 257
多项式的表示 要表示这个多项式，需要表示两项：①系数，②指数 方法一：顺序存储结构直接表示 上面使用了数组来表示多项式，数组的下标表示指数，数组内存储系数，但是这会产生一个问题，那就是如果指数很大，那么怎么表示？ 难道是开一个很大的数组？No，空间浪费太大了这样 方法二：顺序存储表示非零项 将非零项所涉及的两个信息，系数和指数存储起来，例如： 多项式相加 从头开始，比较两个多项式当前对应项的...
java中线性表的两种实现方式区别
daguairen的博客
10-06 4650
注意：线性表的两种实现->顺序实现和链式实现 线性表的两种实现   顺序表 链表 空间性能 顺序表的存储空间是静态分布的，需要一个固定的数组，总有部分数组元素要浪费 链表的存储空间是动态分布，因此不会有空间被浪费。但由于链表需要额外的空间来为每个节点保存指针，因此也要牺牲一部分空间。 时间性能
数据结构-线性表09
01-20
线性表是数据结构中的基础概念，它是一个包含零个或多个数据元素的有限序列，这些元素遵循特定的顺序规则。在线性表中，每个元素要么是序列的开头（无直接前驱），要么位于中间（有一个直接前驱和一个直接后继），...
数据结构-顺序结构的线性表
最新发布
01-06
数据结构-顺序表
数据结构 - 线性表
09-13
线性表是一种常见的数据结构，它表示具有相同数据类型的一组元素的有序序列。线性表中的元素之间存在一种顺序关系，每个元素都有一个前驱和一个后继（除了第一个元素没有前驱，最后一个元素没有后继）。线性表可以用...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值