数据结构复习（二）—— 线性表

最新推荐文章于 2023-05-23 23:42:16 发布
最新推荐文章于 2023-05-23 23:42:16 发布
阅读量1.2k 收藏 3
点赞数 1
分类专栏： C语言 文章标签： 数据结构 链表 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45673283/article/details/121903167
版权
1.在第i个位置插入元素e(带头结点)
typedef struct LNode{
	ElemType data;
	struct LNode *next;
}LNode,*LinkList;

//在第i个位置插入元素e(带头结点)
bool LinkList(LinkList &L,int i,ElemType e)
{
	if(i<1)	//位序从1开始
		return false;
	LNode *p; 	//指针p指向当前扫描到的结点
	int j=0;	//当前p指向第几个结点
	p=L;		//p指向头结点，即第0个结点(不存数据)
	while(p!==NULL && j<i-1) //循环找到第 i-1个结点 
	{
		p=p->next;
		j++; 
	}
	if(p==NULL)	//i值不合法
		return false;
	LNode *s = (LNode *)malloc(sizeof(LNode));	//申请待插入结点空间 
	s->data = e; 
	s-next=p->next;	//将原来跟着p后的结点连接在新插入的结点s之后	
	p->next=s; 		//将插入的结点s连接在p之后 
	return true; 	//插入成功 
}
2.在第i个位置插入元素e(不带头结点)
typedef struct LNode{ 
	ElemType data;
	struct LNode *next;
}LNode,*LinkList;

bool LinkList(LinkList &L,int i,ElemType e)
{
	if(i<1)		//位序从1开始
		return false;	
	if(i==1)	//插入第1个结点的操作与其他结点不同，需要修改头指针
	{
		LNode *s = (LNode *)malloc(sizeof(LNode));
		s-data=e;
		s->next=L;	//新插入结点指向原来第一个结点 
		L=s;	//头指针重新指向新插入结点 
		return true;
	} 
	LNode *p;	//指针p指向当前扫描到的结点
	int j=1;	//当前p指向的是第几个结点
	p=L;		//p刚开始指向第1个结点(不带头结点)
	while(p!=NULL && j<i-1)	//循环找到第 i-1 个结点 
	{
		p=p->next;
		j++; 
	} 
	if(p==NULL)	//i值不合法
		return false;
	LNode *s = (LNode *)malloc(sizeof(LNode));
	s->data=e;
	s->next=p->next;
	p->next=s;
	return true;	//插入成功 
}
3.指定结点的后插操作：在p结点之后插入元素 e
typedef struct LNode{ 
	ElemType data;
	struct LNode *next;
}LNode,*LinkList; 

//指定结点的后插操作：在p结点之后插入元素 e
bool InsertNextNode(LNode *p,ELemType e)
{
	if(p==NULL)
		return false;
	LNode *s=(LNode *)malloc(sizeof(LNode));
	if(s==NULL)		//内存分配失败(内存不足) 
		return false;
	s->data=e;		//用结点s保存数据元素 e 
	s->next=p->next;//s指向p之后的结点 
	p->next=s;		//p重新指向新插入的结点 s 
	return true; 
}

//在第i个位置插入元素e(带头结点)
bool LinkList(LinkList &L,int i,ElemType e)
{
	if(i<1)	//位序从1开始
		return false;
	LNode *p; 	//指针p指向当前扫描到的结点
	int j=0;	//当前p指向第几个结点
	p=L;		//p指向头结点，即第0个结点(不存数据)
	while(p!==NULL && j<i-1) //循环找到第 i-1个结点 
	{
		p=p->next;
		j++; 
	}
	return InsertNextNode(p,e);
}
4.指定结点的前插操作：在p结点之前插入元素 e
typedef struct LNode{ 
	ElemType data;
	struct LNode *next;
}LNode,*LinkList; 

bool InsertPriorNode(LNode *p,ELemType e)
{
	if(p==NULL)
		return false;
	LNode *s=(LNode *)malloc(sizeof(LNode));
	if(s==NULL)		//内存分配失败(内存不足) 
		return false;
	s->next=p->next;
	p->next=s;		//新结点 s连接到 p之后
	s->data=p->data;//将p中元素复制到s中 
	p->data=e;		 //p中元素覆盖为新元素e 
}
5.按位序删除(带头结点)
typedef struct LNode{ 
	ElemType data;
	struct LNode *next;
}LNode,*LinkList; 

