数据结构基础

最新推荐文章于 2024-04-01 15:49:45 发布
最新推荐文章于 2024-04-01 15:49:45 发布
阅读量474 收藏 1
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54670782/article/details/120180720
版权

线性表

线性表中的数据元素可以是各种各样的，但同一线性表中元素必定具有相同特性，即属同一数据对象，相邻数据元素之间存在着序偶关系。（唯一的头，唯一的尾，除头之外，其他节点都有唯一的前驱，除尾之外，其他节点都有唯一的后继。）
线性表是一个相当灵活的数据结构，它的长度可根据需要增长或缩短，即对线性表的数据元素不仅可以进行访问，还可以进行插入和删除等。
线性表有两种数据结构表现形式：

  1. 顺序表 （逻辑相邻，物理上也相邻） 是一种权限更多的数组
  2. 链表 （逻辑相邻，物理上不一定相邻）

时间复杂度：语句与问题规模之间的函数关系
经常遇见的时间复杂度：

  1. O（1） 没有循环， 要么有循环但是循环退出条件和问题规模之间没有关系——循环次数是一个常数
  2. O（n） 有循环，并且循环的次数与问题规模之间有关系（控制循环的变量每次+1或-1来执行）
  3. O（n^2）循环嵌套
  4. O（log n）有循环,并且循环次数与问题规模之间有关系（控制循环变量每次*2或者/2来执行）

空间复杂度：函数所需要的的额外（除函数数据计算本身的存储空间之外）的存储空间与问题规则之间的函数关系

时间复杂度的省略（渐变）规则：

  1. 只要最高项
  2. 不要系数

顺序表（需要挪动数据）

顺序表的特点：
1.很简单 好理解；
2.随机访问数据的时间复杂度为O（1）
3.插入数据的时候时间复杂度为O（n) 尾插的时候时间复杂度为O（1）
4.删除数据的时候时间复杂度为O(n) 尾删的时候时间复杂度为O（1）
为啥有这些特点：因为顺序表的数据之间，逻辑上相邻，物理上也相邻

定长顺序表
在这里插入图片描述
在这里插入图片描述
sqlist.h


//放函数的声明以及结构体的定义
#pragma once//防止头文件重复

//顺序表  定长的顺序表  10

typedef struct SQlist
{
	int data[10];
	int length;
}SQList, * PSQlist;

//typedef SQlist *PSQlist;

//增删改查
void Init_SQlist(PSQlist ps);//PSQlist == SQlist*   初始化
bool Insert(PSQlist ps, int pos, int val);//按位置插入值w为val
bool Del_pos(PSQlist ps, int pos);//按位置删除
bool Del_val(PSQlist ps, int val);//按值删除
bool IsEmpty(PSQlist ps);//判空
bool IsFull(PSQlist ps);//判满
int Get_Length(PSQlist ps);//获取有效长度
void Clear(PSQlist ps);//清空
void Destroy(PSQlist ps);//销毁
void Show(PSQlist ps);//打印

sqlist.cpp

#include <stdio.h>
#include <assert.h>
#include "sqlist.h"


void Init_SQlist(PSQlist ps)//PSQlist == SQlist*
{
	assert(ps != NULL);
	if (ps == NULL)
	{
		return;
	}

	//ps->data 数据域不需要初始化
	ps->length = 0;
}

bool Insert(PSQlist ps, int pos, int val)
{
	assert(ps != NULL && 0 <= pos && pos <= ps->length);
	if (ps == NULL || pos<0 || pos>ps->length)
	{
		return false;
	}

	if (IsFull(ps))
	{
		return false;
	}

	//挪动数据，将插入位置空出来
	for (int i = ps->length - 1; i >= pos; i--)
	{
		ps->data[i + 1] = ps->data[i];
	}

	//把值插进去
	ps->data[pos] = val;
	ps->length++;
	return true;
}

