Day3-数据结构-顺序表

ck钉钉钉

已于 2023-07-18 09:18:25 修改

阅读量85

点赞数

分类专栏：转世重生文章标签：数据结构

于 2023-07-18 08:44:05 首次发布

本文链接：https://blog.csdn.net/ck0056/article/details/131778979

版权

转世重生专栏收录该内容

46 篇文章 1 订阅

订阅专栏

实现一个简单的学生管理系统

head.h文件

#ifndef __HEAD_head_h__
#define __HEAD_head_h__
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define LIST_INIT_SIZE 10
typedef struct
{
	int xuhao;
	char name[10];
	int age;
	long ID;
}student;
typedef struct
{
	student *stu;
	int length;
	int listsize;
}sqlist;
void add(sqlist *l); //添加
void output(sqlist *l); //输出
void chazhao(sqlist *l);    //查找
void intput(sqlist *l);  //输入
int deletelist(sqlist *l);  //释放空间
int initlist(sqlist *l,int n); //申请空间
void amend(sqlist *l); //删除
void change(sqlist *l); // 改
void menu(); //菜单

#endif

test.c文件

#include "head.h"
int initlist(sqlist *l,int n) //申请空间
{
	l->stu =(student *)malloc(sizeof(student)*n);
	if(l->stu==NULL) exit(-1);
	l->length =n;
	l->listsize = LIST_INIT_SIZE;
	return 1;
}
int deletelist(sqlist *l)  //释放空间
{
	if(l->stu == NULL)
		return 0;
	free(l->stu);
	l->length =0;
	l->listsize=0;
	return 1;
}
void intput(sqlist *l)  //输入
{
	int i;
	printf("序号  姓名  年龄  学号  \n");
	for(i=0;i<l->length;i++)
	{
		scanf("%d  %s %d %ld",&l->stu[i].xuhao,l->stu[i].name,&l->stu[i].age,&l->stu[i].ID);
	}
}
void output(sqlist *l) //输出
{
	
	int i;
	printf("序号  姓名  年龄  学号  \n");
	for(i=0;i<l->length;i++)
	{
		printf("%d  %s  %d  %ld\n",l->stu[i].xuhao,l->stu[i].name,l->stu[i].age,l->stu[i].ID);
	}
}
void chazhao(sqlist *l)    //查找
{
	printf("请输入要查找学生的学号：");
	int i,d;
	long id;
	scanf("%ld",&id);
	for(i=0;i<l->length;i++)
	{
		if(id==l->stu[i].ID)
			d=i;
	}
	if(d<l->length&&d>=0)	
		printf("找到了在第%d行\n  %d  %s  %d  %ld\n",d+1,l->stu[d].xuhao,l->stu[d].name,l->stu[d].age,l->stu[d].ID);
	else
		printf("该学生不存在\n");
}
void add(sqlist *l)   //添加
{
	printf("要添加几位学生：");
	int m;
	scanf("%d",&m);
	int i=l->length;
	l->length+=m;
	printf("添加学生的信息：\n");
	printf("序号  姓名  年龄  学号  \n");
	for(i;i<l->length;i++)
	{
		scanf("%d  %s %d %ld",&l->stu[i].xuhao,l->stu[i].name,&l->stu[i].age,&l->stu[i].ID);
	}
}
void amend(sqlist *l)  //删除
{
	int n;
	printf("请输入要删除的序号：");
	scanf("%d",&n);
	int i=0,d;
	for(i=0;i<l->length;i++)
	{
		if(l->stu[i].xuhao==n)
			d=i;
	}
	for(i=d;i<l->length-1;i++)
	{

		l->stu[i]=l->stu[i+1];
	}

	l->length--;
}
void change(sqlist *l) //改
{
	int n;
	printf("请输入要修改的序号：");
	scanf("%d",&n);
	int i,d;
	for(i=0;i<l->length;i++)
	{
		if(l->stu[i].xuhao==n)
			d=i;
	}
	printf("请输入修改后的结果：\n");
	scanf("%d  %s %d %ld",&l->stu[d].xuhao,l->stu[d].name,&l->stu[d].age,&l->stu[d].ID);
}
void menu()
{
	printf("功能\n");
	printf("1.添加学生的信息\t2.查找学生信息\n3.删除学生信息\t4.修改学生信息\n5.查看所有学生信息\t0.退出\n");
	printf("请输入想要的功能：");
}

main.c文件

#include "head.h"
int main()
{
	printf("请输入学生个数：");
	int n;
	scanf("%d",&n);
	sqlist *l;
	initlist(l,n);
//	printf("%d \n",l->length);
	intput(l);
	menu();
	int m;
	scanf("%d",&m);
	while(m)
	{
		switch(m)
		{
			case 1:add(l);break;
			case 2:chazhao(l);break;
			case 3:amend(l);break;
			case 4:change(l);break;
			case 5:output(l);break;
			case 0:break;
		}
		menu();
		scanf("%d",&m);
	}
	deletelist(l);

//	printf("%d \n",l->length);
	return 0;
}

一、概念

1.1数据

数据：能被计算机识别、存储、处理的符号的集合

数据类型：整数、小数、字符、字符串、汉字