bool ListDelete(LinkList &L, int i, ElemType &e)
{
	if(i<1)
		return false;	//位序从1开始
	LNode *p;	//指针p指向当前扫描到的结点
	int j=0;	//当前p指向的是第几个结点
	p=L;		//p指向第头结点，第0个结点
	while(p!=NULL && j<i-1)	//循环找到第i-1个结点 
	{
		p=p->next;
		j++;
	}
	if(p=NULL)	//i值不合法 
		return false;
	if(p->next==NULL)	//第i-1个结点之后已无其他结点 
		return false;
	LNode *q = p->next;	//令q指向被删除结点
	e=q->data;		//用e返回元素的值
	p->next=q->next;//将*q结点从链中"断开" 
	free(q);		//释放结点存储空间
	return true;	//删除成功 
}
6.指定结点的删除（带头结点）
typedef struct LNode{ 
	ElemType data;
	struct LNode *next;
}LNode,*LinkList;
//删除指定结点p
bool DeleteNode(LNode *p)
{
	if(p==NULL)
		return false;
	LNode *q=p->next;	//令q指向*p的后继结点
	p->data=q->data;	//和后继结点元素值复制给p结点元素 
	p->next=q->next;	//将q结点从链中"断开 "
	free(q);			//释放后继结点的存储空间 
	return true; 
}
7.按位查找，返回第 i个元素(带头结点)
LNode *GetELem(LinkList L,int i)
{
	if(i<0)
		return false;	//位序从1开始
	LNode *p;	//指针p指向当前扫描到的结点
	int j=0;		//当前 p 指向的是第几个结点
	p=L;			//L指向头结点，头结点是第0个结点（不存数据） 
	while(p!=NULL && j<i)	//循环找到第i个结点 
	{
		p=p->next;
		j++;
	}
	return p;
}
//平均时间复杂度：O(n)
8.按值查找，找到数据域==e 的结点
//按值查找，找到数据域==e 的结点
LNode *LocateElem(LinkList L,ElemType e)
{
	LNode *p = L->next;
	//从第 1 个结点开始查找数据域为 e 的结点 
	while(p!=NULL && p->data != e)
	{
		p=p->next;
	}
	return p;	//找到后返回该结点指针，否则返回 NULL 
}
9.求表的长度(带头结点)
int length(LinkList L)
{
	int len=0;	//统计表长,初始值为0
	LNode *p = L;
	while(p->next!=NULL) 
	{
		p=p->next;
		len++;
	}
	return len;
} 
//平均时间复杂度：O(n)
10.尾插法建立单链表(带头结点)
typedef struct LNode	//定义单链表结点类型 
{						
	Elemtype data;		//每个结点存放一个数据元素 
	struct LNode *next;	//指针指向下一个结点 
}LNode, *LinkList;

//初始化一个单链表(带头结点)
bool InitList(LinkList &L)
{
	L = (LNode *)malloc(sizeof(LNode));	//分配一个头结点
	if(L==NULL)	//内存不足分配失败 
		return false;
	L->next=NULL;	//头结点后无后继节点 
	return true;
} 

//尾插法建立单链表
LinkList List_TailInsert(LinkList &L)	//正向建立单链表 
{
	int x;	//设置Elemtype为int
	L = (LinkList)malloc(sizeof(LNode));	//建立头结点
	LNode *s,*r=L;	//r为表尾指针
	scanf("%d",&x);	//输入结点的值
	while(x!=9999)	// 9999 表示结束 
	{
		s=(LNode *)malloc(sizeof(LNode));
		s->data=x;
		r->next=s;
		r=s;	//指向新的表尾结点
		scanf("%d",&x); 
	} 
	r->next=NULL;	//表尾结点指针为NULL
	return L; 
} 


void test()
{
	LinkList L;	//声明一个指向单链表的指针 
	//初始化一个空表
	InitList(L);
	//........//
	 
}
11.头插法建立单链表(带头结点)
//头插法建立单链表(带头结点) 
typedef struct LNode	//定义单链表结点类型 
{						
	Elemtype data;		//每个结点存放一个数据元素 
	struct LNode *next;	//指针指向下一个结点 
}LNode, *LinkList;

//后插操作(带头结点) ： 
bool InsertNextNode(LNode *p,Elemtype e)
{
	if(p==NULL)
		return false;
	LNode *s=(LNode *)malloc(sizeof(LNode));
	if(s=NULL)	//内存分配失败
		return false;
	s->data=e;		//用结点s保存数据元素e 
	s->next=p->next;
	p->next=s;		//将结点s连接到p之后 
	return true; 
} 

