C语言基础&&数据结构&&笔记

empathy_Yang

已于 2023-12-19 16:56:36 修改

阅读量132

点赞数 5

分类专栏：数据结构与C语言基础文章标签： c语言数据结构笔记

于 2023-11-12 12:38:03 首次发布

本文链接：https://blog.csdn.net/m0_73984165/article/details/134205399

版权

数据结构与C语言基础专栏收录该内容

7 篇文章 0 订阅

订阅专栏

前言

本次的博客内容主要围绕着指针来说，因为这几个星期的安排有点满，所以学习的进度会慢一点，大家多多担待。

一、指针的相关问题的详解

1.1 指针的概念

在信息工程中指针是一个用来指示一个内存地址的计算机语言的变量或中央处理器(CPU)中寄存器(Register)【用来指向该内存地址所对应的变量或数组】。指针一般出现在比较接近机器语言的语言，如汇编语言或C语言。面向对象的语言如Java一般避免用指针。指针一般指向一个函数或一个变量。在使用一个指针时，一个程序既可以直接使用这个指针所储存的内存地址，又可以使用这个地址里储存的函数的值。

当然，以上的都是官方的权威性解释，讲这么多大家肯定还是很懵呀对吧，换个通俗易懂的解释吧，指针是一个存放变量、数组、函数等地址的这么一个东西。

下面举个例子给大家看看：

#include <stdio.h>
int main()
{
	int a = 10;
	int* p = &a;
	printf("%p\n", &a);
	printf("%p\n", p);
}

由上述程序的运行结果可以看出，整型变量a的地址等于指针p所存的地址。

1.2 指针的定义

光知道指针是放地址的没用，你还要知道它放的是谁的地址或者这么说吧，你还要知道它放的是什么类型数据的地址，这就引出了指针的定义的问题。通常我们要定义一个指针，具体操作是：{所指向的数据的类型} * p{这里不止用p作为指针变量的名称还可以用pc、pt等等}，注意这里的指针类型一定要与指向的元素类型相同，原因是每个类型在内存中所占空间不同那么对应的步长也不同，当p+i的时候对应的意义也是不一样的，如整型吗，每次指针p++的时候是移动4个字节，但如果是字符型那就是1个字节，就像你跑五十米，五十米是一个内存空间，你要读取就得跑对吧，如果是整型指针那他每次就跑四米，而字符指针每次就跑一米，就是跨的步子不一样，也就是步长不一样，如果你让整型的指针指向字符就相当于你让博尔特与小朋友比赛跑50米，想想就会有问题吧。

1.3 指针的各种花里胡哨的用法&&学习中遇到的问题

现在知道了指针的概念，那么接下来就要谈谈它的相关用法了。

1.3.1 指向字符串的指针：

这里的代码是想用字符型指针打印一个字符串，开始想当然的以为字符指针嘛，开始指向的是这个字符串的地址直接用%c输出就行了，事实往往是打脸的，实践出真知，如果这里用%c进行输出输出的只有a ，因为指针记录的是该字符串的基地址而printf %c打印的是一个字符，所以只能打印a，将这里的%c换成%s就可以打印这个字符串了，因为指针指向的是这个字符串的首地址，而输出%s是一直输出直到遇到\0才停止，所以可以输出整个字符串。

1.3.2 指针数组

1.3.3 数组指针（多用于多维数组的使用）

注意：关于如何分辨数组指针还是指针数组，看后面的两个字就行，如果是数组指针那么这就是一个指向数组的指针，如果是指针数组，你们这就是一个数组，数组里的每个元素是指针。

使用的时候还要注意符号优先级的问题，稍不注意数组指针就会跟指针数组搞混。

1.3.4 延伸数组名与取地址数组名的区别

下面我们来看一段代码：提示一下arr为数组名，表示数组的基地址，而&arr表示的同样也是数组的基地址但含义不同，现在问到底哪里不同。

