数据结构自学笔记(C语言)基本概念及顺序线性表

程序员等于数据结构加算法，之前对数据结构有一定程度的了解，但是想成为一名程序员，这点了解还远远不够，所以决定从头系统的学习一遍数据结构。在选择语言上也纠结了一段时间，现在在高级语言太多了，Python、C++ 、Java，都考虑过，但在知乎上看见一些大牛说的很有道理，高级语言之所以高级，就是把很多底层的东西替你做好了，你只有用最原始最低级的C语言去学数据结构才能真正的体会到数据结构底层的东西，所以我也决定使用C语言去学习数据结构，后期刷算法题的时候再用高级语言。

基本概念和术语

数据项：数据项是数据的不可分割的最小单位
数据元素：是数据的基本单位，在程序中通常作为一个整体进行考虑和处理，如图的圆圈， 一个数据元素可由若干数据项组成
数据对象：是性质相同的数据元素的组合，是数据的一个子集
数据结构：是相互之间存在一种或多种关系的数据元素的集合 ，数据元素都不是独立存在的，通常有四种基本结构：集合、线性关系、图状结构、网状结构。数据结构的形式定义为：Data_Structure = (D,S)D是数据元素，S是D中个体的关系。数据结构在计算机中的表示称为数据的物理结构（又称存储结构）
位：最小单位是二进制的一位，一个16进制有4位，一个字节有两个16进制数，也就是8位，数据类型的大小都是通过字节来描述的
存储结构：计算机中根据元素之间的表示方法（顺序映像、非顺序映像）得到两种不同的存储结构:顺序存储结构、链式存储结构。非顺序映像需要借助指针。
数据类型：数据类型可以分成两类：1、非结构的原子类型，如基本类型（整型、字符型、枚举）、指针类型、空类型。2、结构类型，如数组
抽象数据类型ADT：是指一个数学模型以及定义在该模型上的一组操作。抽象数据类型和数据类型实质是一个概念，整型是一个抽象数据类型，尽管在不同处理器上实现的方法不同，但数学特性相同。
算法：是对特定为题求解步骤的一种描述，是指令的有限序列，具有5个重要特性：有穷性、确定性、可行性、输入、输出
线性表：是n个数据元素的有限序列，每个数据元素都有一个确定的位置，即数据元素之间存在线性关系。若是顺序存储结构，则该表为顺序表；若是链式存储结构，则是链表
结构体因为在数据结构中会大量使用结构体，所以提一下。结构体的本质就是物理连续的线性数据结构，为了方便寻址，一般以其本身数据类型的字节长度为基本单位对齐。在函数中结构体通常可以通过&L和*L的方式作为参数传入，前者传入的是结构体指针，后者传入的是结构体地址。对结构体赋值，前者使用.后者使用->。如果需要在函数中改变结构体值，必须采用指针传递的方式。因为调用子函数是开辟了一个栈，如果传入结构体，那么其实是在栈中传入一个结构体副本，改变了值，等子程序跑完了，副本被释放，原来的结构体并没有改变。所以必须使用结构体指针的方式。下面写个小程序验证一下

#include<stdio.h>//printf函数
#include<stdlib.h>//malloc函数
#define LIST_SIZE 100//初始分配量
#define LIST_INCREMENT 10//每次增量
typedef struct{
	int* data;
	int length;
	int listsize;
}seqlist;
int InitList(seqlist *L)
{
	L->data = (int *)malloc(sizeof(int)*LIST_SIZE);
	if (L->data == NULL)
		return -1;
	L->length = 1;
	L->listsize = LIST_SIZE;
	printf("initial finish\n");
	return 0;
}

int InitList1(seqlist L)
{
	L.data = (int *)malloc(sizeof(int)*LIST_SIZE);
	if (L.data == NULL)
		return -1;
	L.length = 2;
	L.listsize = LIST_SIZE;
	printf("initial finish\n");
	return 0;
}

int main()
{
	seqlist L;
	seqlist* L1;
	L1 = &L;
	L.length = 0;
	InitList(L1);
	InitList1(L);
}

在程序中分别通过传入结构体和传入结构体指针的方式改变length值，结构体初始化为0，传入结构体指针改为1，传入结构体改为2，最后程序运行万length值为1，证明了上面的说法。

顺序线性表程序

数据结构第一个接触的程序，就是顺序（sequence）线性表的创建、添加、删除、插入、指定位置删除。还是比较简单的，大概思路就是先建立一个线性表结构体，里面包括三个信息：线性表数据元素类型指针、线性表数据元素个数、线性表长度。在创建时需要通过malloc函数为线性表先开辟一段空间，当不断插入或者添加的过程中如果发现空间不够，需要通过realloc函数继续申请空间。下面是创建、添加和插入的程序，删除和指定位置删除的程序一样的，大家可以自己试着写一下。需要注意的就是length是先加还是后加，判断空间不够时，比较方式是等于还是大于等于，需要自己画一画，思考一下。程序需要有健壮性，在异常操作时，比如插入位置比当前数据元素还要多，应该返回一个值来提醒我们是哪里出错了。

#include<stdio.h>//printf函数
#include<stdlib.h>//malloc函数
#define LIST_SIZE 20//初始分配量
#define LIST_INCREMENT 10//每次增量
typedef struct{
	int *data;
	int length;
	int listsize;
}Seqlist;

