异质链表（C语言实现）

　　用C语言实现多态性的基本思想是使用void*指针，在存储链表结点值的时候将地址存入。

　　也就是说结点中存储的值并不是具体的值，而是一个地址，由于这个地址是main中的本地变量，所以不用担心它会被摧毁。

　　在读取的时候，进行强制类型转换即可。

　　在老师布置异质链表作业的时候，参考了网上很多代码，基本上都是通过传入类型，再在函数内部进行链表创建。这样的写法对于main函数依赖很大，无法实现函数的模块化（也就是说它不能独立存在，必须依赖main函数），个人感觉并不是那么可取。而且链表的值必须通过用户动态输入得到，局限性较大，无法实现传入已有的值。在这一块卡了很久，也查了非常多资料，尤其是void*相关的知识。

　　不过对于头结点的处理比较麻烦，因为传入链表的时候只能拷贝一个指针，对拷贝的指针进行修改，比如加入头结点，并不会影响到原链表。这时候必须强制用户用返回值来接收新得到的链表指针，或者还有一种解决办法是传入指向链表指针的指针，但是这样也要强迫用户传入指向链表指针的指针。总之非常麻烦，这个问题暂时还没有完美解决。在C++中就很简单，传入引用就可以了。

/* @fish1996 2015/09/30     */
/* 数字媒体技术1402*/

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

enum{Char,Double,Int};

/*链表的声明*/
typedef struct ListNode{
void *data;
int type;
struct ListNode *next;
}*List;

/*得到链表的长度*/
int Length(List PtrL);

/*创建一个空链表*/
List Create();

/*在表头插入*/
List InsertFro(void *x,int type,List PtrL);

/*在第k个位置插入*/
List InsertKth(void *x,int k,int type,List PtrL);

/*在表尾插入*/
List InsertBack(void *x,int type,List PtrL);

/*查找第k个元素*/
List FindKth(int k,List PtrL);

/*查找值为x的元素,返回下标*/
int FindXIndex(void *x,int type,List PtrL);

/*查找值为x的元素,返回节点*/
List FindXNode(void *x,int type,List PtrL);

/*删除链表头*/
List DeleteFro(List PtrL);

/*删除下标为k的元素*/
List DeleteKth(int k,List PtrL);

/*删除值为x的元素*/
List Delete(void *x,List PtrL);

/*遍历链表输出*/
void Print(List PtrL);

/*链表销毁*/
List Destroy(List PtrL);

/*两个链表的合并*/
List Union(List p,List s);

/*链表的逆置*/
List Reverse(List p);

/* 创建一个空的链表                                  */

List Create()
{
List L = NULL;  /*设立指向NULL的指针*/
return L;
}

/* 计算链表长度                                      */

int Length(List PtrL)
{
int length=0;
List p=PtrL;
while(p){  /*从第一个结点开始移动指针位置计算长度*/
p=p->next;
length++;
}
return length;
}

/* 在表头插入                                        */

/* 使用说明：                                        */
/* 要得到插入表头的链表，只能在返回值中得到          */
/* 因为这里没有传指向指针的指针，原指针并没有被改变  */
/* 传入的是元素x的地址,所以必须是明确定义且赋值的变量*/
/* correct: p=InsertFro(&x,Int,p);                   */
/* error: p=InsertFro(x,Int,p);                      */
/* error: InsertFro(&x,Int,p);                       */
/* error：p=InsertFro(1,Int,p)                       */

List InsertFro(void *x,int type,List PtrL)
{
List p; /*申请结点内存并赋值*/
p=(List)malloc(sizeof(struct ListNode));
p->data=x;/*data指针等于x指针*/
p->type=type;/*存储类型*/
p->next=PtrL;/*让该结点指向原链表*/
return p;
}

/* 在第k个位置插入                                    */

/* 使用说明：                                         */
/* 要得到插入表头的链表，即k=1时，只能在返回值中得到  */
/* 因为这里没有传指向指针的指针，原指针并没有被改变   */
/* 其余情况可以不使用返回值                           */
/* 传入的是元素x的地址,所以必须是明确定义且赋值的变量 */
/* correct: p=InsertKth(&x,1,Int,p);                  */
/* correct: p=InsertKth(&x,2,Int,p);                  */
/* correct: InsertKth(&x,2,Int,p);                    */
/* error: p=InsertKth(x,1,Int,p);                     */
/* error: InsertKth(&x,1,Int,p);                      */
/* error：p=InsertKth(1,1,Int,p)                      */

List InsertKth(void *x,int k,int type,List PtrL)
{
List p,s;
int length;
if(k==1)return InsertFro(&x,type,PtrL);
/*k=1调用已有函数，实现代码重用*/
p=FindKth(k-1,PtrL);/*找到要删除结点的上一个结点*/
if(!p){
printf("Error: illegal index\n");
return PtrL;
}/*不存在上一个结点*/
s=(List)malloc(sizeof(struct ListNode));/*为插入元素分配内存*/
s->next=p->next;/*先让新结点指向它前一个元素的下一个元素*/
p->next=s;/*再让前一个元素指向新节点*/
s->data=x;/*data指针等于x指针*/
s->type=type;/*存储类型*/
return PtrL;
}