#include <stdio.h>
int main()
{
	int arr[10] = { 0 };
	printf("arr=%p\n", arr);
	printf("&arr=%p\n", &arr);

	printf("arr+1=%p\n", arr+1);
	printf("&arr=%p\n", &arr+1);
	return 0;
}

运行结果：

是不是有点晕，我当时也晕，为什么是这样的结果，后来才知道还是步长，这两个虽然都表示数组的基地址，但到arr+1，&arr+1的时候区别就出来了，arr+1表示往后移一个数组元素的空间，而&arr+1是移一个数组，步长不一样。

以下为图解：

二、顺序表的相关用法与操作

2.1 顺序表的建立

typedef int DataType;
typedef struct Seqlist
{//定义一个结构体用来控制顺序表

	DataType* Data;//可以使用malloc和realloc对其空间进行动态分配
	size_t size;//记录有效数据的个数
	size_t capacity;//记录空间可以存储元素空间的总大小
}Seqlist;

上述的代码的作用是定义一个名叫Seqlist的一个结构体，并定义三个结构体变量，分别为DataType类型指针Data，无符号整型size和无符号整型capacity（注意这里的DataType指的是数据类型，并不只仅限于int型）这里的Data指针目的是用来记录顺序表的基地址的；变量size的作用是记录顺序表的实际表长，也还有者另一个作用，那就是控制顺序表元素的删减；最后一个变量capacity是用来表示顺序表的最大长度的，所有的弄完整个顺序表的定义也就差不多了。

左边的结构体为Seqlist结构体，右侧为顺序表，我们通过左侧的Seqlist结构体来控制顺序表并对顺序表进行相应的操作。

2.2 顺序表的初始化

这里我们采用的是动态类型的申请，静态类型的申请是通过数组来实现的，但静态申请在实际情况中并不常用，因为大小不可改变。

静态申请：静态顺序表顾名思义就是一块不可增添或删除空间的定长顺序表，常用数组来实现。

#define MAX 100
void InitSeqList(struct Seqlist* ps)
{//顺序表初始化

	ps->Data = DataType[MAX];//用数组静态申请一个大小为MAX的顺序表
	ps->size = 0;//表示顺序表的实际表长
	ps->capacity = 100;//表示顺序表的总表长
}

动态申请：动态的顺序表可以自己按需要增添或删除空间的不定长顺序表

void InitSeqList(struct Seqlist* ps)
{//顺序表初始化

	ps->Data = (DataType*)malloc(sizeof(DataType) * 100);//用malloc函数开辟100个DataType类型大小的顺序表，将基地址赋给ps->Data
	ps->size = 0;//表示顺序表的实际表长
	ps->capacity = 100;//表示顺序表的总表长
}

这里的形参我们采用指针传址，这里如果传入的时候不是指针那就会出现问题。这里我们使用malloc函数来开辟100个Datatype类型的内存空间，然后用Data指针来记录这个空间的初始地址，因为此时顺序表还没有任何元素，顺序表为空，所以size的值为0，又因为我们开辟了100个空间，所以capacity最大表长就记为100，至此顺序表的初始化完成。

2.3 顺序表的插入与删除

2.3.1 尾差法

void SeqlistPushBack(Seqlist* ps, int x)//尾插法
{//数据的插入与顺序表的扩容

	if (ps->size == ps->capacity)//判断顺序表是否满容
	{
		if (ps->capacity == 0)
		{//避免顺序表内存空间为零的情况使扩容出现0*2=0的bug
			ps->capacity == 1;
		}
		DataType* temp =(DataType*)realloc(ps->Data, ps->capacity * sizeof(DataType) * 2);//申请一个临时指针进行扩容
		if (temp == NULL)//判断系统空间是否有内存空间进行扩容
		{
			printf("扩容失败\n");//如果没有空间进行扩容，则返回扩容失败
		}
        ps->Data = temp;
	}
//顺序表元素的插入
	ps->Data[ps->size] = x;
	++ps->size;//插入一个数据后实际表长加1
}

