【无标题】

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

八月第一周学习总结

提示：这里可以添加本文要记录的大概内容：

本文内容发关于个人对数据结构学习的部分内容总结

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、数据结构

数据与数据之间关系、存储，以及运算

1. 关系—逻辑结构
   就是数据之间的抽象关系（先后、从属、邻接、层次）
   四种逻辑结构：线性、树型、图型、集合

2. 存储—存储结构
   就是数据的逻辑结构在计算机中进行存储方式

3. 运算—数据操作
   能够对数据进行操作（增、删、改、查、排序）

二、算法与数据结构

1. 算法设计：依赖于数据结构的逻辑结构
2. 算法实现：依赖于数据结构的存储结构
3. 程序 = 数据结构 + 算法

三、线性表

1.线性表的存储结构

存储线性表时，除了要存储具体线性表的数据意外，还要存储数据与数据之间的关系(线性关系、线性结构、先后关系)
顺序存储：数据在存储时，申请的是一段连续的内存空间，把数据存储到这段连续空间（地址相邻）中。

2.顺序存储

存储数据元素时，把数据元素按照逻辑关系（先后顺序），依次存储在一段连续的内存空间，借助元素在这段连续空间的地址，来表示数据之间的先后关系。
顺序表创建（示例）：

struct array
{
	int num;
	int Nos[5];
};
struct array * create()
{
	struct array * p = malloc(sizeof(struct array));
	if(p == NULL)
	{
		printf("malloc error\n");
		return NULL;
	}
	p->num = 0;
	return p;
}

3.链式存储

单链表：
逻辑结构为线性结构，存储结构为链式存储的一种数据结构。数据元素之间的位置是任意的（需要有这个元素才创建申请空间），在一个数据元素中由两部分构成，数据内容与关系。关系：通过指针元素来表示，存储下一个数据元素的地址。
双向链表：
关系不再是只存储下一个元素的地址，把前后关系都存储，每个数据元素有两个指针，分别存储前一个元素的地址，以及后一个元素的地址；分别指向直接前驱与直接后继；双向链表可以让链表的访问更加方便
链表创建（示例）：

struct link{
	char name[20];
	struct link *prior;
	struct link *next;
};

struct link * create(){
	struct link *head=malloc(sizeof(struct link));
	if(head==NULL){
		printf("create error\n");
		return NULL;
	}
	head->next=NULL;
	head->prior=NULL;
}

三、栈

1.栈

就是一种只能在一端进行存取的线性表，遵循先进后出原则的数据结构，只能操作栈顶
对于栈而言，只能操作栈顶元素，不能越过栈顶元素操作其他元素；如果操作完栈顶元素（插入、删除），则会有的栈顶元素

2.顺序栈：（顺序表，限制操作位置的顺序表）

顺序存储有两个端点（a0, an）,选择不能操作的一端，栈顶就从栈底位置开始移动，栈顶指向最后一个元素的位置，当插入时，栈顶移动到最新（下一个）数据元素位置，当删除时，栈顶移动到最新（上一个）数据元素位置

3.链式栈：（链表，限制操作位置的链表）

每个元素申请空间存储地址来表示先后顺序，需要存储元素时才申请空间，有第一个元素以及最后一个元素两端，限制只能在一端进行操作
头节点的next存栈顶元素，每次都在头节点位置进行操作，头节点的next就是栈顶位置，每个栈顶
元素存储上一个栈顶元素的地址；节点的next为NULL就是栈底元素

队列

与栈类似，还是一种操作受限的线性表。只能在线性表的两端进行操作（插入、删除），其中一端只能做插入，另一端只能做删除

双向链表代码：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

struct link{
	char name[20];
	struct link *prior;
	struct link *next;
};

struct link * create(){
	struct link *head=malloc(sizeof(struct link));
	if(head==NULL){
		printf("create error\n");
		return NULL;
	}
	head->next=NULL;
	head->prior=NULL;
}
//指定位置添加
void add(struct link *head,int pos,char *data){
	struct link *p=head;
	struct link *new=malloc(sizeof(struct link));
	for(int i=0;i<pos-1&&p->next!=NULL;i++){
		p=p->next;
	}
	if(p->next!=NULL){
		p->next->prior=new;
	}
	new->next=p->next;
	p->next=new;
	new->prior=p;
	strcpy(new->name,data);
}
//判空
int empty(struct link *head){
	if(head->next==NULL){
		return 1;
	}
	return 0;
}
//指定位置删除
void del(struct link *head,int pos){
	struct link *p=head;
	struct link *q;
	if(empty(p)){
		printf("empty\n");
		return;
	}
	for(int i=0;i<pos-1;i++){
		if(p->next==NULL){
			printf("error\n");
			return;
		}
		p=p->next;
	}
	q=p->next;
	if(q->next!=NULL){
		q->next->prior=p;
	}
	p->next=q->next;
	free(q);
}
//修改
void change(struct link *head,int pos,char *newdata){
	struct link *p=head;
	if(empty(p)){
		printf("empty\n");
		return;
	}
	for(int i=0;i<pos-1;i++){
		if(p->next==NULL){
			printf("error");
			return;
		}
		p=p->next;
	}
	strcpy(p->next->name,newdata);
}
//单个查找
void lookup(struct link *head,int pos){
	struct link *p=head;
	if(empty(p)){
		printf("empty\n");
		return;
	}
	for(int i=0;i<pos-1;i++){
		if(p->next==NULL){
			printf("error\n");
			return;
		}
		p=p->next;
	}
	printf("name is :%s\n",p->next->name);
}
//查看全部
void showlink(struct link *head){
	struct link *p=head;
	if(empty(p)){
		printf("empty\n");
		return;
	}
	while(p->next!=NULL){
		p=p->next;
		printf("%s  ",p->name);
	}
	printf("\n");
}

int main()
{
	struct link *s;
	s=create();
	showlink(s);
	lookup(s,2);
	del(s,2);
	change(s,2,"a");
	add(s,1,"a");
	add(s,1,"b");
	add(s,2,"c");
	showlink(s);
	del(s,1);
	showlink(s);
	lookup(s,1);
	change(s,1,"d");
	showlink(s);
}

总结

通过近段时间对数据结构的学习，对数据的存储结构与逻辑结构有了更深刻的印象，在数据结构中，队列和栈都是线性表演变得到，栈和队列都是特殊的线性表。顺序存储固定了存储空间大小，但是相对链表方便访问，链表为固定表的大小，可存储数据不定，但是在访问时相对顺序表要麻烦。