/*在表尾插入                                          */

/* 使用说明：                                         */
/* 可以不使用返回值                                   */
/* 传入的是元素x的地址,所以必须是明确定义且赋值的变量 */
/* correct: p=InsertBack(&x,Int,p);                   */
/* correct: InsertBack(&x,Int,p);                     */
/* error: p=InsertBack(x,Int,p);                      */
/* error：p=InsertBack(1,Int,p)                       */

List InsertBack(void *x,int type,List PtrL)
{
int k=Length(PtrL); /*得到链表长度*/
return InsertKth(x,k+1,type,PtrL); /*调用已有函数，实现代码重用*/
}

/* 查找第k个元素，返回结点                            */

/* 使用说明：                                         */
/* correct: s=FindKth(2,p);                           */

List FindKth(int k,List PtrL)
{
List p=PtrL;
int count=1;
while(count!=k&&p){/*当下标不为k并且p不为NULL*/
p=p->next; /*移动结点*/
count++; /*记录当前下标*/
}
if(!p){
printf("Error: Not found\n");
}
return p;
}

/*查找值为x的元素,返回下标                            */

/* 使用说明：                                         */
/* 由于void*的限制，该函数实现功能较差                */
/* 传入的是元素x的地址,所以必须是明确定义且赋值的变量 */
/* 所以在传入特定值的时候必须先将其定义               */
/* correct: index=FindXIndex(&x,Int,p);               */
/* error：index=FindXIndex(1,Int,p)                   */

int FindXIndex(void *x,int type,List PtrL)
{
int count=1;/*记录当前下标*/
List p=PtrL;
switch(type){ /*选择类型执行对应操作*/
case Int:
while(p&&(*(int*)p->data!=*(int*)x||p->type!=Int)){
/*判断p是否为空，值是否相等，类型是否匹配*/
p=p->next;
count++;
}
break;
case Double:
while(p&&(*(double*)p->data!=*(double*)x||p->type!=Double)){
p=p->next;
count++;
}
break;
case Char:
while(p&&(*(char*)p->data!=*(char*)x||p->type!=Char)){
p=p->next;
count++;
}
break;
}
if(!p){
printf("Error: Not found\n");
return 0;
}
return count;
}

/*查找值为x的元素,返回结点                            */

/* 使用说明：                                         */
/* 由于void*的限制，该函数实现功能较差                */
/* 传入的是元素x的地址,所以必须是明确定义且赋值的变量 */
/* 所以在传入特定值的时候必须先将其定义               */
/* correct: p=FindXNode(&x,Int,p);                    */
/* error：p=FindXNode(1,Int,p)                        */

List FindXNode(void *x,int type,List PtrL)
{
List p;
int index;
index=FindXIndex(&x,type,PtrL);/*调用已有函数，实现代码重用*/
if(index==0)return NULL;
p=FindKth(index,PtrL);
return p;
}

/*删除链表头                                          */

/* 使用说明：                                         */
/* 要使用返回值得到删除链表头的链表                   */
/* 因为这里没有传指向指针的指针，原指针并没有被改变   */
/* correct: p=DeleteFro(p);                           */
/* error：DeleteFro(p)；                              */

List DeleteFro(List PtrL)
{
List s=PtrL;/*记录表头位置*/
if(PtrL)PtrL=PtrL->next;/*如果链表不为空，向后移动一位*/
else return PtrL;
free(s); /*释放表头空间*/
return PtrL; /*返回删除表头的链表*/
}

/*删除下标为k的元素                                   */

/* 使用说明：                                         */
/* k=1时要使用返回值                                  */
/* 其余可以使用返回值，也可以不使用                   */
/* correct: p=DeleteKth(2,p);                         */
/* correct：DeleteKth(2,p)；                          */
/* error: DeleteKth(1,p);                             */

List DeleteKth(int k,List PtrL)
{
List p,s;
if(k==1)return DeleteFro(PtrL);/*调用已有函数，实现代码重用*/
p=FindKth(k-1,PtrL);/*找到要删除结点的前一个结点*/
if(p==NULL||p->next==NULL){
printf("Error: illegal index\n");
return PtrL;
}
/*如果要删除结点或前一个结点不存在，返回原链表*/
s=p->next;/*s指向待删除结点*/
p->next=s->next;/*待删除结点前一个结点指向待删除结点下一个结点*/
free(s); /*释放待删除结点空间*/
return PtrL;
}

/*删除链尾                                            */

/* 使用说明：                                         */
/* 可以使用返回值，也可以不使用                       */
/* correct: p=DeleteBack(p);                          */
/* correct：DeleteBack(p)；                           */

List DeleteBack(List PtrL)
{
List p;
int len=Length(PtrL);
return DeleteKth(len,PtrL);
}

/*遍历链表输出                                        */

