数据结构与算法学习笔记(C语言)
1.线性表的定义和抽象数据类型
1.线性表的定义:零个或多个数据元素的有限序列,当元素个数是零的时候,称为一个空表
特点:线性表中的元素只有唯一的“首元素”、“尾元素”,除了首、尾元素,其他元素有唯一的直接前驱和后继,首元素没有前驱,尾元素没有后继
2.线性表的抽象数据类型
ADT List {
数据对象:D = {a1, a2, a3, ...}
数据关系:R = {<a1, a2>, <a2,a3>, ...}
/*<a, b>表示a, b的有序对*/
基本操作:
InitList(*L)
/*初始化操作,构建一个空的线性表*/
ClearList(*L)
/*将一个线性表的元素清空*/
DestroyList(*L)
/*销毁线性表*/
ListLength(L)
/*返回线性表中元素的个数*/
GetElem(L, i, *e)
/*用e返回线性表L中第i个元素的值*/
LocateElem(L, e)
/*在线性表中查找与e值相等的元素*/
ListInsert(*L, i, e)
/*在L中第i个元素之前插入新的数据元素e*/
ListDelete(*L, i, *e)
/*删除L中第i个元素,并用e返回其值*/
ListTraverse(L)
/*遍历L中的数据元素*/
}ADT List
例如要合并线性表A和B,即把B中A不存在的元素插入A中
void union(List *La, List *Lb)
//挨个查找Lb中的元素,看是否在La中,若不在,插入之
{
int La_len, Lb_len;
int i; ElemType e;
La_len = ListLength(La);
Lb_len = ListLength(Lb);
for (i = 1; i <= Lb_len; i++) {
GetElem(Lb, i, &e);
/*取Lb中第i个数据元素赋给e*/
if (!LocateElem(La, e))
ListInsert(*La, ++La_len, e);
/*若e不在La中,插入之*/
}
}
分析:由于GetElem和ListInsert与表长无关,忽略GetElem和ListInsert所需的时间,需要遍历B中的元素,B中的每个元素都要与A中所有的元素比较,那么上述算法的时间复杂度为
O(ListLength(A) * ListLength(B))
2.线性表的顺序存储结构
1.定义:线性表的顺序存储结构,指的是用一段地址连续的存储单元依次存储线性表中的数据元素
在C语言中可以用一维数组来实现顺序存储结构
以下采用动态分配的一维数组
顺序存储结构的C语言代码如下
#define INIT_SIZE 100 //线性表存储空间初始分配量
#define INCREMENT 10 //线性表空间不够时,设定的分配增量
typedef int ElemType; //数据元素的数据类型,也可是char
typedef struct {
ElemType *elem; //存储数据元素的数组空间基址
int length; //线性表的当前长度
int listsize; //当前分配的存储容量
}SqList;
2.初始化操作
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int Status;
Status InitSqList(SqList *L)
/*构造一个空的线性表*/
{
L->elem = (ElemType *)malloc(INIT_SIZE * sizeof(ElemType));
/*为数据元素申请存储空间*/
if (!L->elem) exit(OVERLOW)
/*存储空间分配失败*/
L->length = 0;
/*设置空表长度为0*/
L->listsize = INIT_SIZE;
/*设置线性表的初始存储容量*/
return OK;
}
3.将一个线性表的元素清空
void ClearSqList(SqList *L)
{
L->length = 0;
/*长度置为0*/
}
4.销毁线性表
void DestroySqList(SqList*L)
{
free(L->elem);
/*将申请的内存释放掉*/
L->elem = NULL;
/*让指针指向NULL,这一步一定在free之后,
否则系统将找不到分配的空间而无法回收,造成内存泄露*/
L->length = 0;
/*线性表当前长度置零*/
L->listsize = 0;
/*内存已经释放,分配的容量置零*/
}
5.获取线性表的长度
int SqListLength(SqList L)
{
return L.length
}
6.获取线性表中第i个元素的值
Status GetElem(SqList L, int i, ElemType *e)
{
if (L.length = 0 || i < 1 || i > L.length)
/*L为空表或者i的值不合理*/
return ERROR;
*e = L.elem[i-1];
//elem[i]与*(elem + i)等价
return OK;
}
7.找出线性表中和e相等的元素
#define NOT_FOUND 0
int LocateElem(SqList L, ElemType e)
{
int i;
/*查找线性表中和e相等的元素,用i返回它的位置*/
for (i = 0; i < L.length; i++) {
if (L.elem[i] = e)
return i + 1;
}
return NOT_FOUND;
}
8.在线性表第i个位置之前插入元素
Status SqListInsert(SqList *L, int i, ElemType e)
{
int j; ElemType *new_elem;
if (i < 1 || i > L->length + 1) return ERROR;
/*插入位置不合理*/
if (L->length == INIT_SIZE) {
/*线性表当前存储空间已满,需要重新分配空间*/
new_elem = (ElemType *)realloc(L->elem, (L->listsize + INCREMENT) * sizeof(ElemType));
/*空间分配失败*/
if (!new_elem) exit(OVERFLOW);
/*新的空间基址*/
L->elem = new_elem;
/*存储容量增加*/
L->listsize += INCREMENT;
}
/*如果插入的位置不在表尾*/
if (i <= L->length) {
/*将要插入的位置之后的元素后移一位*/
for (j = L->length - 1; j >= i - 1; j--)
/*注意后移从后向前,不然前面的元素覆盖后面的元素*/
L->elem[j + 1] = L->elem[j];
}
/*将新元素插入*/
L->elem[i - 1] = e;
/*表长加一*/
L->length++;
return OK;
}
9.删除线性表第i个位置的元素
Status SqListDelete(SqList *L, int i, ElemType *e)
{
int j;
if (i < 1 || i > L->length) return ERROR;
/*删除位置不合理*/
if (L->length == 0) return ERROR;
/*空表无法执行删除操作*/
*e = L->elem[i - 1];
/*用e接收删除位置的元素*/
for (j = i; j <= L->length - 1; j++) {
/*将删除位置之后的元素全部前移一位*/
L->elem[j - 1] = L->elem[j];
}
L->length--;
/*删除后表长减一*/
return OK;
}
10.遍历线性表中的元素
void SqListTraverse(SqList L)
{
int i;
for (i = 0; i < L.length; i++) {
/*打印表中的元素,并以空格分隔*/
printf("%d ", L.elem[i]);
}
printf("\n");
return 0;
}
11.实例:将两个元素从小到大排列好的线性表合并,合并后的线性表元素依然非递减排列
算法一:
void MergeList(SqList La, SqList Lb, SqList *Lc)
{
int La_len, Lb_len;
int i = j = 1, k = 0;
ElemType *ai, *bj;
/*初始化线性表Lc*/
InitSqList(& Lc);
La_len = SqListLength(La); Lb_len = SqListLength(Lb);
while ((i <= La_len) && (j <= Lb_len)) {
/*若La, Lb非空,则分别从第一个元素开始,
依次获取La, Lb中的元素,分别放在ai, bj中*/
GetElem(La, i, &ai); GetElem(Lb, j, bj);
/*比较ai, bj的大小,将小的放入线性表Lc中*/
if (ai <= bj) {
/*若ai较小,那么将ai放入Lc中,递增计数变量i,
以获取La中的下一个元素*/
SqListInsert(&Lc, ++k, ai); ++i;
}
else {
/*若bj较小,那么将bj放入Lc中,递增计数变量j,
以获取Lb中的下一个元素*/
SqListInsert(&Lc, ++k, bj); ++j;
}
}//while
while (i <= La_len) {
//如果La中剩余元素,则将剩余元素插入Lc
GetElem(La, i++, &ai);
SqListInsert(&Lc, ++k, ai);
}
while (j <= Lb_len) {
//如果Lb中剩余元素,则将剩余元素插入Lc
GetElem(Lb, j++, &bj);
SqListInsert(&Lc, ++k, bj);
}
}
分析此算法,第一个while循环,依次取出La, Lb中的元素进行比较,执行的步骤数是较短的表长的2倍,当while循环结束时,其中较短的表的元素已经访问完了,下面的两个while循环只会执行一个,就是把较长的表的剩余元素依次插入Lc中,那么,时间复杂度为
O(ListLength(La) + ListLength(Lb))
算法二:
void MergeList(SqList La, SqList Lb, SqList *Lc)
{
ElemType *pa, *pb, *pc;
ElemType *pa_last, *pb_last;
/*分别让pa,pb, pc指向La, Lb, Lc元素的首地址*/
pa = La.elem; pb = Lb.elem;
/*另一种方法初始化Lc*/
Lc->listsize = Lc->length = La.length + Lb.length;
/*为Lc申请等于La + Lb表长的存储容量,恰好容纳La和Lb中所有的元素*/
pc = Lc->elem = (ElemType *)malloc(Lc->listsize * sizeof(ElemType));
if (!Lc->elem) exit(OVERFLOW);
//分别让pa_last, pb_last指向La, Lb元素的尾地址
pa_last = La.elem + La.length - 1;
pb_Last = Lb.elem + Lb.length - 1;
while (pa <= pa_last && pb <= pb_last) {
/*归并,将La, Lb中较小的元素插入Lc中*/
if (*pa <= *pb) *pc++ = *pa++;
else *pc++ = *pb++;
}
/*若La中有剩余元素,则插入之*/
while (pa <= pa_last) *pc++ = *pa++;
/*若Lb中有剩余元素,则插入之*/
while (pb <= pb_last) *pc++ = *pb++;
}
分析:这个算法其实和上一个算法本质相同,分别依次遍历La, Lb中的元素,插入其中较小的,然后将较长的表中剩余的元素插入,即完成合并,时间复杂度也是
O(ListLength(La) + ListLength(Lb))
与开篇归并乱序的线性表的算法相比
O(ListLength(La) + ListLength(Lb))相比于
O(ListLength(La) * ListLength(Lb))效率大幅度提升,
所以,执行归并线性表的操作,应该先对表中的元素进行排序!