数据结构第二天、线性表的链式表示和实现

　　今天是学习数据结构的第二天，让我们来一起重温数据结构中极为经典的链表。

　　在复习链表之前我们来复习一个C/C++中很重要的知识点

#include <stdio.h>
#include <stdlib.h>
typedef char ElemType;
typedef struct node
{
ElemType data;
struct node *next;
}LinkList;
void InitList(LinkList *L)//初始化单链表
{
L=(LinkList *)malloc(sizeof(LinkList));
L->next=NULL;
}
int main()
{
int i;
ElemType e;
LinkList *L;
InitList(L);
}

很多同学会说上述代码不就是完成链表初始化的一段代码吗，没有什么特殊的。其实，这段代码是会报错的。因为它根本没有初始化链表。

原因是InitList(L)实际上是对值的传递，和swap()函数的原理类似，传值调用传递的时原来数据的副本，副本是在栈上调用的，在函数执行完成后会自动释放，也没有返回到main函数的具体值，所以会失败。

正确方法是下面这种方法

#include <stdio.h>
#include <stdlib.h>
typedef char ElemType;
typedef struct node
{
ElemType data;
struct node *next;
}LinkList;
void InitList(LinkList **L)//初始化单链表
{
*L=(LinkList *)malloc(sizeof(LinkList));
(*L)->next=NULL;
}
int main()
{
int i;
ElemType e;
LinkList *L;
InitList(&L);
}

也就是传入指针的地址，即指针的指针。

在我的代码中，我才去了另外一种方法，即初始化函数返回时将指针赋值给main函数里的局部变量，这样也可以解决这种问题，具体代码如下：

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

typedef struct Node
{
int Data;
struct Node *Next;
} List;

//创建具有头结点的链表
List *CreateList(int n)
{
List *LinkList = (List *)malloc(sizeof(List));
LinkList->Next = NULL;

for (int i = n; i > 0; --i)
{
List *p = (List *)malloc(sizeof(List));
scanf("%d", &p->Data);
p->Next = LinkList->Next;
LinkList->Next = p;
}
return LinkList;
}

//添加
void Insert(List *LinkList, int n, int e)
{
List *p = LinkList;
int j = 0;

while (p && j < n-1) {
p = p->Next;
++j;
}

if (!p || j > n-1)
{
printf("Error\n");
return;
}

List *s = (List *)malloc(sizeof(List));
s->Data = e;
s->Next = p->Next;
p->Next = s;
return;
}

//删除
void Delete(List *LinkList, int n)
{
List *p = LinkList;
int j = 0;

while (p->Next && j < n-1) {
p = p->Next;
++j;
}

if (p->Next == NULL || j > n-1)
{
printf("Error\n");
return;
}

List *q = p->Next;
p->Next = q->Next;

free(q);
return;
}

//已知单链线性表La和Lb的元素按值非递减排列
//归并La和Lb得到新的单链线性表Lc，Lc也按值非递减排列
List *MergeList(List *la, List *lb)
{
List *pa = la->Next;
List *pb = lb->Next;
List *lc = la;
List *pc = lc;
while (pa && pb) {
if (pa->Data <= pb->Data)
{
pc->Next = pa;
pc = pa;
pa = pa->Next;
} else {
pc->Next = pb;
pc = pb;
pb = pb->Next;
}
}
pc->Next = pa?pa:pb;
free(lb);
return la;
}

//遍历
void Traverse(List *LinkList)
{
List *q = LinkList->Next;

while (q != NULL) {
printf("%d\n", q->Data);
q = q->Next;
}
return;
}

int main(int argc, char const *argv[])
{
List *list_link;
list_link =  CreateList(4);
printf("输出创建的链表\n");
Traverse(list_link);
//printf("%d\n", list_link->Next->Data);
printf("输出删除具体节点后的链表\n");
Delete(list_link, 2);
Traverse(list_link);

printf("输出la，lb归并后的链表测试\n");
List *la, *lb, *lc;
printf("请输入la链表\n");
la = CreateList(3);
printf("请输入lb链表\n");
lb = CreateList(4);
lc = MergeList(la, lb);
Traverse(lc);
return 0;
}

Insert()和Delete()的时间复杂度也都是O(n)量级的。

还有一个要主要的点是在做MergeList(归并操作)时，Lc链表只是将La和Lb链表中的节点重新链接在一起了，没有重新malloc空间。