bool Del_pos(PSQlist ps, int pos)
{
	assert(ps != NULL && pos >= 0 && pos < ps->length);
	if (ps == NULL || pos < 0 || pos >= ps->length)
	{
		return false;
	}

	if (IsEmpty(ps))
	{
		return false;
	}

	//将数据向前覆盖
	for (int i = pos + 1; i < ps->length; i++)
	{
		ps->data[i - 1] = ps->data[i];
	}

	ps->length--;
	return true;
}

bool Del_val(PSQlist ps, int val)
{
	assert(ps != NULL);
	if (ps == NULL)
	{
		return false;
	}

	if (IsEmpty(ps))
	{
		return false;
	}

	//遍历一边，要删除的val存在与否
	int tmp = -1;
	for (int i = 0; i < ps->length; i++)
	{
		if (ps->data[i] == val)
		{
			tmp = i;
			break;
		}
	}
	if (tmp == -1)
	{
		return false;
	}
	//调用上一步写好的函数（按位置删除）
	Del_pos(ps, tmp);//这一个函数已经将length--了，所以不在需要length--

	return true;
}

bool IsEmpty(PSQlist ps)
{	
	assert(ps != NULL);
	return ps->length == 0;
}

bool IsFull(PSQlist ps)
{
	assert(ps != NULL);
	return ps->length == 10;
}

int Get_Length(PSQlist ps)
{
	assert(ps != NULL);
	return ps->length;
}

void Clear(PSQlist ps)
{
	assert(ps != NULL);
	ps->length = 0;
}

void Destroy(PSQlist ps)
{
	assert(ps != NULL);
	Clear(ps);
}


void Show(PSQlist ps)
{
	assert(ps != NULL);

	for (int i = 0; i < ps->length; i++)
	{
		printf("%d ", ps->data[i]);
	}
	printf("\n");
}

不定长顺序表
扩容：
1.5倍在某一刻，我们可以将前面不要的空间利用上
2倍 则不可以
vs用的扩容规则 1.5
gcc 用的扩容规则 2
DSQlist.h

#pragma once
//定长顺序表 简单 不实用    sqlist=sequence list

#define INIT_SIZE 10

typedef struct DSQlist
{
	int* data;//数据域 用来承接malloc申请来的空间
	int length;//有效长度个数
	int listsize;//总的空间大小（简单理解总的格子数）
}DSQlist,*PDSQlist;

//关于顺序表的增删改查

//初始化函数
void Init_list(PDSQlist ps);

//插入数据 按pos插入
bool Insert(PDSQlist ps, int pos, int val);

//删除数据 按位置删除 pos
bool Del_pos(PDSQlist ps, int pos);

//删除数据 按值删除 val
bool Del_val(PDSQlist ps, int val);

//查找 找到值为val的第一个元素 返回其下标 没有找到 返回-1
int Search(PDSQlist ps, int val);

//判空
bool IsEmpty(PDSQlist ps);

//判满
bool IsFull(PDSQlist ps);

//扩容
void Inc(PDSQlist ps);

//清空
void Clear(PDSQlist ps);

//销毁
void Destroy(PDSQlist ps);

//打印
void Show(PDSQlist ps);
//获取长度
int Get_length(PDSQlist ps);

DSQlist.cpp

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include"DSQlist.h"

//关于顺序表的增删改查
//初始化函数
void Init_list(PDSQlist ps)
{
	assert(ps!= NULL);
	if (ps == NULL)
	{
		return;
	}
	ps->data = (int*)malloc(sizeof(int) * INIT_SIZE);
	assert(ps->data != NULL);

	ps->length = 0;
	ps->length = INIT_SIZE;
}

//插入数据 按pos插入
bool Insert(PDSQlist ps, int pos, int val)
{
	assert(ps!= NULL);
	//判断插入位置的合法性
	if (pos<0 || pos>ps->length)
	{
		return false;
	}
	//如果满了 则扩容
	if (IsFull(ps))
	{
		Inc(ps);
	}
	//挪动数据 把插入位置空间 空出来
	for (int i = ps->length - 1; i >= pos; i--)
	{
		ps->data[i + 1] = ps->data[i];
	}
	//把值放进去
	ps->data[pos] = val;
	//有效长度length++
	ps->length++;
	return true;
}