//头插法建立单链表(带头结点)
///***重要应用：链表的逆置
LinkList List_HeadInsert(LinkList &L)
{
	LNode *s;
	int x;
	L=(LinkList)malloc(sizeof(LNode));	//创建头结点
	L->next=NULL;		//初始化为空链表 
	scanf("%d",&x);		//输入结点的值 
	while(x!=9999)
	{
		s=(LNode *)malloc(sizeof(LNode));
		s->data=x;
		s->next=L->next
		L->next=s;	//将新结点头插入表中，L为头指针 
		scanf("%d",&x); 
	}	
	return L;
}
12.双链表的初始化(带头结点)
//双链表的初始化(带头结点)
typedef struct DNode	//定义双链表结点类型 
{
	ElemType data;		//数据域 
	struct DNode *prior,*next;	//前驱和后继指针 
}DNode, *DLinkList;		//DLinkList <==> DNode *

//初始化双链表
bool InitDLinkList(DLinkList &L)
{
	L=(DNode *)malloc(sizeof(DNode));	//分配一个头结点
	if(L==NULL)			//内存不足，分配失败
		return false;	
	L->prior=NULL;	//头结点的prior指针永远指向NULL 
	L->next=NULL;	//头结点之后暂时无其他结点 
	return true;
} 

void test()
{
	//初始化双链表
	DLinkList L;
	InitDLinkList(L); 
}

//判断双链表是否为空（带头结点） 
bool Empty(DLinkList L)
{
	if(L->next == NULL)
		return true;
	else
		return false;
}
13.双链表的插入（带头结点）
//双链表的插入（带头结点） 
typedef struct DNode	//定义双链表结点类型 
{
	ElemType data;		//数据域 
	struct DNode *prior,*next;	//前驱和后继指针 
}DNode, *DLinkList;		//DLinkList <==> DNode *

//在p结点之后插入s结点
bool InsertNextDNode(DNode *p,DNode *s)
{
	if(p==NULL || s==NULL)	//非法参数
		return false; 
	s->next=p->next;	//将s结点插入到p结点之后 
	if(p->next!=NULL)	//如果p结点之后有后继结点 
		p->next->prior=s;
	s->prior=p;
	p->next=s;
	return true;
}
14.双链表的删除（带头结点）
//双链表的删除（带头结点） 
typedef struct DNode	//定义双链表结点类型 
{
	ElemType data;		//数据域 
	struct DNode *prior,*next;	//前驱和后继指针 
}DNode, *DLinkList;		//DLinkList <==> DNode *

//删除p结点的后继结点
bool DeleteNextDNode(DNode *p)
{
	if(p==NULL)
		return false;
	DNode *q=p->next;	//找到p的后继结点
	if(q==NULL)
		return false;	//p没有后继结点
	p->next=q->next;
	if(q->next=NULL)	//后继结点q不是尾结点
		q->next->prior=p;
	free(q);			//是否q结点空间
	return true; 
} 

//销毁双链表
void DestoryList(DLinkList &L)
{
	//每次释放头结点的后继数据结点 
	while(L->next!=NULL)
	{
		DeleteNextDNode(L);
	} 
	free(L);	//释放头结点 
	L=NULL;
}
15.双链表的遍历
//后向遍历
while(p!=NULL)
{
	//对结点p做相应处理，如打印
	p=p->next; 
} 

//前向遍历
while(p!=NULL)
{
	//对结点p做相应处理，如打印
	p=p->prior;
} 

//前向遍历(跳过头结点) 
while(p->prior != NULL)
{
	//对结点p做相应处理，如打印
	p=p->prior;
}
16.循环单链表
//循环单链表 
typedef struct LNode	//定义单链表结点类型 
{
	ElemType data;		//每个结点存放一个数据元素 
	struct LNode *next;	//指针指向下一个结点 
}LNode,*LinkList;

//初始化一个循环单链表
bool InitList(LinkList &L)
{
	L=(LNode *)malloc(sizeof(LNode));	//分配一个头结点
	if(L==NULL)			//内存不足，分配失败 
		return false; 	
	L->next=L;			//头结点next指向头结点本身 
	return true;
} 

//判断循环单链表是否为空
bool Empty(LinkList L)
{
	if(L->next==L)
		return true;
	else
		return false;
} 

