2.数据结构期末复习之顺序表和链表

news2024/11/19 18:36:41

1.表是可以是线性结构

学号姓名
19(数据项)jams(数据项)
20(数据项)ming(数据项)
 19 jams或 20 ming是数据元表
 单个的是数据项‘’
 线性结构可以表示为  19 jams->20 ming

2.什么是逻辑结构?:具有相同类型的有限序列(元素排序的位置,排兵布阵+操作的方法)

                  a1 a2 a3 .... an (空表长度为0)

3.什么是存储结构? 主要包括 线性存储结构(数组)+链式存储结构,后面的图结果用到了邻接表(其实就是数组+链表结构,可以结合使用)

4.线性表(逻辑结构+存储结构[线性结构])的特点

         1.元素个数有限性
         2.类型相同,例如 
                ((jams,18),(ming,19))
         3.元素类型的抽象性(如2)
         4.相邻元素序偶关系 a1无前驱,an无后继,中间元素只有一个前驱和后继
              如:   a1(无前驱)--->a2(只有一个前驱后继)--->....--->an(无后继)
  1. 线表的抽象数据类型(ADT) 来表达他的逻辑结构
   DataModel: 相同数据类型,前驱后继关系
   Operation:
                       InitList: 初始化表
                       DestroyList: 销毁表
                       Length:  得到线性表长度
                       Get:  得到下标对应的值
                       Locate: 根据值得到下标
                       Insert:在第i个位置插入一个新元素x
                       Delete:删除第i个元素
                       Empty: 判断表为空
   endADT

6.线表的存储结构

     1.用一段连续的地址存储
     2.依次存表的数据元素

7.为什么数组下标必须从0开始

比如 int [3];  //如果下标从0开始,他会计算第一个的地址为 
               //系统分配的地址+0(下标)*size(int) 如果int是4字节的话
               //就是 系统分配的地址+0
               //下标为1时 系统分配的地址+4

8.线性表的完整c语言代码

#include<stdio.h>
#include<stdlib.h>
/*将顺序表的存储结构定义和各个函数定义放到这里*/
#define MaxSize 100           /*假设顺序表最多存放100个元素*/
typedef int DataType;           /*定义线性表的数据类型，假设为int型*/
typedef struct {
	DataType data[MaxSize];    /*存放数据元素的数组*/
	int length;                 /*线性表的长度*/
} SeqList;
void InitList(SeqList *L) { //就是把长度设置为0
	L->length = 0;
}
int CreatList(SeqList *L, DataType a[ ], int n) {
	int i;
	if (n > MaxSize) {
		printf("顺序表的空间不够，无法建立顺序表\n");
		return 0;
	}
	for(i = 0; i < n; i++)
		L->data[i] = a[i];
	L->length = n;
	return 1;
}
int Empty(SeqList *L) {
	if (L->length == 0) return 1;              /*顺序表为空返回1*/
	else return 0;
}
int Length(SeqList *L) {
	return L->length;
}
void PrintList(SeqList *L) {
	int i;
	for(i = 0; i < L->length; i++)
		printf("%d ", L->data[i]);       /*输出线性表的元素值，假设为int型*/
	printf("\n");
}
int Locate(SeqList *L, DataType x) {
	int i;
	for (i = 0; i < L->length; i++)
		if (L->data[i] == x) return i+1;           /*返回序号*/
	return 0;                               /*退出循环，说明查找失败*/
}
int Get(SeqList *L, int i, DataType *ptr) {
	if (i < 1 || i > L->length) {
		printf("查找位置非法，查找失败\n");
		return 0;
	} else {
		*ptr = L->data[i - 1];
		return 1;
	}
}
int Insert(SeqList *L, int i, DataType x) {
	int j;
	if (L->length >= MaxSize) {
		printf("上溢错误，插入失败\n");
		return 0;
	}
	if (i < 1 || i > L->length + 1) {
		printf("位置错误，插入失败\n");
		return 0;
	}
	for (j = L->length; j >= i; j--)       //全部元素向后移动            /*j表示元素序号*/
		L->data[j] = L->data[j - 1];
		
	L->data[i - 1] = x;
	L->length++;
	return 1;
}
int Delete(SeqList *L, int i, DataType *ptr) {
	int j;
	if (L->length == 0) {
		printf("下溢错误，删除失败\n");
		return 0;
	}
	if (i < 1 || i > L->length) {
		printf("位置错误，删除失败\n");
		return 0;
	}
	*ptr = L->data[i - 1];                       /*取出位置i的元素*/
	for (j = i; j < L->length; j++)    //从i这个下标开始向前覆盖          /* j表示元素所在数组下标*/
		L->data[j - 1] = L->data[j];
	L->length--;
	return 1;
}
int main( ) {
	int r[8] = {12,32,43,55,34,76,81,59}, i, x;
	SeqList L;                         /*定义变量L为顺序表类型*/
	CreatList(&L, r, 8);               /*建立具有5个元素的顺序表*/
	printf("当前线性表的数据为：");
	PrintList(&L);                      /*输出当前线性表1 2 3 4 5*/
	Insert(&L, 2, 8);                   /*在第2个位置插入值为8的元素*/
	printf("执行插入操作后数据为：");
	PrintList(&L);                     	/*输出插入后的线性表1 8 2 3 4 5*/
	printf("当前线性表的长度为：%d\n", Length(&L));    /*输出线性表的长度6*/
	printf("请输入查找的元素值：");
	scanf("%d", &x);
	i = Locate(&L, x);
	if (0 == i) printf("查找失败\n");
	else printf("元素%d的位置为：%d\n", x, i);
	printf("请输入查找第几个元素值：", &i);
	scanf("%d", &i);
	if (Get(&L, i, &x) == 1) printf("第%d个元素值是%d\n", i, x);
	else printf("线性表中没有第%d个元素\n", i);
	printf("请输入要删除第几个元素：");
	scanf("%d", &i);
	if (Delete(&L, i, &x) == 1) {              /*删除第i个元素*/
		printf("删除第%d个元素是%d，删除后数据为：", i, x);
		PrintList(&L);                         /*输出删除后的线性表*/
	} else printf("删除操作失败\n");
	return 0;
}