//删除数据 按位置删除 pos
bool Del_pos(PDSQlist ps, int pos)
{
	assert(ps!= NULL);
	//判断删除位置pos的合法性
	if (pos < 0 || pos >= ps->length)
	{
		return false;
	}
	//如果空 就不允许删除操作  可以不写
	
	//挪动数据 往前覆盖
	for (int i = pos; i + 1 <=ps->length; i++)
	{
		ps->data[i] = ps->data[i + 1];
	}
	//有效长度ps->length--
	ps->length--;
		return true;
}

//删除数据 按值删除 val
bool Del_val(PDSQlist ps, int val)
{
	assert(ps!= NULL);
	//通过函数Search来找val的下标
	int i = Search(ps, val);
	if (i == -1)//如果i=-1 代表没找到 则直接退出
	{
		return false;
	}
	//找到 则直接调用按位置pos删除函数 即可   ps->length 不需要减减 因为调用的函数已经减减过了
	Del_pos(ps, i);
	return true;
}

//查找 找到值为val的第一个元素 返回其下标 没有找到 返回-1
int Search(PDSQlist ps, int val)
{
	assert(ps!= NULL);
	for (int i = 0; i < ps->length; i++)
	{
		if (val == ps->data[i])
		{
			return i;
		}
	}
	return -1;
}

//判空
bool IsEmpty(PDSQlist ps)
{
	assert(ps!= NULL);
	return ps->length ==0;
}

//判满
bool IsFull(PDSQlist ps)
{
	assert(ps!= NULL);
	return ps->length == ps->listsize;
}

//扩容  按两倍扩容
void Inc(PDSQlist ps)
{
	assert(ps!= NULL);
	//malloc realloc calloc
	ps->data = (int*)realloc(ps->data, sizeof(int) * ps->listsize * 2);
	assert(ps->data != NULL);
	//ps->length;  不需要修改
	ps->listsize *= 2;
}

//清空
void Clear(PDSQlist ps)
{
	assert(ps!= NULL);
	ps->length = 0;
}

//销毁
void Destroy(PDSQlist ps)
{
	assert(ps!= NULL);
	free(ps->data);
	ps->data = NULL;
	ps->length = 0;
	ps->listsize = 0;
}

//打印
void Show(PDSQlist ps)
{
	assert(ps!= NULL);
	for (int i = 0; i < ps->length; i++)
	{
		printf("%d", ps->data[i]);
	}
	printf("\n");
}


int Get_length(PDSQlist ps)
{
	assert(ps!= NULL);
	int count = 0;
	for (int i = 0; i < ps->length; i++)
	{
		count++;
	}
	return count;
}

***单链表***有两种实现方式：

  1. 带头结点 （简单，实现简单，理解也简单）
  2. 不带头结点（头指针，难，因为会出现二级指针，不好实现，也不好理解）

在这里插入图片描述
在这里插入图片描述
找合适的位置：
for(p=plist;p->next!=NULL;p=p->next);//1 需要前驱，经常用于插入和删除操作等等
for(p=plist->next;p!=NULL;p=p->next);//2 不需要前驱,经常用于打印，查找
插入操作 两行代码 1.pnewnode->next=p->next;2.p->next=pnewnode;//pnewnode新节点的名字 p是插入位置
删除操作 三行代码 1.Node* q = p->next;//申请一个新指针，指向要删除的节点
2.p->next = q->next;让删除结点的上一个结点
3.free(q); //p指向删除结点的上一个节点，q指向删除节点

想通过子函数去影响父函数，必须有取地址操作并且还得有解引用操作（取地址和解引用缺一不可。

list.h

#pragma once
typedef int ELEMTYPE;

typedef struct Node
{
	ELEMTYPE data;//数据域  保存其数据本身
	struct Node* next;//指针域  指向下一个数据节点的地址
}Node, * PNode;

//增删改查

//初始化
void Init_list(Node* plist);//Node * == PNode

//头插
bool Insert_head(PNode plist, int val);

//尾插
bool Insert_tail(PNode plist, int val);