//判断结点p是否为循环单链表的表尾结点
bool isTail(LinkList L,LNode *p)
{
	if(p->next == L)
		return true;
	else
		return false;
}
17.循环双链表
//循环双链表
typedef struct DNode
{
	ElemType data;
	struct DNode *prior,*next;
}DNode,*DLinkList;

//初始化空的循环双链表
bool InitDLinkList(DLinkList &L)
{
	L=(DNode *)malloc(sizeof(DNode));	//分配一个头结点
	if(L==NULL)				//内存不足，分配失败 
		return false;
	L->prior=L;			//头结点的prior指针指向头结点
	L->next=L;			//头结点的next指针指向头结点 
	 return true;
} 

//判断循环双链表是否为空 
bool Empty(DLinkList L)
{
	if(L->next == L)
		return true;
	else
		return false;
}

//判断p结点是否为循环双链表的表尾结点
bool isTail(DLinkList L,DNode *p)
{
	if(p->next==L)
		return true;
	else
		return false;
} 
void test()
{
	//初始化循环双链表
	DLinkList L;
	InitDLinkList(L);
	//....
18.循环双链表的插入
//循环双链表的插入 
typedef struct DNode
{
	ElemType data;
	struct DNode *prior,*next;
}DNode,*DLinkList;

//在p结点之后插入s结点
bool InsertNextDNode(DNode *p,DNode *s)
{
	s->next=p->next;
	p->next->prior=s;
	s->prior=p;
	p->next=s;
	return true;
} 

//删除p的后继结点q
bool DeleteNextDNode(DNode *p)
{
	if(p==NULL)
		return false;
	DNode *q=p->next;	//找到p的后继结点
	if(q==NULL)
		return false;	//p没有后继结点
	p->next=q->next;
	q->next->prior=p;
	free(q);			//是否q结点空间
	return true; 
}
19.静态链表
//静态链表
#define MaxSize 10		//静态链表的最大长度
struct Node				//静态链表结构类型的定义 
{
	ElemType data;		//存储数据元素 
	int next;			//下一个元素的数组下标 
};
typedef struct Node SLinkList[MaxSize];	//可用SLinkList定义 “一个长度为MaxSize的Node型数组” 

//等价于下面定义 
#define MaxSize 10	 /静态链表的最大长度
typedef struct 			//静态链表结构类型的定义 
{
	ElemType data;		//存储数据元素 
	int next;			//下一个元素数组下标 
}SLinkList[MaxSize];


void testSLinkList()
{
	struct Node a;
	//.......
}

//等价于 
void testSLinkList()
{
	struct Node a[MaxSize];
	//.......
}
20.验证猜想
//验证猜想
#include<stdio.h>
#define MaxSize 10		//静态链表的最大长度
struct Node				//静态链表结构类型的定义 
{
	int data;			//存储数据元素
	int next;			//下一个元素的数组下标
};

typedef struct				//静态链表结构类型的定义 
{
	int data;			//存储数据元素
	int next;			//下一个元素的数组下标
}SLinkList[MaxSize];

void testSLinkList()
{
	struct Node x;
	printf("sizeX=%d\n",sizeof(x));
	
	struct Node a[MaxSize];
	printf("sizeA=%d\n",sizeof(a));
	
	SLinkList b;
	printf("sizeB=%d\n",sizeof(b));
}
int main()
{
	testSLinkList(); 
	return 0;
}
21.静态链表
#define MaxSize 10	 //静态链表的最大长度
typedef struct 			//静态链表结构类型的定义 
{
	ElemType data;		//存储数据元素 
	int next;			//下一个元素数组下标 
}SLinkList[MaxSize];



void testSLinkList()
{
	SLinkList a;
	//.......
}
22.按位查找，返回第 i个元素(带头结点）
//2.7.1按位查找，返回第 i个元素(带头结点) 
typedef struct LNode{ 
	ElemType data;
	struct LNode *next;
}LNode,*LinkList; 

LNode *GetElem(LinkList L,int i)
{
	if(i<0)
		return NULL;	//带头结点，可以认为头结点为第0个结点
	LNode *p;	//指针p指向当前扫描到的结点
	int j=0;	//当前指针p指向的是第几个结点
	p=L;		//L指向头结点，头结点是第0个结点(不存数据)
	while(p!=NULL && j<i)
	{
		//循环找到第i个结点
		p=p->next;
		j++; 
	} 
	return p;
}
wings(hha)
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
第5章 散列查找
咕叽咕叽
11-28 1069
设有一组关键字 { 29，01， 13，15，56，20，87，27，69，9，10，74 }，散列函数为 H(key)=key%17，采用线性探测方法解决冲突。设有一组关键字 { 29，01， 13，15，56，20，87，27，69，9，10，74 }，散列函数为 H(key)=key%17，采用平方探测方法解决冲突。已知线性表的关键字集合 { 21，11， 13，25，48，6，39，83，30，96，108 }，散列函数为 h(key)=key%11，采用分离链接法解决冲突。
《数据结构》一般线性表的合并
千言万语ROOM
03-05 1万+
一般线性表的合并 算法思想： 遍历表A和表B，查看B的每一个元素是否在A中，若不在，将B的该元素插入到A的表尾，A表的表长+1。 算法的时间复杂度和A、B的长度有关，O（m*n）. //合并 void Combine(SqList &A,SqList &B){ for(int i=0;i<B.length;i++){ int count=0; for(int j=0;j<A.le
数据结构——排序查找算法作业(PTA 第12-13周）大一下
rempter的博客
05-16 4248
1. 稳定与不稳定：评价一个排序算法是否稳定，是指该算法完成排序的同时，是否会改变序列中 相同元素的相对位置。 稳定算法：冒泡、插入、归并 不稳定算法：希尔、选择、快速、计数、基数、桶排序 2.对N个不同的数据采用冒泡排序进行从大到小的排序，当元素基本有序时交换元素次数肯定最多。 错，基本有序排列次数最少。 3.快速排序的速度在所有排序方法中为最快,而且所需附加空间也最少() 错，它是基于比较的排序中最快的， 但是有些排序不需要比较， 比如桶排序、基数排序。另外 空间也不是最少， 堆排序就比快排...
NeuDs 数据结构 排序算法题目
WeFun_Han的博客
05-23 1324
* 对长度为n的数组arr执行冒泡排序 */ void bubbleSort(int arr[], int n);请实现bubbleSort函数，使排序后的数据从小到大排列。/* 对长度为n的数组arr执行插入排序 */ void insertionSort(int arr[], int n);请实现insertionSort函数，使排序后的数据从小到大排列。其中List/* 保存线性表中最后一个元素的位置 */ };L是用户传入的一个线性表，其中。
【PTA】【878真题】浙江大学软件学院878自命题2016真题
葑鈊丶
10-10 1615
选择题 2-1 若有以下说明和定义 typedef int *INTEGER; INTEGER a,*b; 那么以下叙述正确的是： 选项 A a 是 int 型的指针变量 B b 是 int 型的一级指针变量 C a 是 int 型变量 D 程序中可用 INTEGER 代替 int 类型名 解析：a 是 int 型的指针变量，b 是 int 型的二级指针变量。 2-2 下列程序段的输出结果是： int k=2, s=0; switch(k) { case 2:
《数据结构》_PTA_数据结构作业7：查找
国家一级致癌物
12-30 7924
判断题 1-1 在散列表中，所谓同义词就是具有相同散列地址的两个元素 T 1-2 在散列表中，所谓同义词就是被不同散列函数映射到同一地址的两个元素。 F 1-3 若用平方探测法解决冲突，则插入新元素时，若散列表容量为质数，插入就一定可以成功。 F 1-4 将M个元素存入用长度为S的数组表示的散列表，则该表的装填因子为M/S。 T 1-5 在散列中，函数“插入”和“查找”具有同样的时间复杂度。 T 1-6 即使把2个元素散列到有100个单元的表中，仍然有可能发生冲突。 T 1-7 在检索一个单词时，用哈希算法
数据结构C++ 线性表——顺序表和单链表基本操作(含代码和注释).docx
11-04
代码包含顺序表和单链表的基本操作（增删改查等，详见注释），并展示了两个具体使用例子，包括对基本操作的验证和合并两个有序线性表为一个有序表。代码均已通过Dev-C++5.4.0，为了防止误修改，文档已限制编辑，密码...
数据结构——导图.rar
04-30
这份“数据结构——导图.rar”压缩包包含了关于数据结构的详细思维导图，一共分为7个章节，涵盖了数据结构的基础到高级主题。 1. **线性表**：线性表是最基础的数据结构之一，它是由n（n>=0）个相同类型元素构成的...
图解数据结构（使用Python）——链表
12-21
概念：链表（Linked List）是由许多相同数据类型的数据按特定顺序排列而成的线性表，其特点是各个数据在计算机内存中的位置是不连续且随机的。 优点： 数据的插入和删除都比较方便，不需要移动大量的数据（列表在...
2016年考研核心考点——数据结构1
08-03
进入具体的章节内容，**线性表**是数据结构的基础，包括**线性表的定义和基本操作**。线性表是一个有序的数据序列，支持插入、删除、查找等基本操作。在线性表中，顺序表和链表是最常见的两种实现方式，它们各有优...
数据结构复习
m0_53387935的博客
12-29 2632
一、判断题 （1）若某堆栈的输入序列为1,2,3,4，则4,3,1,2不可能是堆栈的输出序列之一。(true) （2）队列逻辑上是一个表头和表尾既能插入又能删除的线性表。（false） （3）若一个叶子结点是某子树的中序遍历序列的最后一个结点，则它必是该子树的先序遍历中的最后一个结点。（true） （4）在索引顺序表上实现分块查找，在等概率查找情况下，其查找长度只与表中元素个数有关，而与每块中元素个数无关。（false） （5）二叉树为二叉排序树的充分必要条件是其任一结点的值均大于其左孩子...
PTA数据结构期末练习-单选题
Gecko_F的博客
06-28 9742
数据结构练习题
PTA数据结构题目集 第十一周——散列查找
cos的博客
09-05 984
PTA数据结构题目集 第十一周——散列查找练习题，涉及散列查找的应用、KMP等，所用语言为c++。
线性表（3）——哈希链表
波波鱼的博客
03-26 1527
C++实现： Key_Value_Pair.h #pragma once #ifndef Key_Value_Pair_H #define Key_Value_Pair_H template <typename Key, typename Value> class Key_Value_Pair { public: typedef Key Key_Type; typedef ...
关于ASL(平均查找长度)的简单总结
热门推荐
Ang_go的博客
05-26 4万+
关于ASL的简单总结概述顺序查找中ASL计算折半查找中ASL计算哈希表中ASL计算 概述 ASL（Average Search Length），即平均查找长度，在查找运算中，由于所费时间在关键字的比较上，所以把平均需要和待查找值比较的关键字次数称为平均查找长度。 它的定义是这样的： 其中n为查找表中元素个数，Pi为查找第i个元素的概率，通常假设每个元素查找概率相同，Pi=1/n，Ci是找到第i个元素的比较次数。 当然，有查找成功，就有查找不成功，即要查找元素不在查找表中。针对不同查找方式的查找成功与不成功
数据结构------查找
Helloirbd的博客
12-27 185
散列操作原理是以空间换时间 将元素通过一个函数转换为整数，使得该整数可以尽可能唯一地代表这个元素 转换函数即成为散列函数 除留余数法H(key)=key%mod 可以把很大的数转化为不超过mod的数 线性探查法 平方探查法 以上两者又称为开放定址法 链地址法   1.线性表的关键字集合key = { （此处数据老师们可以自行设计，可以参考课件上的）}，选取哈希函数的方法为“...
数据结构小结
博客
10-20 1610
                                    数据结构基础 1.数据结构的三个方面:      数据的逻辑结构:反应数据元素之间的逻辑关系. (线性,树形,图状,集合)； 数据的存储结构:数据的逻辑结构在计算机中的表示. (顺序存储,链式存储)； 数据的运算结构:算法(查找,排序,插入,删除,更新,读取)。 2.逻辑结构
哈希查找与增补
半途行走的博客
12-04 1206
题目描述 给出一个数据序列，建立哈希表，采用求余法作为哈希函数，模数为11，哈希冲突用链地址法和表尾插入 如果首次查找失败，就把数据插入到相应的位置中 实现哈希查找与增补功能   输入 第一行输入n，表示有n个数据 第二行输入n个数据，都是自然数且互不相同，数据之间用空格隔开 第三行输入t，表示要查找t个数据 从第四行起，每行输入一个要查找的数据，都是正整数   输出 每行输出...
数据结构复习——习题一
最新发布
10-07
数据结构习题集中的习题一是关于栈的内容。栈是一种特殊的线性表，它的特点是先进后出。栈的基本操作包括入栈和出栈。入栈是将元素添加到栈的顶部，而出栈是将栈顶的元素移除。栈的实现方式有顺序栈和链栈两种。顺序...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

wings(hha)

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值