在进行元素插入这个操作之前，我们是不是应该判断一下能不能插，虽然我这里的代码是空表，肯定是有位置插的，但一般情况下不是这样的，是未知的，所以我们要用个if结构判断一下实际表长是否等于最大表长，如果等于则需要对顺序表进行扩容，而扩容这里我们就需要用到realloc函数，具体操作为：在使用前一定要有<stdlib.h>这个头文件，没有函数就不能使用。

realloc（原顺序表的基地址，原顺序表的最大表长*顺序表每个元素所占字节大小*2），注意这里的*2是一般的乘法，就是将原来顺序表的空间大小扩大两倍，这里的倍数可以自行定义，不一定只能是2哦。使用realloc扩容后将新的顺序表的基地址赋给一个DataType类型指针temp，原因在于如果空间申请失败将会返回一个空指针，如果将空指针赋给p我们不仅不会拿到新的空间还会丢失原来的开辟的内存空间。为了保险我们临时创建指针temp来接收realloc的返回值，当它申请成功时再将其空间交给p。而在使用realloc函数进行扩容时要判断系统有没有空间给你进行扩容，所以要用个选择分支结构进行判断看temp指针是否为空，为空则扩容失败。

好，当空间内存充足不用扩容时就可以进行插入操作了，这里我们用的是尾插法，比较基本，就是给顺序表从头一直往后插元素然后实际表长加加，类似这个效果，从头一个个赋值。

这一切的一切用这一段语句就可以代替：ps->Data[ps->size] = x；记住在插完元素后实际表长要加一，这样尾插就搞定了。

2.3.2 头插法

搞完尾插，接下来就搞个复杂一点的头插，头插麻烦就麻烦在每插一个元素之前的元素就要往后移一位，做一个不恰当的比喻就是你在排队，就你一个人在排，然后突然有个人来插队，跑你前面去了，你就往后移了一位，然后又有人插队，插到之前插在你前面的人的前面的前面，你跟你前面的人都往后移，差不多这样，可见插队是多么的可耻啊，咳咳，回到正题，头插就是这样，不断的插队。

void SeqlistPushFront(Seqlist* ps, DataType x)//头插法
{
	if (ps->size == ps->capacity)//判断顺序表是否满容
	{
		if (ps->capacity == 0)
		{//避免顺序表内存空间为零的情况使扩容出现0*2=0的bug
			ps->capacity == 1;
		}
		DataType* temp = (DataType*)realloc(ps->Data, ps->capacity * sizeof(DataType) * 2);//申请一个临时指针进行扩容
		if (temp == NULL)//判断系统空间是否有内存空间进行扩容
		{
			printf("扩容失败\n");//如果没有空间进行扩容，则返回扩容失败
		}
        ps->Data = temp;
	}
//顺序表元素的插入
	
	int cur = ps->size;//用一个变量记录顺序表最后一个元素的后一位的位置
	while (cur>0)
	{
		ps->Data[cur] = ps->Data[cur - 1];//让最后一个元素的后一位等于最后一个元素，然后一直换换到第一个元素为止跳出
			--cur;
	}

	ps->Data[cur] = x;//将想要插的值赋给想要插的位置
	++ps->size;//插入一个元素，实际表长加1

}

以上是代码展示，前面的扩容和尾插一样的原理就不多说了，主要的是下面的操作。具体的解释我写了注释，主要的思想可以看下面的图示，可能有点丑，反正意思是这个意思啦，就是往后移元素。虽然我写了注释，但我还是解释一下吧，要移元素首先我们得定义一个int型变量cur，记录顺序表最后一个元素的位置，最后再通过一个循环让最后一个元素的后一位等于最后一个元素，跳出循环的条件是cur>0，如果不满足则会一直换，移完位置后就是赋值和实际表长加1的操作了。

2.3.3 任意位置插入

到这里，哼哼，我告诉你，其实是前面的尾插和头插都可以不用看的，不需要，因为我可以任意位置插入了，还要你前面一个一个按顺序插干嘛对吧，那么如何实现任意位置插入元素呢，其实很简单，可以看底下的代码演示：

