〇、数据和数据结构
1>认识数据
数据：能被计算机识别，存储，处理的符号
数据类型(整数，小数，字符，字符串，汉字)
非数据类型（声音，图片，视频，文件，app）
数据元素：由数据项组成，数据的基本单位
数据项：值数据的最小单位
数据对象：类型相同的数据元素组成
数据 > 数据对象> 数据元素> 数据项
2> 数据结构
数据结构：存储多个类型相同的数据元素之间一种或多种关系的集合
D_S=(D，R)
i> 逻辑结构
数据元素之间的一种或多种关系
1.集合结构：数据元素之间没有关系(地铁上的人)
2.线性结构：数据元素之间存在一对一的逻辑关系(数组，地铁的座位)头节点无直接前驱，尾节点无直接后继，中间节点存储在唯一的前驱唯一的后继
3.树形结构：数据元素之间存在一对多的逻辑关系(族谱，公司架构)头结点无直接前驱，尾节点无直接后继，中间节点存在唯一的直接前驱，多个后继
4.图形结构：数据元素之间存在多对多的逻辑关系(地图)
ii>存储结构
逻辑结构在计算机的存储形式
顺序存储：使用一段连续的存储空间实现存储(数组)
链式存储：使用任意一段空间实现存储(银行取现)
散列存储：称为哈希存储，关键字通过哈希函数映射在内存地址的一种存储形式(词典)
实现查找
索引存储：使用索引表和数据文件共同实现的查找方式
实现查找
3> 时间复杂度
时间复杂度：程序的执行次数
T(n)=O(f(n))
T: time时间
T(n):时间复杂度
O：大O阶 渐进符
n:问题的规模
f(n): 问题规模的函数
注意：只保留最高阶
f(n)=3*n^4+4*n^2+5*n+100---->3*n^4 ---->n^4
T(n)=O(f(n))--->O(n^4)
//1.O(1):常数阶 没有循环
int t=a; 1
a=b; 1
b=t; 1
f(n)=3--->3*n^0---->n^0--->1
T(n)=O(1)
//2.O(n): 线性阶 一层循环
for(int i=1;i<=n;i++) n+1
{
puts("hello"); n
}
f(n)=2*n+1--->2*n--->n
T(n)=O(n)
//3.O(n^2):平方接 两层循环
for(int i=1;i<=n;i++) n+1
{
for(int j=1;j<=n;j++) (n+1)*n
{
puts("hello"); n*n
}
}
f(n)=2*n^2+2*n+1 ---->2*n^2---->n^2
T(n)=O(n^2)
//4.O(n^3)立方阶 三层循环
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n;j++)
{
for(int k=1;k<=n;k++)
{
puts("hello");
}
}
}
//5.O(log2n):对数阶
int i=1; 1
while(i<n) log2n +1
{
i*=2; log2n
}
2^次数=n 次数=log2 n
f(n)=2*log2n+2 ---->log2n
一、线性表
线性表是存储类型相同、个数有限的一个集合(属相)
线性表：线性结构
线性结构是一种元素之间存在一对一的关系，即每个元素都有唯一的直接前驱和直接后继。线性表就是一种典型的线性结构。
存储结构：顺序存储，链式存储
在顺序存储结构中，线性表的元素在内存中占用一段连续的存储空间。顺序表通常使用数组来实现，通过数组的下标来访问元素。
在链式存储结构中，线性表的元素在内存中可以是不连续的，通过指针来连接各个元素。链表是一种常见的链式存储结构，包括单链表、双链表等。
线性表：顺序表，链表，数组，栈，队列，字符串
二、顺序表
1> 顺序表概念
-
顺序表：线性表的顺序存储就是顺序表
-
顺序表的逻辑结构：线性结构(一对一)
-
顺序表的存储结构：顺序存储(地址连续)
-
特点：逻辑相邻物理也相邻
-
顺序表是借助于数组实现的，但是不等价数组
-
顺序表下表从0开始
-
顺序表长度len：实际元素的个数
-
线性表长度/数据长度MAXSIZE：不可以改变，表示顺序表的最大空间
-
顺序表满：len==MAXSIZE
-
顺序表空：len==0
- 顺序表的定义
顺序表：数据元素，顺序表长度
2> 顺序表的操作
1) 顺序表堆区创建
/*
* function: 顺序表堆区申请内存
* @param [ in]
* @param [out]
* @return
*/
sqlist* create_list() {
sqlist *list=(sqlist*)malloc(sizeof(sqlist));
if(NULL ==list)
return NULL;
//创建成功
//对数据元素初始化
memset(list->data,0,sizeof(list->data));
//对顺序表长度初始化
list->len=0; S
return list;
}
1) 顺序表尾插+判满
/*
* function: 判满
* @param [ in]
* @param [out]
* @return
*/
int full(sqlist*list){
return list->len==MAXSIZE?FALSE:SUCCESS;
}
/*
* function: 尾插入
* @param [ in]
* @param [out] 顺序表，值
* @return
*/
int insert_rear(sqlist *list,datatype element) {
//1,判断顺序表是否创建NULL==list
//2.判断顺序表是否为满len==MAXSIZE
if(NULL==list || full(list)) {
return FALSE;
}
list->data[list->len]=element;
list->len++;
return SUCCESS;
}
3) 顺序表尾删
/*
* function: 尾删
* @param [ in]
* @param [out] 顺序表
* @return
*/
int delete_rear(sqlist*list){
//1,判断顺序表是否创建
//2，判断顺序表是否为空
if(NULL ==list || empty(list))
return FALSE;
//3,删除
list->len--;
return SUCCESS;
}
4) 顺序表遍历+判空
/*
* function: 判断是否为空
* @param [ in]
* @param [out]
* @return
*/
int empty(sqlist *list){
return list->len==0?FALSE:SUCCESS;
}
/*
* function: 循环输出
* @param [ in]
* @param [out] 顺序
* @return
*
*/
int Output(sqlist *list){
//1.判断顺序表是否为空
//2.判断顺序表是否创建
if( NULL ==list || empty(list))
return FALSE;
//3,循环输出
for(int i=0;i<list->len;i++){
printf("%d\t",list->data[i]);
}
puts("");
return SUCCESS;
}
#### 5) 顺序表按下标插入
```c
/*
* function: 插入
* @param [ in]
* @param [out]顺序表，下表，插入的值
* @return
*/
int insert_index(sqlist* list,int index,datatype element){
if(NULL==list || isFull(list) || index<0 || index>list->len)
return FALSE;
for (int i = list->len-1; i >= index; i--) {
list->data[i+1]=list->data[i];
}
list->data[index]=element;
list->len++;
return SUCCESS;
}
6) 顺序表按下标删除
/*
* function: 删除
* @param [ in]
* @param [out]
* @return
*/
int delete_index(sqlist* list,int index){
if(NULL==list || isEmpty(list) || index<0 || index>=list->len)
return FALSE;
for (int i=index+1;i< list->len ;i++) {
list->data[i-1]=list->data[i];
}
list->len--;
return SUCCESS;
}
7) 顺序表按下表修改
/*
* function: 按下表修改
* @param [ in]
* @param [out] 顺序表，下表 值
* @return
*/
int update_index(sqlist*list,int index,datatype element)
{
//1,判断顺序表是否创建
//2，判断顺序表是否为空
//3，判断下表是否合法
if(NULL==list|| empty(list)|| index<0|| index>=list->len)
return FALSE;
//4,修改
list->data[index]=element;
return SUCCESS;
}
8) 顺序表按下表查找
/*
* function: 按下表查找
* @param [ in]
* @param [out] 顺序表，index
* @return */
void search_index(sqlist*list,int index)
{
//1,判断顺序表是否创建
//2，判断顺序表是否为空
//3，判断下表是否合法
if(NULL==list|| empty(list)|| index<0|| index>=list->len)
return;
//4,查找
printf("search by index element is %d\n",list->data[index]);
}
9) 按元素查找
/*
* function: 按元素查找
* @param [ in] list,key
* @param [out] 元素下标
* @return
*/
int search_key(sqlist* list,datatype key){
int in=-1;
if(NULL==list || isEmpty(list))
return FALSE;
for (int i = 0; i < list->len; i++) {
if(list->data[i]==key){
in=i;
break;
}
}
if(in==-1){
return FALSE;
}else{
return in;
}
}
10) 顺序表按元素删除(如果存在重复则只能删除第一个)
/*
* function: 顺序表按元素删除(如果存在重复则只能 删除第一个)
* @param [ in]
* @param [out]
* @return
*/
int delete_key(sqlist* list,datatype key){
int in=search_key(list,key);
if(in==FALSE)
return FALSE;
return delete_index(list,in);
}
11) 顺序表按元素修改
/*
* function: 顺序表按元素修改
* @param [ in]
* @param [out]
* @return
*/
int change_key(sqlist* list,datatype key,datatype new){
int in=search_key(list,key);
if(in==FALSE)
return FALSE;
update_index(list,in,new);
return SUCCESS;
}
12) 顺序表去重
/*
* function: 顺序表去重
* @param [ in] list
* @param [out]
* @return
*/
int deduplicate(sqlist* list){
for (int i = 0; i < list->len-1; i++) {
for (int j = i+1; j < list->len-i; j++) {
if(list->data[i]==list->data[j]){
delete_index(list,j);
j--;
}
}
}
}
13) 顺序表排序
/*
* function: 13 顺序表排序
* @param [ in] list
* @param [out]
* @return
*/
int sort(sqlist* list){
if(NULL==list || isEmpty(list))
return FALSE;
for (int i = 0; i < list->len-1; i++) {
for (int j = 0; j < list->len-i-1; j++) {
if(list->data[j] > list->data[j+1]){
datatype temp=list->data[j];
list->data[j]=list->data[j+1];
list->data[j+1]=temp;
}
}
}
return SUCCESS;
}
14) 顺序表释放
/*
* function: 顺序表释放
* @param [ in] list
* @param [out]
* @return
*/
sqlist* my_free(sqlist* list){
if(NULL==list || isEmpty(list))
return NULL;
free(list);
list=NULL;
return list;
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