//按位置插入  pos  
bool Insert_pos(PNode plist, int pos, int val);

//按位置删除 pos 
bool Del_pos(PNode plist, int pos);

//按值删除 遇到值为val的第一个有效节点 删除掉 释放其内存
bool Del_val(PNode plist, int val);

//查找search 查找值我val的第一个节点，返回其地址
struct Node* Search(PNode plist, int val);

//寻找值为val的节点的前驱
Node* Get_prior(PNode plist, int val);

//寻找值为val的节点的后继
Node* Get_next(PNode plist, int val);

//判空
bool IsEmpty(PNode plist);

//判满
bool IsFull(PNode plist);

//获取其有效值长度
int Get_length(PNode plist);

//清空
void Clear(PNode plist);

//销毁
void Destroy(PNode plist);

//打印
void Show(PNode plist);

list.cpp

#include <stdio.h>
#include <assert.h>
#include <malloc.h>
#include "list.h"

//初始化
void Init_list(Node* plist)//Node * == PNode
{
	assert(plist != NULL);
	if (plist == NULL)
		return;

	//plist->data; 不需要初始化， 因为没有使用，直接浪费掉了
	plist->next = NULL;
}

//头插
bool Insert_head(PNode plist, int val)
{
	assert(plist != NULL);
	//申请新节点
	Node* pnewnode = (Node*)malloc(sizeof(Node) * 1);
	assert(pnewnode != NULL);
	pnewnode->data = val;
	//pnewnode->next = NULL; 这里不需要初始化， 因为接下来就会对其重新赋值

	//直接插入 1 2 顺序不能反
	pnewnode->next = plist->next;//1
	plist->next = pnewnode;//2
	return true;
}

//尾插
bool Insert_tail(PNode plist, int val)
{
	assert(plist != NULL);
	
	//1.创建新结点
	Node* pnewnode = (Node*)malloc(sizeof(Node));
	assert(pnewnode != NULL);
	pnewnode->data = val;
	//2.找到合适的插入位置
	Node* p = plist;
	for (p = plist; p->next != NULL; p = p->next);//让for循环跑完，p刚好指向最后一个有效节点

	//3.插入
	pnewnode->next = p->next;
	p->next = pnewnode;

}

//按位置插入  pos  
bool Insert_pos(PNode plist, int pos, int val)
{
	assert(plist != NULL);
	//创建新结点
	Node* pnewnode = (Node*)malloc(sizeof(Node) * 1);
	assert(pnewnode != NULL);
	pnewnode->data = val;

	//找合适的插入位置 根据pos
	Node* p = plist;
	for (int i = 0; i < pos; i++)
	{
		p = p->next;
	}
	//插入
	pnewnode->next = p->next;//新节点的next域赋值为之前上一个结点的next（保证后面的结点不丢失）
	p->next = pnewnode;//让前驱结点的next指向新节点
	return true;

}

//按位置删除 pos 
bool Del_pos(PNode plist, int pos)
{
	assert(plist != NULL);
	if(pos<0||pos>=Get_length(plist))
	{
		return false;
	}
	//1.找到删除结点的上一个结点
	Node* p = plist;
	for (int i = 0; i < pos; i++)
	{
		p = p->next;
	}
	//2.删除要删除的结点
	Node* q = p->next;//申请一个新指针，指向要删除的节点
	p->next = q->next;//p->next=p->next->next;//让删除结点的上一个结点的next指向删除结点的下一个节点的结点
	free(q);//释放要删除的结点
	return true;
}

//按值删除 遇到值为val的第一个有效节点 删除掉 释放其内存
bool Del_val(PNode plist, int val)
{
	assert(plist != NULL);
	Node* p = Get_prior(plist, val);
		if (p == NULL)
		{
			return false;
		}
		Node* q = p->next;
		p->next = q->next;
		free(q);
		return true;
}