void SeqlistPush(Seqlist* ps, int pos, DataType x)
{//任意位置插入元素
	if (ps->size == ps->capacity)//判断顺序表是否满容
	{
		if (ps->capacity == 0)
		{//避免顺序表内存空间为零的情况使扩容出现0*2=0的bug
			ps->capacity == 1;
		}
		DataType* temp = (DataType*)realloc(ps->Data, ps->capacity * sizeof(DataType) * 2);//申请一个临时指针进行扩容
		if (temp == NULL)//判断系统空间是否有内存空间进行扩容
		{
			printf("扩容失败\n");//如果没有空间进行扩容，则返回扩容失败
		}
        ps->Data = temp;
	}
		//顺序表元素的插入
	   
		int cur = ps->size;//用一个变量记录顺序表最后一个元素的后一位的位置
		while (cur >= pos)
		{
			ps->Data[cur] = ps->Data[cur - 1];//让最后一个元素的后一位等于最后一个元素，然后一直换换到第一个元素为止跳出
			--cur;
		}
		
		ps->Data[cur] = x;//将想要插的值赋给想要插的位置
		++ps->size;//插入一个元素，实际表长加1
}

可以看到代码基本跟之前的头插没什么变化，无非就多了一个pos这个东西嘛，那这个pos是用来干什么的呢，当然是用来记录插入数据的位置的啦，输入你想插入的位置，注意这里循环是大于等于，这里相当于让循环终止条件变成到你想插入的位置，上面的头插是从顺序表的第一个位置插，区别不是很大。

2.3.4 尾删法

void SeqlistDeleteBack(Seqlist * ps)
{//尾删法
	if (ps->size > 0)
		--ps->size;//用size控制元素的删增，size-1代表删了最后一个元素，至于里面值是多少不管
	else
		printf("此表已空\n");

}

尾删就是从后往前删顺序表的元素，但说是删吧也不是我们平常理解的删，我们平常理解的删应该是直接把一个元素给干没了，但这里不是，这里是通过让实际表长减一来进行删除，假如我本来有按序排的四个元素在顺序表中，现在我让实际表长减一，那第四个元素就不管了，相当于删了，做一个不恰当的比喻，四十人的教室，坐了39个上课的，还有一个不是本班在这上自习的，我们上课的时候需要管他吗，不需要，我们上我们的，不影响。

2.3.5 头删法

void SeqlistDeleteFront(Seqlist* ps)
{//头删法
	int cur = 0;
	while (cur < ps->size - 1)//删除第一个元素，将后面元素前移
	{
		ps->Data[cur] = ps->Data[cur + 1];
		++cur;
	}
	ps->size = ps->size - 1;//删除一个元素实际表长减1
	printf("删除成功\n");
}

前面的头插法理解了头删也就差不多了，既然头插法是将元素往后移，那头删法就是往前移，注意这里的cur与上面头插的cur不同，前者指物理位置，后者指逻辑位置，这里通过循环让前一个元素等于后一个元素，一直到跳出循环让实际表长减一，原来被删前的最后一个位置上的元素就不管了，原理上面也解释了就不多说了。

2.3.6 任意位置的删除

void SeqlistDelete(Seqlist* ps, int pos)//pos表示所删元素的逻辑位置
{//任意删除一个元素
	int cur = pos-1;//pos-1为所删元素的物理位置
	while (cur < ps->size - 1)//删除第pos个元素，将后面元素前移
	{
		ps->Data[cur] = ps->Data[cur + 1];
		++cur;
	}
	ps->size = ps->size - 1;//删除一个元素实际表长减1
	printf("删除成功\n");
}

任意位置的删除就是将头删的cur=0改成cur=你想删的物理位置即可，因为你输入的是你想删除的逻辑位置，所以要减一才是物理位置，其他没什么变化，当然知道任意删那前面的头删、尾删就压根不用考虑，咳咳我这么说不代表不要掌握啊。

2.4 顺序表的查找、取值

2.4.1 查找

