数据结构初识(大一暑假)

于 2019-08-28 10:29:05 发布
阅读量669 收藏 2
点赞数 1
分类专栏： 初学
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_43634388/article/details/97899852
版权

复习

书的推荐
2019.07.31
2019.07.31
2019.07.31

int main() {
	int *p;//p是个指针变量名字，int*表示该p变量只能存储int类型变量的地址
	int i = 10;
	int j;
	
	p = &i;
	j = *p;//等价于 j = i 
	printf("i = %d,j = %d,*p = %d\n", i, j,*p);
	return 0;

void f(int *i) {
	*i = 100;
}

int main() {
	int i = 9;
	f(&i);
	printf("i = %d\n", i);
	return 0;
}

2019.07.31

void Print(int *p, int len) {
//	p[0] = -1;//p[0]==*p   p[i]就是主函数的a[i]
	int i = 0;
	for (i = 0; i < len; i++) {
		printf("%d\n", p[i]);
	}

}
int main() {
	int a[5] = { 1,3,5,7,9 };
//	printf("%d\n", *a + 3);//等价于 a[0]+3
//	printf("%d\n", *(a + 3));//等价于a[0+3]

	Print(a, 5);//a等价于&a[0],&a[0]本身就是int*类型 
	printf("%d\n", a[0]);// -1 改变了
	return 0;
}

double arr[3] = { 1.1,2.2,3.3 };
	double *q;
	q = &arr[0];
	printf("%p\n", q);//%p就是十六进制输出
	q = &arr[1];
	printf("%p\n", q);

差8个字节
在这里插入图片描述
无论指针变量指向一个多大的数，它的字节数是一样的

void f(int *p);//声明

int main() {
	int i = 10;
	f(&i);
	printf("i = %d\n", i);

	return 0;
}

void f(int *p) {
	*p = 99;
}

//但是这样写不安全！！！！！！！！！！！！
void f(int **q) {
	*q = (int *)0xFFFFFFFF;
}

int main() {
	int i = 9;
	int *p = &i;//int *p; p = &i
	printf("%p\n", p);
	f(&p);
	printf("%p\n", p);

	return 0;
}

struct Student {
	int sid;
	char name[200];
	int age;
};//分号不能省略

int main() {
	struct Student st = { 1000,"eurus",20 };
	printf("%d %s %d\n", st.sid,st.name,st.age);
	st.sid = 99;
	//st.name = "lisa"; Error
	strcpy(st.name, "lisa");
	st.age = 22;


	return 0;
}

struct Student *pst;
	pst = &st;
	pst->sid = 99;//pst->sid  等价于 (*pst).sid,而(*pst).sid 等价于 st.sid,所以pst->sid等价于 st.sid

在这里插入图片描述

**指针变量后面加->；
（*p）是一个普通变量，加 . **
在这里插入图片描述

void f(struct Student *pst);
void g(struct Student st);
void g2(struct Student  *pst);

int main() {
	struct Student st;//已经为st分配好了内存
	f(&st);
//	printf("%d %s %d\n", st.sid, st.name, st.age);
//	g(st); 结构体可以相互赋值
	g2(&st);
	
	return 0;
}

//这种方式耗内存，耗时间，不推荐
void g(struct Student st) {
	printf("%d %s %d\n", st.sid, st.name, st.age);
}

void g2(struct Student  *pst) {
	printf("%d %s %d\n", pst->sid, pst->name, pst->age);
}

void f(struct Student *pst) {
	(*pst).sid = 99;
	strcpy_s(pst->name, "Eurus");
	pst->age = 22;
}

int main() {
	//静态
	int a[5] = { 4,10,2,8,6 };

	//动态
	int len;
	printf("请输入数组的长度：len = ");
	scanf_s("%d", &len);
	int *pArr = (int*)malloc(sizeof(int)*len);
	//*pArr = 4;//类似于 a[0] = 4
	//pArr[1] = 10;//类似于a[1] = 10
	//printf("%d %d\n", *pArr, pArr[1]);

	//我们可以把pArr当做一个普通数组来使用
	for ( int i = 0; i < len; i++)
	{
		scanf_s("%d", &pArr);
	}
	for (int i = 0; i < len; i++)
	{
		printf("%d\n", *(pArr + i));
	}

	free(pArr);//把pArr所代表的动态分配的20个字节的内存释放
	return 0;
}

跨函数内存使用：

struct Student {
	int aid;
	int age;
};
struct Student *CreatStudent();
void PrintStudent(struct Student*);
int main() {
	struct Student *p;
	p = CreatStudent();
	PrintStudent(p);
	return 0;
}
struct Student *CreatStudent(void) {
	struct Student *p = (struct Student*)malloc(sizeof(struct Student));
	p->age = 88;
	p->aid = 99;
	return p;
}
void PrintStudent(struct Student* st) {
	printf("%d %d\n", st->age, st->aid);
}

数据结构初识

连续存储数组

//定义了一个数据类型，该数据类型的 名字叫做struct Arr,该数据类型 含有三个成员，分别是pBase，len，cnt
struct Arr {
	int *pBase; //存储的是数组第一个元素的地址
	int len; //数组所能容纳的最大元素的个数
	int cnt; //当前数组有效元素的个数
};

void init_arr(struct Arr *pArr, int length); //初始化
bool append_arr(struct Arr *pArr,int val); //追加
bool insert_arr(struct Arr *pArr,int pos,int val); //插入     pos的值从1开始 
bool delete_arr(struct Arr *pArr, int pos,int *pVal); //删除
bool is_empty(struct Arr *pArr);
bool is_full(struct Arr *pArr);
void sort_arr(struct Arr *pArr);
void show_arr(struct Arr *pArr);
void inversion_arr(struct Arr *pArr); //倒置

int main() {
	struct Arr arr;
	int val;

	init_arr(&arr,6);
	append_arr(&arr, 1);
	if (delete_arr(&arr, 1, &val)) {
		printf("删除成功！\n");
		printf("删除的元素是%d\n", val);
	}
	else {
		printf("删除失败!\n");
	}
	append_arr(&arr, 5);
	append_arr(&arr, 8);
	append_arr(&arr, 9);
	append_arr(&arr, 15);
	insert_arr(&arr, 1, 89);
	show_arr(&arr);

	inversion_arr(&arr);
	show_arr(&arr);
	sort_arr(&arr);
	show_arr(&arr);
	return 0;
}

void init_arr(struct Arr *pArr,int length) {
	pArr->pBase = (int *)malloc(sizeof(int) * length);
	if (NULL == pArr->pBase) {
		printf("动态内存分配失败！\n");
		exit(-1); //终止整个程序
	}
	else {
		pArr->len = length;
		pArr->cnt = 0;
	}
	return;
}

bool is_empty(struct Arr *pArr) {
	if (pArr->cnt == 0) {
		return true;
	}
	else {
		return false;
	}
}

void show_arr(struct Arr *pArr) {
	
	//if（数组为空），提示用户数组为空
	//else，输出数组的有效内容
	if (is_empty(pArr)) {
		printf("数组为空\n");
	}
	else {
		for (int i = 0; i < pArr->cnt; i++) {
			printf("%d ", pArr->pBase[i]);
		}
		printf("\n");
	}
}

bool is_full(struct Arr *pArr) {
	if (pArr->cnt == pArr->len) {
		return true;
	}
	else {
		return false;
	}
}

bool append_arr(struct Arr *pArr, int val) {
	//满是返回false
	if (is_full(pArr)) {
		return false;
	}
	//不满时追加
	else {
		pArr->pBase[pArr->cnt] = val;
		(pArr->cnt)++;
		return true; 
 	}
}

bool insert_arr(struct Arr *pArr, int pos, int val) {
	 //先移位，后插入
	int i;
	if (is_full(pArr)) {
		return false;
	}

	if (pos < 1 || pos > pArr->cnt + 1) {
		return false;
	}

	for (i = pArr->cnt - 1; i >= pos - 1; i--) {
		pArr->pBase[i+1] = pArr->pBase[i];
	}
	pArr->pBase[pos - 1] = val;
	pArr->cnt++;
	return true;
}

bool delete_arr(struct Arr *pArr, int pos, int *pVal) {
	int i;
	
	if (is_empty(pArr)) {
		return false;
	}
	if (pos < 1 || pos > pArr->cnt) {
		return false;
	}
	*pVal = pArr->pBase[pos-1];
	for (i = pos; i < pArr->cnt; i++) {
		pArr->pBase[i - 1] = pArr->pBase[i];
	}
	pArr->cnt--;
	return true;
}

void inversion_arr(struct Arr *pArr){
	int i = 0;
	int j = pArr->cnt - 1;
	int t;
	while (i < j) {
		t = pArr->pBase[i];
		pArr->pBase[i] = pArr->pBase[j];
		pArr->pBase[j] = t;
		i++;
		j--;
	}
	return;
}

void sort_arr(struct Arr *pArr) {
	int i, j;
	int t;
	for (i = 0; i < pArr->cnt; i++) {
		for (j = i + 1; j < pArr->cnt; j++) {
			if (pArr->pBase[i] > pArr->pBase[j]) {
				t = pArr->pBase[i];
				pArr->pBase[i] = pArr->pBase[j];
				pArr->pBase[j] = t;
			}
		}
	}
}

typedef的用法

typedef int Honey; //为int再重新多取一个名字，Honey等价于int

typedef struct Student {
	int aid;
	char name[100];
	char sex;
}ST;
int main() {
	//int i = 10; //等价于Honey i = 10
	//Honey j = 20;
	//printf("j = %d\n", j);


	struct Student st; //等价于 ST st
	struct Student *ps = &st; //等价于ST *ps

	ST st2;
	st2.aid = 200;
	printf("%d\n", st2.aid);

	return 0;
}

typedef int Honey; //为int再重新多取一个名字，Honey等价于int

typedef struct Student {
	int aid;
	char name[100];
	char sex;
}*PST,STU; // STU代表了struct Student，PST 等价于 struct Student *
int main() {
	STU st; //struct Student st;
	PST ps = &st; //struct Student *ps = &st
	ps->aid = 200;
	printf("%d\n", ps->aid);

	return 0;
}

链表
在这里插入图片描述
在这里插入图片描述
修改
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

栈
在这里插入图片描述
队列
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
【】队列为空
【】队列为满
修改后
count == N：队列为满
count == 0：队列为空
*在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
完全二叉树和满二叉树的区别

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
*F，根先出现的，所以是没有右子树的 *
在这里插入图片描述
答案
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
**快速排序 **

在这里插入图片描述

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值