数据结构概念学习以及顺序表完整操作

于 2023-07-24 02:40:28 发布
阅读量72 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62318298/article/details/131887231
版权

概念

数据

  • 数据：能被计算机识别、存储、处理的符号的集合
  • 数据类型：整数、小数、字符、字符串、汉字
  • 非数据类型：声音、图片、视频、app文件
  • 数据元素：由数据项组合的，是数据的基本单位
  • 数据项：数据项是数据的最小单位
    在这里插入图片描述
  • 数据>数据对象>数据元素>数据项

数据结构

  • 数据结构：有类型相同，个数有限的数据元素以及相互之间的一种或多种关系组成的集合

逻辑结构

  • 逻辑结构：表示数据元素之间一种或多种关系的

  • 线性结构：数据元素之间存在一对一的逻辑关系【地铁上的座位、数组】
    头结点无前驱，尾结点无后继，中间结点存在唯一的前驱和唯一的后继

  • 树形结构：数据元素之间存在一对多的逻辑关系【族谱】
    头结点无前驱，尾结点无后继，中间节点存在唯一的前驱，多个后继

  • 图形结构：数据元素之间存在多对多的逻辑关系【地图】

  • 集合结构：数据元素之间没有关系【地铁上的人】

存储结构/物理结构

  • 存储结构：逻辑结构在计算机上的存储形式
  • 顺序存储：使用任意一段连续的存储空间，存储数据【数组】（逻辑相邻，物理也相邻）
  • 链式存储：使用任意一段空间实现存储数据（逻辑相邻，物理不一定相邻）
  • 索引存储：由索引表和数据文件实现的查找
  • 散列存储：哈希存储，关键通过哈希函数映射在计算机一种存储形式（实现查找功能）

时间复杂度

  • 时间复杂度：表示代码的执行次数

  • 公示T(n)=O((fn))
    T：time 时间
    T(n)：时间复杂度
    O：渐进符、大O阶
    n：问题的规模
    f(n)：问题规模的函数

  • 时间复杂度：只保留最高阶
    f(n)=3n ^ 2+n^2+100+n
    T(n)=O(3    n^3+n ^2+100+n)=O(3*n ^3)=O(n ^3)

线性表

  • 线性表：由类型相同的数据元素组成的线性结构
  • 逻辑结构：线性结构【一对一】
  • 存储结构：顺序存储、链式存储
  • 线性表：顺序表、链表、栈、队列、数组、字符串