int Find(Seqlist* ps, DataType x)
{//查找
	int temp = 0;
	
	while (temp < ps->size)//遍历一遍顺序表，将输入的学生信息一个个与顺序表的每个元素进行比较
	{
		if(strcmp(x.number,ps->Data[temp].number)==0&& strcmp(x.name,ps->Data[temp].name)==0&& strcmp(x.phonenumber,ps->Data[temp].phonenumber)==0)//这里运用strcmp函数来进行字符串之间的比较
			return temp+1;
		++temp;
	}
	printf("没有找到与之相匹配的学生信息\n");
	return -1;
}

上述代码是我写的学生管理系统的查找功能函数，查找我们可以用一个循环，循环体里为一个判断，就是你输入想要查找的元素看等不等于顺序表的元素，一个一个比较，直到将顺序表中的所有元素比完，如果还没有则返回-1，如果有则返回temp+1，因为这里的temp指的是物理位置，而输出的是逻辑位置所以要加一。

2.4.2 取值

DataType Get(Seqlist* ps, size_t pos)//因为传入的是逻辑位置，所以返回值的时候要注意是pos-1，因为数组下标为物理位置
{//取值
	printf("%s,%s,%s\n",ps->Data[pos - 1].number, ps->Data[pos - 1].name, ps->Data[pos - 1].phonenumber);
	return ps->Data[pos - 1];
}

取值操作只要打印你想要位置的元素即可，注意，你这里输入进去的是逻辑位置，二我们打印的时候用的是物理位置，所以要让pos-1，然后返回当前位置的值就行。

2.5 顺序表的的输出

这里直接用一个循环一个个打印就行。

void Print(Seqlist* ps)
{//打印所插入的元素
	int t = 0;
	while (t < ps->size)
	{
		printf("%s,%s,%s\n", ps->Data[t].number, ps->Data[t].name, ps->Data[t].phonenumber);
		t++;
	}
	printf("\n");
}

2.6 顺序表的销毁

void Destory(Seqlist* ps)
{//销毁顺序表
	free(ps->Data);//释放指针所对应的内存空间
    ps->capacity = ps->size = 0;
	ps->Data = NULL;//将ps->Data指针置空，防止其变成野指针
}

用free函数来释放Data指针所指向的空间，释放完后让Data指针置空，不然会成为野指针

2.7 主函数部分

int main()
{//主函数部分
	Seqlist s;
	int x;
	InitSeqList(&s);
	InsterStudent(&s);
	InsterStudent(&s);
	InsterStudent(&s);
	InsterStudent(&s);
	InsterStudent(&s);
	InsterStudent(&s);
	InsterStudent(&s);
	InsterStudent(&s);
	InsterStudent(&s);
	printf("插入的学生信息如下\n");
	Print(&s);
	printf("\n");
	FindStudent(&s);
	printf("请输入你想取的位置的学生信息\n");
	scanf("%d", &x);
	Get(&s, x);
	printf("删除一个位置的学生信息,请输入删除位置\n");
	scanf("%d",&x);
	SeqlistDelete(&s,x);
	Print(&s);
}

这里我写的是一个学生管理系统。

2.8 完整学生管理系统代码

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct student
{
	char number[20] = {0};//学生的学号
	char name[20] ={0};//学生姓名
	char phonenumber[30] = {0};//学生的电话号码
}DataType;