//查找search 查找值我val的第一个节点，返回其地址
struct Node* Search(PNode plist, int val)
{
	assert(plist != NULL);
	//遍历一遍单链表，找值为val的结点，将其地址返回
	for (Node* p = plist->next; p != NULL; p = p->next)
	{
		if (p->data == val) //判断当前节点的数据域是否为val
		{
			return p;
		}
	}
	return NULL;
}

//寻找值为val的节点的前驱
Node* Get_prior(PNode plist, int val)
{
	assert(plist != NULL);
	Node* p = plist;
	for (p; p->next!= NULL; p = p->next)
	{
		if (p->next->data == val)
		{
			return p;
		}
	}
	return NULL;
}

//寻找值为val的节点的后继
Node* Get_next(PNode plist, int val)
{
	Node* p = Search(plist, val);
	if (p == NULL)
	{
		return NULL;
	}
	return p->next;
}

//判空
bool IsEmpty(PNode plist)
{
	return plist->next == NULL;
}

//判满
//bool IsFull(PNode plist) ; 单链表不存在判满操作

//获取其有效值长度
int Get_length(PNode plist)
{
	int count = 0;
	for (Node* p = plist->next; p != NULL; p = p->next)
	{
		count++;
	}
	return count;
}

//清空
//单链表的清空，和销毁实现方式一样，都是将malloc来的结点全部释放掉
void Clear(PNode plist)
{
	Destroy(plist);
}

//销毁
void Destroy(PNode plist)//一直头删
{
	assert(plist != NULL);
	while (plist->next != NULL)//每次判断第一个有效节点是否存在
	{
		Node* p = plist->next;
		plist->next = p->next;
		free(p);
	}
	plist->next = NULL;//此时没有有效结点，那么将plist->next置为空
}

void Destroy2(PNode plist)
{
	assert(plist != NULL && plist->next != NULL);
	Node* p = plist->next;
	Node* q;
	plist->next = NULL;
	while (p != NULL)
	{
		q = p->next;
		free(p);
		p = q;
	}
}
//打印
void Show(PNode plist)
{
	for (Node* p = plist->next; p != NULL; p = p->next)
	{
		printf("%d", p->data);
	}
	printf("\n");
}

顺序表：逻辑相邻，物理相邻
随机访问时间复杂度O（1）
插入时间复杂度O（n） 尾插的时间复杂度O（1）
删除时间复杂度O（n） 尾删的时间复杂度O（1）
查找search时间复杂度O（n）
单链表：逻辑相邻，物理不一定相邻
随机访问时间复杂度O（n）
插入的时间复杂度O（1） 不需要挪动数据
删除的时间复杂度O（1） 不需要挪动数据
查找search时间复杂度O（n）
如果经常访问节点，不经常插入和删除结点 选顺序表
如果经常插入和删除结点，不经常访问结点 选单链表

Wu~~~~
关注
专栏目录
【数据结构基础】矩阵的存储结构，数组，三元组表及十字链表
wayne_lee_lwc的博客
12-04 1万+
前言 数据结构，一门数据处理的艺术，精巧的结构在一个又一个算法下发挥着他们无与伦比的高效和精密之美，在为信息技术打下坚实地基的同时，也令无数开发者和探索者为之着迷。 也因如此，它作为博主大二上学期最重要的必修课出现了。由于大家对于上学期C++系列博文的支持，我打算将这门课的笔记也写作系列博文，既用于整理、消化，也用于同各位交流、展示数据结构的美。 此系列文章，将会分成两条主线，一条“数据结构基础”，一条“数据结构拓展”。“数据结构基础”主要以记录课上内容为主，“拓展”则是以课上内容为基础的更加高深的数据结构
数据结构基础知识核心归纳(一)
老蒋也疯狂
09-09 2万+
堆是一种树状的数据结构。一般由程序员分配释放，存放由new创建的对象和数组(C中是由malloc分配和free释放)，JVM不定时查看这个对象，如果没有引用指向这个对象就回收.1)优点：可动态分配内存大小，生成周期不必事先告诉编译器，Java垃圾回收自动回收数据；2)缺点：运行时需动态分配内存，因此，数据存储速度较慢
线性表的一些概念
hixiaowen的专栏
03-11 731
一、线性表的概念： 1、线性表中的数据元素可以是各种各样的，但同一线性表 中的元素必定具有相同的特征（属于同一数据对象），相邻元素之间存在序偶关系 2、记录：一个数据元素含有多个数据项 3、含有大量记录的线性表成为文件 二、线性表的基本操作： 增： InitList（&L）：构造一个空的线性表 ListInsert（&L，i，e）：插入结点 删： ListDelete（&L，i，
线性表文档之线性表
二木成林
04-05 1951
线性表文档之线性表
线性表
、moddemod
01-22 327
  线性表是n个数据元素的有限序列.一个数据元素可以是由若干个数据项组成的,在这种情况下,长把数据元素称为记录,韩有大量记录的线性表称为文件.线性表中的元素可以是各种各样的,但同一线性表中的元素必定具有相同特性,即属同一数据对象,相邻数据元素之间存在着序偶关系.   线性表中元素的个数n定义为线性表的长度,n=0时称为空表.线性表是一个相当灵活的数据结构,它的长度可根据需要增长或缩短,即对线性表的...