int InitList(Seqlist *L)
{
	L->data = (int *)malloc(sizeof(int)*LIST_SIZE);
	if (L->data == NULL)
		return -1;//分配失败
	L->length = 0;
	L->listsize = LIST_SIZE;
	printf("initial finish\n");
	return 0;
}

int ListAdd(Seqlist *L, int e)
{
	int *newbase;
	if((L->length+1)>L->listsize)
	{
		newbase = (int*)realloc(L->data,(L->listsize+LIST_INCREMENT)*sizeof(int));
		if(!newbase)
			return -1;
		L->data = newbase;
		L->listsize+=LIST_INCREMENT;
	}
	L->data[L->length]= e;
	L->length++;
	return 1;
}

int ListInsert(Seqlist *L,int i, int e)
{
	int *newbase;
	int *q;//插入位置
	int *p;
	if(i<1 || i>L->length+1)//最大插在队尾
		return -1;
	if(L->length>=L->listsize)
	{
		newbase = (int*)realloc(L->data,(L->listsize+LIST_INCREMENT)*sizeof(int));
		if(!newbase)
			return -1;
		L->data = newbase;
		L->listsize+=LIST_INCREMENT;
	}
	q = &(L->data[i-1]);
	for(p = &(L->data[L->length-1]);p>=q;p--)
		*(p+1)= *p;
	*q = e;
	L->length++;
	return 1 ;

}

int main()
{
	int i = 0;
	Seqlist L;
	Seqlist *L1 = &L;
	InitList(L1);
	for(i = 0;i<40;i++)
	{
		ListAdd(L1,i+1);
	}
	ListInsert(L1,1,111);
	for(i = 0;i<L1->length;i++)
	{
		printf("%d\n",L1->data[i]);
	}
}

在上面程序的基础上又加大了点难度，写了一个合并两个顺序线性表的程序。默认这两个表是从小到大排列的，要求合并后还是从小到大排列的。

#include<stdio.h>//printf函数
#include<stdlib.h>//malloc函数
#define LIST_SIZE 20//初始分配量
#define LIST_INCREMENT 10//每次增量
typedef struct{
	int *elem;//线性表数据指针
	int length;//线性表数据元素数量
	int listsize;//线性表表长
}Seqlist;//sequence顺序的意思

int InitList(Seqlist *L)//线性表初始化
{
	L->elem = (int *)malloc(sizeof(int)*LIST_SIZE);
	if (L->elem == NULL)
		return -1;//分配失败
	L->length = 0;
	L->listsize = LIST_SIZE;
	printf("initial finish\n");
	return 0;
}

int ListAdd(Seqlist *L, int e)//线性表添加数据元素
{
	int *newbase;
	if((L->length+1)>L->listsize)
	{
		newbase = (int*)realloc(L->elem,(L->listsize+LIST_INCREMENT)*sizeof(int));
		if(!newbase)
			return -1;
		L->elem = newbase;
		L->listsize+=LIST_INCREMENT;
	}
	L->elem[L->length]= e;
	L->length++;
	return 1;
}

int ListMerge(Seqlist *L1,Seqlist *L2,Seqlist *L3)//合并顺序线性表
{
	int *p1 = L1->elem;
	int *p2 = L2->elem;
	int *p1_last = p1+L1->length-1;
	int *p2_last = p2+L2->length-1;
	int *p3 = L3->elem;
	L3->listsize = L3->length = L1->length+L2->length;
	p3 = (int*)realloc(L3->elem,L3->listsize*sizeof(int));
	while(p1<=p1_last && p2<=p2_last)
	{
		if(*p1<*p2) *p3++=*p1++;
		else *p3++=*p2++;
	}
	while(p1<=p1_last)*p3++=*p1++;
	while(p2<=p2_last)*p3++=*p2++;
}
int main()
{
	int i = 0;
	Seqlist a,b,c;
	Seqlist *L1 = &a;
	Seqlist *L2 = &b;
	Seqlist *L3 = &c;
	InitList(L1);
	InitList(L2);
	InitList(L3);
	for(i = 0;i<40;i++)
	{
		ListAdd(L1,2*i+1);
		ListAdd(L2,2*i+2);
	}
	ListMerge(L1,L2,L3);
	for(i = 0;i<L3->length;i++)
	{
		printf("%d\n",L3->elem[i]);
	}
}

*p3++=*p1++这句话是当年学过C语言的同学都头通过的语法，其实现在好好想想其实也没那么难。 *p3代表指针p3指向的内容，p3代表p3指向内容的地址，++的优先级虽然很高，但是后置++的意思就是这句话都运行完了再执行++运算。所以这个语法等价于：
*p3 = *p1;p1++;p3++;
C语言运算优先表贴上来，需要的时候拿来看一下。相同优先级中，按结合性进行结合。大多数运算符结合性是从左到右，只有三个优先级是从右至左结合的，它们是单目运算符、条件运算符、赋值运算符。

顺序线性表大概就这些了，其实概念性的东西并不多，但是在写程序的时候总会有自己想不到的地方，尤其是在指针的使用上。不断改正程序的过程其实还是很有用的，下一篇就是链式顺序表了，有想一起学习的同学可以一起讨论下，欢迎批评指正。