9.线性表(包括顺序表和单链表),我们说说他的链式存储结构的特点

   1.逻辑与物理次序不一定相同(不像数组 例如 下标0到1 地址是连续的)
   2.用指针表示 标记更新

在这里插入图片描述

10.关于单链表的一些术语(说出来,可以让我们听起来就比较专业)
1.C语言的 单链表的(Node)结构体 data(数据域) next(指针域)
在这里插入图片描述![在这里插入图片描述](https://img-blog.csdnimg.cn/c4dd9e21e4fd40b8b8e9f13af861bc11.png

2.链表几个术语

   头指针: 指向第一个节点的指针
   尾指针(尾标志): 指向最后节点的指针
   头节点:第一个节点的指针 ,方便边界处理(方便写代码)
   尾节点:最后一个节点的指针 ,next指向null的

在这里插入图片描述
11.链表的完整c语言代码

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
/*将单链表的结点结构定义和各个函数定义放到这里*/
typedef int DataType;          /*定义线性表的数据类型，假设为int型*/
typedef struct Node {          /*定义单链表的结点类型*/
	DataType data;
	struct Node *next;
} Node;
Node *InitList( )    //主要创建一个节点然后next设置为NULL,返回头节点
{
	Node *first = (Node *)malloc(sizeof(Node));   /*生成头结点*/
	first->next = NULL;                       /*头结点的指针域置空*/
	return first;
}
int Empty(Node *first) //判断单链表是否为空,只需要判断first的next为NULL就为空
{
	if (first->next == NULL) return 1;            /*单链表为空，返回1*/
	else return 0;
}
//遍历单链表并输出,复制一个头指针的next给p指针,p不为NULL(可以一个一个遍历) 继续遍历
//事实上,我们也可以直接 p赋值first指针 判断p->next!=null也可以,但是这里使用的可以与(我们使用的逻辑相对应)
//我先移动到我要使用的位置,然后一一next  比较简单
//我到next一个元素,一个一一next         理解比较困难
void PrintList(Node *first)  
{
	Node *p = first->next;            /*工作指针p初始化*/
	while (p != NULL) {
		printf("%d ", p->data);         /*输出结点的数据域，假设为int型*/
		p = p->next;                 /*工作指针p后移，注意不能写作p++*/
	}
	printf("\n");
}
int Length(Node *first)  //求长度和遍历一样 直接返回遍历次数
{
	Node *p = first->next;          /*工作指针p初始化*/
	int count = 0;                 /*累加器count初始化*/
	while (p !=NULL) {
		p = p->next;
		count++;
	}
	return count;
}
 //得到x元素的位置, 以后我要养成查询在前,修改在后的习惯
 //链表没有下标所以,没有返回0的,逻辑还是遍历(好的代码可以重复利用来写!!!)
int Locate(Node *first, DataType x)  
{
	Node *p = first->next;                /*工作指针p初始化*/
	int count = 1;                       /*累加器count初始化*/
	while (p != NULL) {
		if (p->data == x) return count;       /*查找成功，结束函数并返回序号*/
		p = p->next;
		count++;
	}
	return 0;                           /*退出循环表明查找失败*/
}
//得到指定位置的值
//只需要判断count的大小，这里使用while不是使用for因为while不能确定循环次数,而for需要
//还要判断是否到结尾了没有元素
int Get(Node *first, int i, DataType *ptr)
{
	Node *p = first->next;                     /*工作指针p初始化*/
	int count = 1;                            /*累加器count初始化*/
	while (p != NULL && count < i) {
		p = p->next;                           /*工作指针p后移*/
		count++;
	}
	if (p == NULL) {
		printf("位置错误，查找失败\n");
		return 0;
	} else {
		*ptr = p->data;
		return 1;
	}
}
int Insert(Node *first, int i, DataType x)
{
	Node *s = NULL, *p = first ;       /*工作指针p初始化为指向头结点*/
	int count = 0;
	while (p != NULL && count < i - 1) {        /*查找第i-1个结点*/
		p = p->next;                           /*工作指针p后移*/
		count++;
	}
	if (p == NULL) {
		printf("位置错误，插入失败\n");
		return 0;
	} else {
		s = (Node *)malloc(sizeof(Node));
		s->data = x;                       /*申请一个结点s，数据域为x*/
		 //必须先修改new出来的节点的next,改前一个节点的next,以免数据丢失
		s->next = p->next;                  
		p->next = s;       /*将结点s插入到结点p之后*/
		return 1;
	}
}
Node *CreatList(DataType a[ ], int n)
{ //先创建头节点,然后头插法一一连接
	int i;
	Node *s = NULL;
	Node *first = (Node *)malloc(sizeof(Node));
	first->next = NULL;                             /*初始化头结点*/
	for (i = 0; i < n; i++) {
		s = (Node *)malloc(sizeof(Node));
		s->data = a[i];                      /*为每个数组元素建立一个结点*/
		s->next = first->next;
		first->next = s;    /*将结点s插入到头结点之后*/
	}
	return first;
}

int Delete(Node *first, int i, DataType *ptr)
{
	Node *p = first, *q = NULL;          /*工作指针p要指向头结点*/
	int count = 0;
	DataType x;
	while (p != NULL && count < i - 1) {  /*查找第i-1个结点*/
		p = p->next;
		count++;
	}
	if (p == NULL || p->next == NULL) {  /* p结点或p的后继结点不存在*/
		printf("位置错误，删除失败\n ");
		return 0;
	} else {
		q = p->next;
		*ptr = q->data;        /*存储被删结点和被删元素值*/
		p->next = q->next;               /*摘链*/
		free(q);
		return 1;
	}
}
void DestroyList(Node *first)
{
	Node *p = first;
	while (first != NULL) {        /*依次释放每一个结点，包括头结点*/
		first = first->next;
		free(p);
		p = first;
	}
}
int main( )
{
	int r[5] = {1, 2, 3, 4, 5}, i, x;
	Node *first = NULL;
	first = CreatList(r, 5);
	printf("当前线性表的数据为：");
	PrintList(first);                       /*输出当前链表1 2 3 4 5*/
	Insert(first, 2, 8);                     /*在第2个位置插入值为8的结点*/
	printf("执行插入操作后数据为：");
	PrintList(first);                      /*输出插入后链表1 8 2 3 4 5*/
	printf("当前单链表的长度为：%d\n", Length(first));      /*输出单链表长度6*/
	printf("请输入查找的元素值：");
	scanf("%d", &x);
	i = Locate(first, x);
	if (i != 0) printf("元素%d的元素位置为：%d\n", x, i);
	else printf("单链表中没有元素%d\n", x);
	printf("请输入要删除第几个元素：");
	scanf("%d", &i);
	if (Delete(first, i, &x) == 1) {                        /*删除第i个元素*/
		printf("删除的元素值是%d，执行删除操作后数据为：", x);
		PrintList(first);                                 /*输出删除后链表*/
	} else printf("删除操作失败\n");
	DestroyList(first);                                 /*释放单链表*/
	return 0;
}

12.总结出写代码方法论(由上面的Get方法思考得出)
在这里插入图片描述
13. (给个值)插入元素操作也可以分为 头插法(上面的代码就是)和尾插法(在尾节点后面插入元素)

14.循环单链表(单链表的尾节点的next指向first头节点) 多个rear尾指针判断j结束在这里插入图片描述
15.循环双链表(有pre前指针和next指针)
在这里插入图片描述
16.顺序表和链表的比较

     1.存储分配方式
                           顺: 静态存储分配,连续单元空间,逻辑用下标表示
                           链: 动态分配(存储地址不一定连续),链接使用指针
     2.空间
                           顺: 有限空间,存储密度100%(不存储其他东西,比如指针,额外因为结构导致的数据)只                 存元素
                           链:存储密度不高,动态分配空间,空间弹性你自己分配,
    3.时间复杂度
                       1.按位查   
                                  顺: O(1) 随机存取(拿到什么下标就拿到什么元素)
                                  链: O(n) 顺序存取(只能一个一个遍历 计数来查找)
                      2.按值操作
                                 链,顺: O(n)都遍历一遍
                      3.插入删除
                                  顺: O(n) 插入必须插入元素后移, 删除需要前移覆盖之前的元素
                                  链: O(1) 指针理论上速度可以达到O(1)直接操作内存地址
   4.总结
                 1.长度知道: 顺
                           不知道:链
                 2.操作  少插入和删除(查找)用 顺
                              常用插入删除   用  链

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/541414.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

jenkins流水线使用入门示例

jenkins流水线使用入门示例

之前采用Jenkins的自由风格构建的项目&#xff0c;每个步骤流程都要通过不同的方式设置&#xff0c;并且构建过程中整体流程是不可见的&#xff0c;无法确认每个流程花费的时间&#xff0c;并且问题不方便定位问题。 Jenkins的Pipeline可以让项目的发布整体流程可视化&#xf…
阅读更多...
低代码开发大势所趋，这款无代码开发平台你值得拥有

低代码开发大势所趋，这款无代码开发平台你值得拥有

文章目录 什么是低代码iVX和其它低代码的平台的区别没有创新的“拼凑”&#xff0c;没有好东西iVX在线编辑器体验 什么是低代码 低代码&#xff08;Low Code&#xff09;是一种可视化的应用开发方法&#xff0c;用较少的代码、以较快的速度来交付应用程序&#xff0c;将程序员…
阅读更多...
ElasticSearch漫游 (1.安装ELK)

ElasticSearch漫游 (1.安装ELK)

前期准备&#xff1a; 请搭建好linux环境 推荐使用centos7系统请关闭linux防火墙请安装好docker 安装ES 创建网络 我们需要部署kibana容器&#xff0c;因此需要让es和kibana互联&#xff0c;这里先创建一个网络。 docker network create es-net加载es镜像 运行docker命令 部…
阅读更多...
智能无线温振传感器：提高锂电设备故障诊断精度的利器

智能无线温振传感器：提高锂电设备故障诊断精度的利器

当今锂电工厂对于设备可靠性和生产效率的要求越来越高&#xff0c;而设备故障诊断是其中非常重要的一环。针对锂电设备的振动和温度等健康状态的监测&#xff0c;智能无线温振传感器是一款非常有用的工具。 图.太阳能面板生产&#xff08;iStock&#xff09; 智能无线温振传感器…
阅读更多...
和数组处理有关的一些OJ题（JAVA)(ArrayList）

和数组处理有关的一些OJ题（JAVA)(ArrayList）

1、给你一个数组 nums 和一个值 val&#xff0c;你需要 原地 移除所有数值等于 val 的元素&#xff0c;并返回移除后数组的新长度。 不要使用额外的数组空间&#xff0c;你必须确保时间复杂度为O(N)&#xff0c;空间复杂度为O&#xff0c;并原地修改输入数组。元素的顺序可以改…
阅读更多...
Android系统原理性问题分析 - Android Java框架层的结构

Android系统原理性问题分析 - Android Java框架层的结构

声明 在Android系统中经常会遇到一些系统原理性的问题&#xff0c;在此专栏中集中来讨论下。Android系统&#xff0c;为了能够更好的理解Android的Java世界的运行规律&#xff0c;此篇分析Android Java框架的结构。此篇参考一些博客和书籍&#xff0c;代码基于Android 7.1.1&a…
阅读更多...
资产处置求变，京东拍卖如何做好“价值枢纽”？

资产处置求变，京东拍卖如何做好“价值枢纽”？

近年来&#xff0c;随着资产处置市场规模快速成长以及互联网行业飞速发展&#xff0c;金融资产、司法拍卖、罚没物资等处置方式从最初单纯线下拍卖逐渐落地互联网&#xff0c;服务专业化程度也在不断提高。为更好适应市场变化&#xff0c;满足不断增长的市场需求&#xff0c;5月…
阅读更多...
NISP二级证书含金量如何

NISP二级证书含金量如何

国家信息安全水平考试&#xff08;National Information Security Test Program&#xff0c;简称NISP&#xff09;&#xff0c;是由中国信息安全测评中心实施培养国家网络空间安全人才的项目。 为培养更多优秀的实践型网络安全人才&#xff0c;中国信息安全测评中心推出了国家…
阅读更多...
替代MySQL半同步复制，Meta技术团队推出MySQL Raft共识引擎

替代MySQL半同步复制，Meta技术团队推出MySQL Raft共识引擎

作者&#xff1a;Anirban Rahut、Abhinav Sharma、Yichen Shen、Ahsanul Haque 原文链接&#xff1a;https://engineering.fb.com/2023/05/16/data-infrastructure/mysql-raft-meta/ 译者&#xff1a;ChatGPT 责编&#xff1a;张红月 MySQL Raft是MySQL数据库中一种基于Raft协议…
阅读更多...
探索LeetCode【0010】正则表达式匹配（已懂，未练习）

探索LeetCode【0010】正则表达式匹配（已懂，未练习）

目录 0.1 题目0.2 补充示例1. 参考B站视频2. 官方答案的评论-可用3. chatGPT的思路和解法-可用 0.1 题目 题目链接&#xff1a;【0010】正则表达式匹配 给你一个字符串 s 和一个字符规律 p&#xff0c;请你来实现一个支持 . 和 * 的正则表达式匹配。 . 匹配任意单个字符* 匹…
阅读更多...
2023 RSAC|和衷共济 共同应对网络安全挑战

2023 RSAC|和衷共济 共同应对网络安全挑战

作为全球最具规模的安全大会&#xff0c;2023年RSA Conference的落幕也为安全行业的“何去何从”带来一定的启发性。 今年大会的主题是“Strong together”&#xff0c;主要来自于海伦凯勒的名言: “ Alone we can do so little; together we can do so much. ” 纵观2022年…
阅读更多...
做完这个测试项目，我终于决定辞职·····

做完这个测试项目，我终于决定辞职·····

很迷茫&#xff0c;然后过得非常不如意&#xff0c;倒不是上一年的职业目标没达到&#xff0c;而是接下来的路根本不知道如何走。在没解决这个问题之前&#xff0c;或者说没搞清楚自己的方向之前&#xff0c;是迟迟不能落笔的&#xff0c;啊不&#xff0c;应该是落键盘。 下班…
阅读更多...
JavaWeb-RequestResponse的使用

JavaWeb-RequestResponse的使用

Request&Response 今日目标 掌握Request对象的概念与使用掌握Response对象的概念与使用能够完成用户登录注册案例的实现能够完成SqlSessionFactory工具类的抽取 1&#xff0c;Request和Response的概述 Request是请求对象&#xff0c;Response是响应对象。这两个对象在我们…
阅读更多...
德尔玛IPO首日破发，市值蒸发超4亿

德尔玛IPO首日破发，市值蒸发超4亿

今日&#xff08;5月18日&#xff09;&#xff0c;小米“代工厂”广东德尔玛科技股份有限公司&#xff08;下称“德尔玛”&#xff0c;301332.SZ&#xff09;正式在深交所挂牌上市。 德尔玛此次IPO募资净额为12.31亿元&#xff0c;开盘价为14.81元/股&#xff0c;与发行价持平…
阅读更多...
Call to undefined function bcadd()

Call to undefined function bcadd()

先介绍一下当前使用的环境。同学们可以比较一下&#xff0c;看本篇文章是否可以提供帮助。 docker 部署 nginx 1.24php 8.1-fpm 再介绍一下框架&#xff0c;使用的是 "laravel 9.33.0" 其实这里跟 laravel 框架和 nginx 是没太多关系的&#xff0c;因为我们主要是使…
阅读更多...
MySQL高级_第09章_性能分析工具的使用

MySQL高级_第09章_性能分析工具的使用

MySQL高级_第09章_性能分析工具的使用 在数据库调优中&#xff0c;我们的目标就是 响应时间更快&#xff0c;吞吐量更大。利用宏观的监控工具和微观的日志分析可以帮我们快速找到调优的思路和方式。 1. 数据库服务器的优化步骤 当我们遇到数据库调优问题的时候&#xff0c;该…
阅读更多...
Windows平台软件开发模型总结：V型模型、瀑布模型、迭代模型、增量模型、螺旋模型、原型模型

Windows平台软件开发模型总结：V型模型、瀑布模型、迭代模型、增量模型、螺旋模型、原型模型

我是荔园微风&#xff0c;作为一名在IT界整整25年的老兵&#xff0c;今天总结一下Windows平台软件开发模型总结&#xff1a;V型模型、瀑布模型、迭代模型、增量模型、螺旋模型、原型模型。 很多人可能知道了&#xff0c;那就是在我们浙江省&#xff0c;从2021年年初到现在&…
阅读更多...
内网 monorepo 配置指南（PNPM、YARN）

内网 monorepo 配置指南（PNPM、YARN）

此处的内网是指没办法连接互联网进行依赖下载的环境&#xff0c;本文以windows平台为例 背景说明 绝大部分政府机关、国有企业都是在内网开发&#xff0c;无法从互联网同步依赖&#xff0c;就需要另辟蹊径解决项目依赖的问题。 传统的单包项目还好&#xff0c;从互联网机器将…
阅读更多...
兼顾降本与增效，我们对存算分离的设计与思考

兼顾降本与增效，我们对存算分离的设计与思考

“降本增效”是最近企业常被提及的关键字&#xff0c;作为新时代企业发展的数据大脑&#xff0c;企业大数据团队需要持续探索如何在有限资源下创造更多价值。本文将以场景为"引"&#xff0c;技术为"核"&#xff0c;介绍如何基于 StarRocks 全新的存算分离架…
阅读更多...
软考软件设计师真题与答案解析

软考软件设计师真题与答案解析

1、2020下半年基础知识&#xff08;上午题&#xff09; 1、某计算机系统的CPU主频为2.8GHz。某应用程序包括3类指令&#xff0c;各类指令的CPI(执行每条指令所需要的时钟周期数)及指令比例如’下表所示。执行该应用程序时的平均CPI为&#xff08; &#xff09;&#xff1b;运算…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023