typedef struct Seqlist
{//定义一个结构体用来控制顺序表

	DataType* Data;//可以使用malloc和realloc对其空间进行动态分配
	size_t size;//记录有效数据的个数
	size_t capacity;//记录空间可以存储元素空间的总大小
}Seqlist;
void InitSeqList(struct Seqlist* ps)
{//顺序表初始化

	ps->Data = (DataType*)malloc(sizeof(DataType) * 100);//用malloc函数开辟100个DataType类型大小的顺序表，将基地址赋给ps->Data
	ps->size = 0;//表示顺序表的实际表长
	ps->capacity = 100;//表示顺序表的总表长
}
void SeqlistPushBack(Seqlist* ps, DataType x)//尾插法
{//数据的插入与顺序表的扩容

	if (ps->size == ps->capacity)//判断顺序表是否满容
	{
		if (ps->capacity == 0)
		{//避免顺序表内存空间为零的情况使扩容出现0*2=0的bug
			ps->capacity == 1;
		}
		DataType* temp =(DataType*)realloc(ps->Data, ps->capacity * sizeof(DataType) * 2);//申请一个临时指针进行扩容
		if (temp == NULL)//判断系统空间是否有内存空间进行扩容
		{
			printf("扩容失败\n");//如果没有空间进行扩容，则返回扩容失败
		}

	}
//顺序表元素的插入

	ps->Data[ps->size] = x;
	++ps->size;//插入一个数据后实际表长加1
	printf("插入成功\n");
}

void SeqlistPushFront(Seqlist* ps, DataType x)//头插法
{
	if (ps->size == ps->capacity)//判断顺序表是否满容
	{
		if (ps->capacity == 0)
		{//避免顺序表内存空间为零的情况使扩容出现0*2=0的bug
			ps->capacity == 1;
		}
		DataType* temp = (DataType*)realloc(ps->Data, ps->capacity * sizeof(DataType) * 2);//申请一个临时指针进行扩容
		if (temp == NULL)//判断系统空间是否有内存空间进行扩容
		{
			printf("扩容失败\n");//如果没有空间进行扩容，则返回扩容失败
		}

	}
//顺序表元素的插入
	
	int cur = ps->size;//用一个变量记录顺序表最后一个元素的后一位的位置
	while (cur>0)
	{
		ps->Data[cur] = ps->Data[cur - 1];//让最后一个元素的后一位等于最后一个元素，然后一直换换到第一个元素为止跳出
			--cur;
	}

	ps->Data[cur] = x;//将想要插的值赋给想要插的位置
	++ps->size;//插入一个元素，实际表长加1
	printf("插入成功\n");
}
void SeqlistPush(Seqlist* ps, int pos, DataType x)
{//任意位置插入元素
	if (ps->size == ps->capacity)//判断顺序表是否满容
	{
		if (ps->capacity == 0)
		{//避免顺序表内存空间为零的情况使扩容出现0*2=0的bug
			ps->capacity == 1;
		}
		DataType* temp = (DataType*)realloc(ps->Data, ps->capacity * sizeof(DataType) * 2);//申请一个临时指针进行扩容
		if (temp == NULL)//判断系统空间是否有内存空间进行扩容
		{
			printf("扩容失败\n");//如果没有空间进行扩容，则返回扩容失败
		}
	}
		//顺序表元素的插入
	   
		int cur = ps->size;//用一个变量记录顺序表最后一个元素的后一位的位置
		while (cur >= pos)
		{
			ps->Data[cur] = ps->Data[cur - 1];//让最后一个元素的后一位等于最后一个元素，然后一直换换到第一个元素为止跳出
			--cur;
		}
		
		ps->Data[cur] = x;//将想要插的值赋给想要插的位置
		++ps->size;//插入一个元素，实际表长加1
		printf("插入成功\n");
}
	
void SeqlistDeleteBack(Seqlist * ps)
{//尾删法
	if (ps->size > 0)
		--ps->size;//用size控制元素的删增，size-1代表删了最后一个元素，至于里面值是多少不管
	else
		printf("此表已空\n");

}

void SeqlistDeleteFront(Seqlist* ps)
{//头删法
	int cur = 0;
	while (cur < ps->size - 1)//删除第一个元素，将后面元素前移
	{
		ps->Data[cur] = ps->Data[cur + 1];
		++cur;
	}
	ps->size = ps->size - 1;//删除一个元素实际表长减1
	printf("删除成功\n");
}