非数据类型：声音，图片，视频，app,文件

数据元素：由数据项组合的，是数据的基本单位

数据项：数据项是数据的最小单位

数据对象：由相同类型的数据元素组成

数据> 数据对象> 数据元素> 数据项

1.2 数据结构

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

D_S=(D,R);

i) 逻辑结构

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

1.线性结构：数据元素之间存在一对一的逻辑关系【地铁上的座位，数组】

头节点无前驱，尾节点无后继，中间节点存在唯一的前驱，唯一的后继

2.树形结构：数据元素之间存在一对多的逻辑关系【族谱】

头节点无前驱，尾节点无后继，中间节点存在唯一的前驱，多个的后继

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

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

ii)存储结构/物理结构

存储结构：逻辑结构在计算机的存储形式

1.顺序存储：使用任意一段连续的存储空间，存储数据【数组】

逻辑相邻，物理也相邻

2.链式存储：使用任意一段空间实现存储数据【银行取钱】

逻辑相邻，物理不一定相邻

3.索引存储：由索引表和数据文件实现的查找

4.散列存储：哈希存储，关键通过哈希函数映射在计算机一种存储形式

实现查找功能

1.3 时间复复杂度

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

公式：T(n)=O(f(n))

T： time 时间

T(n): 时间复杂度

O：渐进符、大O阶

n:问题的规模

f(n):问题规模的函数

时间复杂度：只保留最高阶
    f(n)=3*n^2+n^2+100+n
    T(n)=O(3*n^3+n^2+100+n)=O(3*n^3)=O(n^3)
1>O(1):常数阶
    int t=a; 1
    a=b;    1
    a=t;    1
    f(n)=3
    T(n)=O(3)=O(3*n^0)=O(n^0)=O(1)
2>O(n): 线性阶
    for(int i=1;i<=n;i++)    n+1
    {
        printf("1");          n
    }
    f(n)=n*2+1=n
3> O(n^2): 平方阶
    for(int i=1;i<=n;i++)    n+1
    {
        for(int j=1;j<=n;j++) n*(n+1)
        {
               printf("1");        n*n
        }    
    }
    f(n)=2*n^2+2*n+1--->n^2
    
    for(int i=1;i<n;i++)  n
    {
        for(int j=0;j<n-i;j++) (n-1)*(n-i)
        {
            printf("1");        (n-1)*(n-i-1)
        }    
    }
    f(n)=n^2
3> O(n^3): 立方阶
    for(int i=1;i<=n;i++) n+1
    {
            for(int j=1;j<=m;j++) n*(m+1)
            {
                for(int k=1;k<=n;k++) n*m*(n+1)
                {
                    printf("1");       n*m*n         
                }            
            }
    }
    f(n)=2*n^2*m+2*n*m+1=2*n^2*m=n^2*m
4>O(log2n):对数阶
    int i=1;   1
    int n=8;   1
    while(i<n) log2 n +1
    {
        i*=3;    123   log2 n
    }
    f(n)=2*log2 n  +3=log2n

二、线性表

线性表：由类型相同的数据元素组成的线性结构。

1.逻辑结构：线性结构【一对一】

2.存储结构：顺序存储、链式存储

线性表：顺序表、链表、栈、队列、数组、字符串

三、顺序表

1.顺序表：线性表的顺序存储称为顺序表

2.顺序表的逻辑结构：线性结构

3.存储结构：顺序存储【逻辑相邻，物理也相邻】

4.顺序表是借助于一维数组实现的，但是不等价于一维数组

5.顺序表长度：实际元素的个数，变 int len;

7.线性表长度：数组长度，存储数据的最大空间，不变#define MAXSIZE 8

8.顺序表满：len==MAXSIZE

9.顺序表空:len==0

3.1 顺序表操作

1.顺序表结构体定义

顺序表：顺序表长度、数据元素

2.顺序表创建空间

/*
 * 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;
}

3.顺序表尾插入

/*
 * 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;
}

4.顺序表尾尾删

/*
 * 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;
}

5.顺序表任意下标插入

6.顺序表任意下标删除

7.顺序表任意下标修改

8.顺序表任意下标查找

/*
 * 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];
}

9.顺序表任意元素插入

参数：被插入的元素key，要插入的元素e，顺序表list

1,查找key在顺序表的位置 seach_by_data得到下表

2.在下表插入e insert_by_sub

10.顺序表任意元素删除

参数：被删除的元素，顺序表

11.顺序表任意元素修改

参数：被修改的元素key，要修改的元素e，顺序表list

12.顺序表任意元素查找

13.顺序表去重

14.顺序表排序

15.顺序表合并

16.顺序表判空

/*
 * function:    顺序表为空
 * @param [ in] 
 * @param [out] 
 * @return      空返回-1 非空返回0
 */
int empty(Seqlist *list)
{
    return list->len==0?-1:0;
}

17.顺序表判满

/*
 * function:    判断顺序表满
 * @param [ in] 
 * @param [out] 
 * @return      满返回-1  不满返回0
 */
int full_list(Seqlist *list)
{
    return list->len==MAXSIZE?-1:0;
}

18.顺序表输出

/*
 * 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("");

}