数据结构-线性表(学习笔记)
maweisky531的专栏
08-11 363
定义： 1.线性表(List)是零个或多个数据元素的集合 2.线性表中的数据元素之间是有顺序的 3.线性表中的数据元素个数是有限的 4.线性表中的数据元素的类型必须相同  线性表是具有相同类型的 n（ ≥ 0）个数据元素的有限序列 a1, a2, …, an ,ai是表项，n 是表长度。 性质: 1.a0为线性表的第一个元素，只有一个后继 2.an为线性表的最后一个元素，只
数据结构 第二章（线性表）
最新发布
Zevalin的博客
04-01 1621
同一线性表中的元素必定具有相同的特性，即属于同一数据对象，相邻数据元素之间存在着序偶关系。由n（n≥0）个数据特性相同的元素构成的有限序列称为线性表，线性表中元素的个数n定义为线性表的长度，当n=0时称之为空表。对于非空的线性表或线性结构，其特点是：①存在唯一的一个被称作“第一个”的数据元素。②存在唯一的一个被称作“最后一个”的数据元素。③除第一个元素之外，结构中的每个数据元素均只有一个前驱。④除最后一个元素之外，结构中的每个数据元素均只有一个后继。​。
C++与数据结构基础简明教程
04-23
C++与数据结构基础简明教程
数据结构基础知识（1）
greengirl5的博客
10-10 4087
快速排序，从前往后查找比该数大的数，交换位置，从后往前查找比该数小的数，交换位置 双向链表和双向循环链表：通过双向循环的头指针可以直接找到尾结点，而普通双向链表需要从头到尾遍历 二叉树不是线性结构，完全二叉树是效率很高的数据结构，堆是一种完全二叉树或近似完全二叉树，效率极高 数据的逻辑结构反映的是数据元素之间的逻辑关系 逻辑结构就是数据之间的关系，而按数据之间的关系来说，逻辑结构大概可以分为：线性结构和非线性结构（集合、树、网） 数据的基本单位是数据元素，而数据的最小单位是数据项 算法分析的两个主要方面是：
【数据结构】线性表的介绍
WINGREZ‘S BLOG
07-31 2045
参考资料：《数据结构（C语言版）严蔚敏著》 版权说明：未经作者允许，禁止转载。如引用本文内容，需标明作者及出处。如本文侵犯了您的权益，请联系我删除并致歉。 文章说明：如文章中出现错误，请联系我更改。如您对文章的内容有任何疑问，也欢迎来与我讨论。 本文正在施工中...请稍等... 线性表 线性结构的特点 （以下针对数据元素的非空有限集讨论） （1）存在唯一一个被称作“第一个”的数据元素； （2...
【数据结构】线性表知识大全
小白_xm
05-01 3038
1、线性表的定义 线性表是具有相同数据类型的 n（n>=0）个数据元素的有限序列，其中 n 为表长，当 n=0 时线性表是一个空表。若用 L 命名线性表，其一般表示为： L = (a1,a2,...,ai,ai+1,...,an) 式中，a1 是唯一的“第一个”数据元素，又称表头元素；an 是唯一的“最后一个”数据元素，又称表尾元素。除第一个元素外，每个元素有且只有一个直接前驱。除最后一个元素外，每个元素有且只有一个直接后继。 线性表具有如下特点： 表中元素的个数有限 表中元素具有逻辑
【算法与数据结构】数据结构之线性表
a594218234的博客
09-25 201
线性表 初步了解 线性表或称为有序表（Ordered Likst） 本质：线性表 就是n个元素的有限序列（n≥0） 如：最简单的有序表就是字母表：A,B,C,D,…，Z就是 一个线性表。 线性表定义 线性表数据元素可以是任何一种类型 对于同一线性表的每一个元素都必须属于同一类型 线性表可以 形容为： 可以是空集合，或者可写成 (a₁## 线性表 初步了解 线性表或称为有序表（Ordered Likst）- 本质：线性表 就是n个元素的有限序列（n≥0）> 如：最简单的有序表就是字母
线性表总结
weixin_46447561的博客
09-24 385
线性表 1、定义： 是由n(n>=0)个具有相同特性（同一类型）的数据元素(结点)a1，a2， …an组成的有限序列的线性结构; 当n=0时，称为空表 当n>0时，将非空的线性表记作： (a1，a2，…an) a1称为线性表的首结点，an称为线性表的尾结点 2、基本特点 数据元素有序且是有限的； 3、性质 ◆ 除第一个元素外，每个元素均有唯一一个直接前驱 ◆ 除最后一个元素外，每个元素均有唯一一个直接后继 ◆ 所有结点具有相同的数据类型 注意，“前驱”、“后继”和“直接**”的区别 ——
数据结构_线性表
水逝流年
04-09 4177
线性结构有这样的特点，在数据元素的非空有限集中：（1）存在唯一的一个被称作“第一个”的元素；（2）存在唯一的一个被称作“最后一个”的数据元素；（3）除第一个之外，集合中的每个数据元素均只有一个前驱；（4）除最后一个之外，集合中的每个数据元素均只有一个后继。 1、介绍 线性表（linear List）是最常用而且最简单的一种数据结构，简单地说，一个线性表是n个数据元素的有限序列。在稍微复杂的线性
二、线性表
余笙的博客
06-02 726
一、线性表的概述 1、线性表的概念 线性表属于最基本、最简单、也是最常用的一种数据结构，从逻辑上划分它属于线性结构。一个线性表是由n个相同特性的数据元素组成的有限序列，数据元素之间有一种线性的或“一对一”的逻辑关系。 线性表应该满足下面三个要求： 第一个数据元素没有直接前驱，这个数据元素被称为开始结点。 最后一个数据元素没有直接后继，这个元素被称为终端结点。 除了第一个和最后一个数据元素外，其它数据元素有且仅有一个直接前驱和一个直接后继。 线性表特点： 顺序性：在线性表中，相邻数据元
线性表，线性表和链表的区别
weixin_30588729的博客
09-21 2346
存储类别 顺序存储结构单链表 存储分配方式 用一段连续的存储单元依次存储线性表的数据元素 采用链式存储结构，用一组任意的存储单元存放线性表的元素 时间性能 查找O（1）、插入和删除O（n） 查找O（n）、插入和删除O（1） 空间性能 需要预分配存储空间，分大了浪费，小了容易发生上溢 不需要分配存储空间，只要有就可以分配，元素个数不受限制...
线性表-第2章-《数据结构习题集》答案解析-严蔚敏吴伟民版
热门推荐
StrayedKing-245176013
12-26 8万+
严蔚敏吴伟民版《数据结构习题集》第2章线性表部分答案+习题解析。
数据结构基础概念解析
"数据结构概念名词解释大全" 数据结构是计算机科学中不可或缺的一部分，它主要研究数据的...这些基本概念构成了数据结构的基础，理解它们对于学习和应用数据结构至关重要，因为它们直接影响到算法的设计和程序的效率。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值