void SeqlistDelete(Seqlist* ps, int pos)//pos表示所删元素的逻辑位置
{//任意删除一个元素
	int cur = pos-1;//pos-1为所删元素的物理位置
	while (cur < ps->size - 1)//删除第pos个元素，将后面元素前移
	{
		ps->Data[cur] = ps->Data[cur + 1];
		++cur;
	}
	ps->size = ps->size - 1;//删除一个元素实际表长减1
	printf("删除成功\n");
}

DataType Get(Seqlist* ps, size_t pos)//因为传入的是逻辑位置，所以返回值的时候要注意是pos-1，因为数组下标为物理位置
{//取值
	printf("%s,%s,%s\n",ps->Data[pos - 1].number, ps->Data[pos - 1].name, ps->Data[pos - 1].phonenumber);
	return ps->Data[pos - 1];
}

int Find(Seqlist* ps, DataType x)
{//查找
	int temp = 0;
	
	while (temp < ps->size)//遍历一遍顺序表，将输入的学生信息一个个与顺序表的每个元素进行比较
	{
		if(strcmp(x.number,ps->Data[temp].number)==0&& strcmp(x.name,ps->Data[temp].name)==0&& strcmp(x.phonenumber,ps->Data[temp].phonenumber)==0)//这里运用strcmp函数来进行字符串之间的比较
			return temp+1;
		++temp;
	}
	printf("没有找到与之相匹配的学生信息\n");
	return -1;
}

void FindStudent(Seqlist* ps)
{//查找学生信息
	DataType A;
	printf("请输入想要查找的学生信息\n");
	scanf("%s%s%s", &A.number, &A.name, &A.phonenumber);
	int i=Find(ps, A);
	printf("%d\n", i);

}

void Print(Seqlist* ps)
{//打印所插入的元素
	int t = 0;
	while (t < ps->size)
	{
		printf("%s,%s,%s\n", ps->Data[t].number, ps->Data[t].name, ps->Data[t].phonenumber);
		t++;
	}
	printf("\n");
}

void Destory(Seqlist* ps)
{//销毁顺序表
	free(ps->Data);//释放指针所对应的内存空间
	ps->Data = NULL;//将ps->Data指针置空，防止其变成野指针
}

void InsterStudent(Seqlist* ps)
{//学生信息插入
	DataType A;//初始化结构体A
	printf("请输入学生的学号，姓名，联系电话\n");
	scanf("%s%s%s", &A.number, &A.name, &A.phonenumber);//录入学生信息
	SeqlistPushBack(ps, A);//将录入的信息插入到顺序表中

}

int main()
{//主函数部分
	Seqlist s;
	int x;
	InitSeqList(&s);
	InsterStudent(&s);
	InsterStudent(&s);
	InsterStudent(&s);
	InsterStudent(&s);
	InsterStudent(&s);
	InsterStudent(&s);
	InsterStudent(&s);
	InsterStudent(&s);
	InsterStudent(&s);
	printf("插入的学生信息如下\n");
	Print(&s);
	printf("\n");
	FindStudent(&s);
	printf("请输入你想取的位置的学生信息\n");
	scanf("%d", &x);
	Get(&s, x);
	printf("删除一个位置的学生信息,请输入删除位置\n");
	scanf("%d",&x);
	SeqlistDelete(&s,x);
	Print(&s);
}

运行结果：

本期博客就到这啦，该文章偏向于数据结构方面，所以代码量较多，主要是理解和实现。如果有错误还请各位看客不吝赐教，谢谢大家啦~

我们下一期见~

empathy_Yang

关注

5
点赞
踩
0

收藏

觉得还不错? 一键收藏
2
评论
C语言基础&&数据结构&&笔记

本次的博客内容主要围绕着指针来说，因为这几个星期的安排有点满，所以学习的进度会慢一点，大家多多担待。光知道指针是放地址的没用，你还要知道它放的是谁的地址或者这么说吧，你还要知道它放的是什么类型数据的地址，这就引出了指针的定义的问题。通常我们要定义一个指针，具体操作是：{所指向的数据的类型} * p{这里不止用p作为指针变量的名称还可以用pc、pt等等}
复制链接

扫一扫