/* 使用说明：                                         */
/* correct: Print(p);                                 */

void Print(List PtrL)
{
List p=PtrL;
while(p){
/*根据类型做对应的输出*/
switch(p->type){
case Int:
printf("%d ",*(int*)p->data);
break;
case Char:
printf("%c ",*(char*)p->data);
break;
case Double:
printf("%lf ",*(double*)p->data);
break;
}
p=p->next;/*移动指针位置*/
}
printf("\n");
}

/*只输出当前结点的值                                  */

/* 使用说明：                                         */
/* correct: PrintNow(p);                              */

void PrintNow(List PtrL)
{
List p=PtrL;
if(p){
/*根据类型做对应的输出*/
switch(p->type){
case Int:
printf("%d ",*(int*)p->data);
break;
case Char:
printf("%c ",*(char*)p->data);
break;
case Double:
printf("%lf ",*(double*)p->data);
break;
}
}
printf("\n");
}

/* 链表销毁                                           */

/* 使用说明：                                         */
/* 要得到销毁后的链表，需要使用返回值                 */
/* 因为这里没有传指向指针的指针，原指针并没有被改变   */
/* correct: p=Destroy(p);                             */
/* error: Destroy(p);                                 */

List Destroy(List PtrL)
{
List q,p=PtrL;
while(p){
q=p->next;/*记录p的下一个结点位置*/
free(p);/*释放p的内存空间*/
p=q;/*p指向下一个结点*/
}
return p;
}

/* 两个链表的合并                                     */

/* 使用说明：                                         */
/* 按第一个链表在前，第二个链表在后的顺序合并         */
/* 要得到合并后的链表，需要使用返回值                 */
/* 因为这里没有传指向指针的指针，原指针并没有被改变   */
/* correct: p=Union(p1,p2);                           */
/* correct: p1=Union(p1,p2);                          */
/* error: Union(p1,p2)                                */

List Union(List PtrL1,List PtrL2)
{
List p;
int len;
len=Length(PtrL1);/*得到第一个链表长度*/
p=FindKth(len,PtrL1);/*得到第一个链表的尾结点*/
p->next=PtrL2;/*让第一个链表的尾结点指向第二个链表的头结点*/
return PtrL1;
}

/* 链表的逆置                                         */

/* 使用说明：                                         */
/* 要得到逆序后的链表，需要使用返回值                 */
/* 因为这里没有传指向指针的指针，原指针并没有被改变   */
/* correct: p=Reverse(p);                             */
/* error: Reverse(p)                                  */

List Reverse(List PtrL)
{
List now,next,prev,head,tmp;
if(!PtrL)return PtrL;
next=PtrL;/*next指向第一个元素*/
now=next->next; /*now指向第二个元素*/
next->next=NULL;/*因为next将会是最后一个结点，将其下一个结点设为NULL*/
while(now){
prev=now->next;/*记录now的下一轮循环的位置*/
now->next=next;/*逆序过程，让后一个结点指向前一个结点*/
next=now;/*next向后移一位*/
now=prev;/*now向后移一位*/
}
return next;
}

int main()
{
List p=Create();
List l=Create();
int u=1996;
int x=1;
int y=1;
char t='b';
double d=0.1;
char a='a';

l=InsertFro(&u,Int,l);

printf(">> Insert element 1 in front of the list：\n");
p=InsertFro(&x,Int,p);
Print(p);
printf("\n");

printf(">> Insert element b with index 2：\n");
InsertKth(&t,2,Char,p);
Print(p);
printf("\n");

printf(">> Insert element 0.1 at the back of the list：\n");
InsertBack(&d,Double,p);
Print(p);
printf("\n");

printf(">> The length of the list:\n%d\n",Length(p));
printf("\n");

printf(">> Find the index of element a in the list:\n");
printf("%d\n",FindXIndex(&a,Char,p));
printf("\n");

printf(">> Delete element with index 6:\n");
DeleteKth(6,p);
printf("\n");

printf(">> Insert element 1 with index 5:\n");
InsertKth(&x,5,Int,p);
printf("\n");

p=Reverse(p);
printf(">> After reverse:\n");
Print(p);
printf("\n");

List q=FindKth(2,p);
printf(">> The second element of the list is:\n");
PrintNow(q);
printf("\n");

printf(">> The index of the value 1 is:\n");
printf("%d\n",FindXIndex(&y,Int,p));
printf("\n");

printf(">> Found the element with index 4:\n");
FindKth(4,p);
printf("\n");

p=Union(p,l);
printf(">> After connect two lists:\n");
Print(p);
printf("\n");

p=DeleteFro(p);
printf(">> Delete the first element：\n");
Print(p);
printf("\n");

DeleteKth(2,p);
printf(">> Delete element with index 2：\n");
Print(p);
printf("\n");

DeleteBack(p);
printf(">> Delete the last element：\n");
Print(p);
printf("\n");

p=Destroy(p);
printf(">> After destroy：\n");
Print(p);
printf("\n");

return 0;
}