顺序表

  • 顺序表：线性表的顺序存储称为顺序表
  • 顺序表的逻辑结构：线性结构
  • 存储结构：顺序存储【逻辑相邻，物理也相邻】
  • 顺序表是借助于一维数组实现的，但是不等价于一维数组
  • 顺序表的长度：实际元素的个数(会变)
  • 线性表长度：数组长度，存储数据的最大空间(长度是不变的 #define MAXSIZE 8)
  • 顺序表判满：len==MAXSIZE
  • 顺序表判空：len==0

顺序表操作

顺序表结构体定义

#define MAXSIZE 8
typedef struct
{
	int len；
	int data[MAXSIZE];
}sqlist;

顺序表创建空间

/*
 * function:    顺序表在堆区申请空间
 * @param [ in] 
 * @param [out] 
 * @return      
 */
Seqlist *create_list()
{
Seqlist *list=(Seqlist *)malloc(sizeof(Seqlist));
    if(NULL == list)
    {
    return NULL;
    }
    list->len=0;//顺序表长度清零
        //sizeof(datatype)*MAXSIZE
    memset(list->data,0,sizeof(list->data));
    return list;
}

顺序表尾插

/*
 * function:    判断顺序表满
 * @param [ in] 
 * @param [out] 
 * @return      满返回-1  不满返回0
 */
int full_list(Seqlist *list)
{
	return list->len==MAXSIZE?-1:0;
}
/*
 * function:    尾插，插入一个
 * @param [ in] 
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
 int insert_rear(datatype e,Seqlist *list)
 {
 	if(NULL==list||full_list(list))
 	{
 		printf("insert rear error\n");
 		return -1;
 	}
 	list->data[list->len]=e;
 	list->len++;
 	return 0;
 }

顺序表尾删

/*
 * function:    顺序表为空
 * @param [ in] 
 * @param [out] 
 * @return      空返回-1 非空返回0
 */
int empty(Seqlist *list)
{
	return list->len==0?-1:0;
}
/*
 * function:    尾部删除
 * @param [ in] 
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
int delete_rear(Seqlist *list)
{
    if(NULL==list || empty(list))
    {
    puts("delete rear error");
    return -1;
    }
    printf("delete element is：%d\n",list->data[list->len-1]);
    list->len--;
    return 0;
}

顺序表任意下标插入

/*
 * function:    按下表插入
 * @param [ in] 
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
int insert_by_sub(Seqlist *list,int sub,datatype e)
{
    //1,判断顺序表是否存在
    //2，判断顺序表满
    //3，判断下表是否合法
    if(NULL==list || full_list(list)|| sub<0 || sub>list->len)
    {
    puts("insert error");
    return -1;
    }
    //4,插入
    //循环后移
    for(int i=list->len-1;i>=sub;i--)  n-1-sub+1
    {
    list->data[i+1]=list->data[i];  n-1-sub
    }
    //在sub插入
    list->data[sub]=e;
    list->len++;
    return 0;
}

顺序表任意下标删除

/*
 * function:    按下表删除
 * @param [ in] 
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
int delete_by_sub(int sub,Seqlist *list)
{
    //1,判断顺序表是否存在
    //2，判断顺序表是否为空
    //3，判断下表是否合法
    if(NULL == list || empty(list) || sub<0 || sub>=list->len)
    {
    puts("delete error");
    return -1;
    }
    //4，删除
    //删除前移
    for(int i=sub;i<list->len-1;i++)
    {
    list->data[i]=list->data[i+1];
    }
    list->len--;
    return 0;

}

顺序表任意下标修改

/*
 * function:    按下表修改
 * @param [ in] 
 * @param [out] 
 * @return      成功返回 0 失败返回-1
 */
int update_by_sub(Seqlist *list,int sub,datatype e)
{
    //1.判断顺序表是否创建
    //2，判断顺序表是否为空
    //3，判断下表是否合法
    if(NULL == list || empty(list) || sub<0 || sub>=list->len)
    {
    puts("update error");
    return -1;
    }
    //4,修改：重新赋值
    list->data[sub]=e;
    return 0;
}

顺序表任意下标查找

/*
 * function:    按下表查找
 * @param [ in] 
 * @param [out] 
 * @return      成功返回查找的值 失败返回-1
 */
datatype search_by_sub(int sub,Seqlist *list)
{
    //1,判断顺序表是否存在
    //2，判断顺序表是否为空
    //3，判断下表是否合法
    if(NULL==list || empty(list) || sub<0||sub>=list->len)
    {
    puts("search element error");
    return -1;
    }
    return list->data[sub];
}

按任意元素查找

/*
 * function:    按元素查找
 * @param [ in] 
 * @param [out] 
 * @return      失败返回-1  成功返回下表
 */
int search_by_data(datatype key,Seqlist *list)
{
    //1,判断顺序表是否存在
    //2，判断顺序表是否为空
    if(NULL==list || empty(list))
    {
    return -1;
    }
    //3,按元素查找
    for(int i=0;i<list->len;i++)
    {
    if(key==list->data[i])
    {
        return i;
    }
    }
    return -1;
}

顺序表任意元素插入

/*
 * function:    按元素插入
 * @param [ in] 
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
int insert_by_data(datatype key,datatype e,Seqlist *list)
{
	//参数：被插入的元素key，要插入的元素e，顺序表list
	//1,查找key在顺序表的位置 seach_by_data得到下表
	//2.在下表插入e insert_by_sub
    int sub=search_by_data(key,list);
    if(sub==-1)
    return -1;
    insert_by_sub(list,sub,e);
    return 0;
}

顺序表按任意元素删除

/*
 * function:    按元素删除
 * @param [ in] 
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
int delete_by_data(datatype key,Seqlist *list)
{
    //查找key是否存在
    int sub=search_by_data(key,list);
    if(sub==-1)
    return -1;
    delete_by_sub(sub,list);
    return 0;

}

顺序表按任意元素修改

/*
 * function:    按元素修改
 * @param [ in] 
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
int update_by_data(datatype key,datatype e,Seqlist *list)
{
    //查找key是否存在
    int sub=search_by_data(key,list);
    if(sub==-1)
    return -1;
    update_by_sub(list,sub,e);
    return 0;
}

顺序表去重

    for(int i=0;i<list->len-1;i++)
    {
         for(int j=i+1;j<len;j++)
         {
              if(list->data[i]==list->data[j])
              {
                   delete_by_sub(j,list);   
                   j--;  //防止漏删        
              }        
         }   
    }

顺序表排序

/*
 * function:    顺序表排序
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int Bubble(Seqlist *list,int len)
{
	if(NULL==list||empty(list))
	{
		printf("排序失败\n");
		return -1;
	}
	for(int i=1;i<len;i++)
	{
		for(int j=0;j<len-i;j++)
		{
			if(list->data[j]>list->data[j+1])
			{
				int t=list->data[j];list->data[j]=list->data[j+1];
				list->data[j+1]=t;
			}
		}
	}
	return 0;
}

顺序表合并

/*
 * function:    顺序表有序合并
 * @param [ in] 
 * @param [out] 
 * @return      无
 */
void combine(Seqlist *la,Seqlist *lb,Seqlist *lc)
{
    int p=0;//la的下表
    int q=0;//lb的下表

    while(p<la->len && q<lb->len)
    {
    if(la->data[p] <=lb->data[q])
    {
        lc->data[lc->len++]=la->data[p++];
    }
    else
    {
        lc->data[lc->len++]=lb->data[q++];
    }
    }
    //吧la剩余元素存到lc
    while(p<la->len)
    {
        
    lc->data[lc->len++]=la->data[p++];
    }
    //吧lb剩余元素存到lc
    while(q<lb->len)
    {
    lc->data[lc->len++]=lb->data[q++];
    }

}

顺序表输出

/*
 * function:    输出
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void output(Seqlist *list)
{
    if(NULL==list || empty(list))
    {
    puts("output error");
    return;
    }
    for(int i=0;i<list->len;i++)
    {
    printf("%d\t",list->data[i]);
    }
    puts("");

}

顺序表特点

  • 顺序表属于静态分配空间
  • 顺序表：逻辑结构体：线性结构，存储结构：顺序存储【使用一段连续的存储空间】
  • 顺序表插入和删除时间复杂度O(n)，修改和查找的时间复杂度是O(1)
  • 顺序表不方便插入和删除【插入和删除需要移动大量元素】，顺序表方便查找和修改
  • 顺序表需要提前预估存储空间，MAXSIZE
  • 顺序表的存储密度大于链表
  • 顺序表空间利用率高于链表
  • 顺序表多适用于数据量较小的情况，且顺序表存在满
奕书想睡觉了。
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值