数据结构：线性结构(1)

数据结构中的线性表即元素之间存在一对一关系的表
常见的线性结构有：数组、表、功能受限的表(栈、队列)

第一节

线性表的存储又分为:
1、顺序存储:在一块连续的内存存储元素与元素之间的关系
顺序存储的优点:速度快、不易产生内存碎片
顺序存储的缺点:对内存要求高、添加删除不方便
顺序表运算

typedef struct Array
{
	size_t size;
	TYPE base;
}Array;
//创建
Array* create_array(TYPE len)
{
	Array* array=malloc(sizeof(Array));
	base=malloc(sizeof(TYPE)*len);
	size=len;
	return array;
}
//销毁
void destroy_array(Array* arr)
{
	free(arr->size);
	free(arr);
}
//访问
TYPE* access_array(Array* arr,int index)
{
	if(index>arr->size || index<0) return NULL;
	return arr->base+i;
}
//查找
int find_array(Array* arr,TYPE data)
{
	for(int i=0;i<arr->size;i++)
	{
		if(arr->base+i == data) 
		{
			return i;
		}
	}
	return NULL;
}
//排序
void sort_array(Array* arr)
{
	for(int i=0;i< arr->size;i++)
	{
		for(int j=i+1;j< arr->size;j++)
		{
			int temp=0;
			if(arr[i] < arr[j])
			{
				temp=arr[i];
				arr[i]=arr[j];
				arr[j]=temp
			}
		}
	}
}
//遍历
void show_array(Array* arr)
{
	for(int i=0;i < arr->size;i++)
	{
		printf("%d ",arr->base+i);
	}
	printf("\n");
}
//删除
bool delete_array(Array* arr,int index)
{
	if(index<0 || index> arr->size) return false;
	for(int i=arr->size-1;i>index;i--)
	{
		arr->base[i-1]=arr->base[i];
	}
}
//插入
bool insert_Array(Array* arr,int index,TYPE data)
{
	if(index<0 || index>arr->size) return false;
	for(i=index;i<arr->size;i++)
	{
		arr->base[i]=arr->base[i+1];
	}
	return true;
}

TYPE表示数据类型
size定义的是元素个数，防止越界
base则用来定义堆内存的首地址，存储元素
顺序表逻辑上相邻的元素

在物理上也是相邻的，若要访问第i个元素可以使用base+i进行访问

2、链式存储:元素随机存储在内存空间内，元素之间建立联系(通过指针)构成关系
链式存储的优点:对内存要求低、添加删除方便
链式存储的缺点:查找速度慢，容易产生内存碎片，只能从头逐个遍历
链表又分为单向链表和双向链表
下面是单向链表的形式

// 创建节点
Node* create_node(void* data)
{
	Node* node = malloc(sizeof(Node));
	node->data = data;
	node->next = NULL;
	return node;
}



// 创建链表
List* create_list(void)
{
	List* list = malloc(sizeof(List));
	list->head = NULL;
	list->tail = NULL;
	list->size = 0;
	return list;
}

一、区别
1、单向链表：只有一个指向下一结点的指针，也就是只能next。
2、双向链表：除了有一个指向下一结点的指针外，还有一个指向前一结点的指针，可以通过prev()快速找到前一结点。
二、使用情况不同
1、单向链表：适用于节点的增加删除。
2、双向链表：适用于需要双向查找节点值的情况。
三、读取不同
1、单向链表：只能单向读取。
2、双向链表：可以双方向读取。

链表优于数组的有：
插入删除不需要移动元素，时间性能为O(1)
存储空间位置可以任意
存储空间大小不需要事先确定，也没有溢出