/*国嵌版的，采用代码复用的思想*/
#ifndef _LINKLIST_H_
#define _LINKLIST_H_
typedef void LinkList;
typedef struct _tag_LinkListNode LinkListNode;
struct _tag_LinkListNode
{
LinkListNode* next; /*Linuxn内核中主要就是此类做法*/
};
LinkList* LinkList_Create();
void LinkList_Destroy(LinkList* list);
void LinkList_Clear(LinkList* list);
int LinkList_Empty(LinkList* list);
int LinkList_Length(LinkList* list);
int LinkList_Insert(LinkList* list, LinkListNode* node, int pos);
LinkListNode* LinkList_Get(LinkList* list, int pos);
LinkListNode* LinkList_Delete(LinkList* list, int pos);
#endif
#include <stdio.h>
#include <malloc.h>
#include "LinkList.h"
typedef struct _tag_LinkList
{
LinkListNode header;
int length;
} TLinkList;
LinkList* LinkList_Create()
{
TLinkList* ret = (TLinkList*)malloc(sizeof(TLinkList));
if(ret != NULL)
{
ret->header.next = NULL;
ret->length = 0;
}
return ret;
}
void LinkList_Destroy(LinkList* list)
{
free(list);
}
void LinkList_Clear(LinkList* list)
{
TLinkList* slist = (TLinkList*)list;
if(slist != NULL)
{
slist->header.next = NULL;
slist->length = 0;
}
}
int LinkList_Empty(LinkList* list)
{
TLinkList* slist = (TLinkList*)list;
int ret = 0;
if((slist != NULL) && (slist->length == 0))
{
ret = 1;
}
return ret;
}
int LinkList_Length(LinkList* list)
{
TLinkList* slist = (TLinkList*)list;
int ret = -1;
if(slist != NULL)
{
ret = slist->length;
}
return ret;
}
int LinkList_Insert(LinkList* list, LinkListNode* node, int pos)
{
TLinkList* slist = (TLinkList*)list;
int i = 0;
int ret = (slist != NULL) && (0 <= pos);
if(ret)
{
LinkListNode* current = (LinkListNode*)slist;
for(i=0;(i < pos) && (current->next != NULL);i++)
{
current = current->next;
}
node->next = current->next;
current->next = node;
slist->length++;
}
return ret;
}
LinkListNode* LinkList_Get(LinkList* list, int pos)
{
TLinkList* slist = (TLinkList*)list;
LinkListNode* ret = NULL;
int i = 0;
if((0 <= pos) && (pos < slist->length))
{
LinkListNode* current = (LinkListNode*)slist;
for(i=0;i<pos;i++)
{
current = current->next;
}
ret = current->next;
}
return ret;
}
LinkListNode* LinkList_Delete(LinkList* list, int pos)
{
TLinkList* slist = (TLinkList*)list;
LinkListNode* ret = NULL;
int i = 0;
if((slist != NULL) && (0 <= pos) && (pos < slist->length))
{
LinkListNode* current = (LinkListNode*)slist;
for(i=0;i<pos;i++)
{
current = current->next;
}
ret = current->next;
current->next = ret->next;
slist->length--;
}
return ret;
}
#include <stdio.h>
#include <stdlib.h>
#include "LinkList.h"
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
typedef struct value
{
LinkListNode header; /*一定要包含结点结构体，这种是Linux内核链表主要采用的思想*/
char c;
} DataElem;
int main(int argc, char *argv[])
{
LinkList* list = LinkList_Create();
DataElem v1,v2,v3,v4,v5,v6;
v1.c = 'a';
v2.c = 'b';
v3.c = 'c';
v4.c = 'd';
v5.c = 'e';
v6.c = 'f';
int i = 0;
LinkList_Insert(list,(LinkListNode*)&v1,0);
LinkList_Insert(list,(LinkListNode*)&v2,0);
LinkList_Insert(list,(LinkListNode*)&v3,0);
LinkList_Insert(list,(LinkListNode*)&v4,0);
LinkList_Insert(list,(LinkListNode*)&v5,0);
LinkList_Insert(list,(LinkListNode*)&v6,0);
for(i=0;i<LinkList_Length(list);i++)
{
DataElem* p = (DataElem*)LinkList_Get(list,i);
printf("the element is %c\n",(*p).c);
}
printf("the length is %d\n",LinkList_Length(list));
printf("\n");
while(LinkList_Length(list) > 0)
{
DataElem* p = (DataElem*)LinkList_Delete(list,LinkList_Length(list)-1);
printf("the element is %c\n",(*p).c);
}
LinkList_Clear(list);
printf("LinkList is Empty(%d)\n",LinkList_Empty(list));
LinkList_Destroy(list);
return 0;
}
/*大话数据结构版修改*/
#include "stdio.h"
#include "string.h"
#include "ctype.h"
#include "stdlib.h"
#include "io.h"
#include "math.h"
#include "time.h"
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 20 /* 存储空间初始分配量 */
typedef int Status;/* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int ElemType;/* ElemType类型根据实际情况而定，这里假设为int */
Status visit(ElemType c)
{
printf("%d ",c);
return OK;
}
typedef struct Node
{
ElemType data;
struct Node *next;
}Node;
typedef struct Node *LinkList; /* 定义LinkList */
/* 初始化顺序线性表 */
Status InitList(LinkList *L)
{
*L=(Node*)malloc(sizeof(Node)); /* 产生头结点,并使L指向此头结点 */
if((*L) == NULL) /* 存储分配失败 */
return ERROR;
(*L)->next=NULL; /* 指针域为空 */
return OK;
}
/* 初始条件：顺序线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE */
Status ListEmpty(LinkList L)
{
if(L->next)
return FALSE;
else
return TRUE;
}
/* 初始条件：顺序线性表L已存在。操作结果：将L重置为空表 */
Status ClearList(LinkList *L)
{
LinkList p,q;
p=(*L)->next; /* p指向第一个结点 */
while(p) /* 没到表尾 */
{
q=p->next;
free(p);
p=q;
}
(*L)->next=NULL; /* 头结点指针域为空 */
return OK;
}
/* 初始条件：顺序线性表L已存在。操作结果：返回L中数据元素个数 */
int ListLength(LinkList L)
{
int i=0;
Node* p=L->next; /* p指向第一个结点 */
while(p)
{
i++;
p=p->next;
}
return i;
}
/* 初始条件：顺序线性表L已存在，0≤i<ListLength(L) */
/* 操作结果：用e返回L中第i个数据元素的值 */
Status GetElem(LinkList L,int pos,ElemType *e)
{
int i;
if(0 <= pos && pos<ListLength(L))
{
Node *current = L->next;
for(i=0; i< pos && current->next != NULL ;i++)
{
current = current->next;
}
*e = current->data;
return OK;
}
return ERROR;
}
/* 初始条件：顺序线性表L已存在 */
/* 操作结果：返回L中第1个与e满足关系的数据元素的位序。 */
/* 若这样的数据元素不存在，则返回值为-1*/
int LocateElem(LinkList L,ElemType e)
{
int i=0;
Node *current = L->next;
while(current)
{
if(current->data==e) /* 找到这样的数据元素 */
return i;
current=current->next;
i++;
}
return -1;
}
/* 初始条件：顺序线性表L已存在,0≤i<ListLength(L)， */
/* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */
Status ListInsert(LinkList *L,int pos,ElemType e)
{
int i;
if(0 <= pos && L!=NULL)
{
Node *current = *L; /*current是头结点,指向第0个节点*/
if(pos>=ListLength(*L))
{
pos = ListLength(*L);
}
for(i=0; i< pos && current->next != NULL ;i++)
{
current = current->next;
}
Node *Next = current->next;
Node *s = (Node*)malloc(sizeof(Node));
s->data = e;
s->next = Next;
current->next = s;
return OK;
}
return ERROR;
}
/* 初始条件：顺序线性表L已存在，0≤i<ListLength(L) */
/* 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 */
Status ListDelete(LinkList *L,int pos,ElemType *e)
{
int i;
if(0 <= pos && pos < ListLength(*L)&& L!=NULL && e != NULL)
{
Node *current = *L; /*current是头结点,指向第0个节点*/
for(i=0; i< pos && current->next != NULL ;i++)
{
current = current->next;
}
Node *Next = current->next;
*e = Next->data;
current->next = Next->next;
free(Next);
return OK;
}
return ERROR;
}
/* 初始条件：顺序线性表L已存在 */
/* 操作结果：依次对L的每个数据元素输出 */
Status ListTraverse(LinkList L)
{
LinkList p=L->next;
while(p)
{
visit(p->data);
p=p->next;
}
printf("\n");
return OK;
}
#if 1
/* 随机产生n个元素的值，建立带表头结点的单链线性表L（头插法） */
void CreateListHead(LinkList *L, int n)
{
LinkList p;
int i;
srand(time(0)); /* 初始化随机数种子 */
*L = (LinkList)malloc(sizeof(Node));
(*L)->next = NULL; /* 先建立一个带头结点的单链表 */
for (i=0; i<n; i++)
{
p = (LinkList)malloc(sizeof(Node)); /* 生成新结点 */
p->data = rand()%100+1; /* 随机生成100以内的数字 */
p->next = (*L)->next;
(*L)->next = p; /* 插入到表头 */
}
}
/* 随机产生n个元素的值，建立带表头结点的单链线性表L（尾插法） */
void CreateListTail(LinkList *L, int n)
{
LinkList p,r;
int i;
srand(time(0)); /* 初始化随机数种子 */
*L = (LinkList)malloc(sizeof(Node)); /* L为整个线性表 */
r=*L; /* r为指向尾部的结点 */
for (i=0; i<n; i++)
{
p = (Node *)malloc(sizeof(Node)); /* 生成新结点 */
p->data = rand()%100+1; /* 随机生成100以内的数字 */
r->next=p; /* 将表尾终端结点的指针指向新结点 */
r = p; /* 将当前的新结点定义为表尾终端结点 */
}
r->next = NULL; /* 表示当前链表结束 */
}
#endif
int main()
{
LinkList L;
ElemType e;
Status i;
int j,k;
i=InitList(&L);
printf("初始化L后：ListLength(L)=%d\n",ListLength(L));
for(j=1;j<=5;j++)
i=ListInsert(&L,0,j);
printf("在L的表头依次插入1～5后：L.data=");
ListTraverse(L);
printf("ListLength(L)=%d \n",ListLength(L));
i=ListEmpty(L);
printf("L是否空：i=%d(1:是 0:否)\n",i);
i=ClearList(&L);
printf("清空L后：ListLength(L)=%d\n",ListLength(L));
i=ListEmpty(L);
printf("L是否空：i=%d(1:是 0:否)\n",i);
for(j=1;j<=10;j++)
ListInsert(&L,j-1,j);
printf("在L的表尾依次插入1～10后：L.data=");
ListTraverse(L);
printf("ListLength(L)=%d \n",ListLength(L));
ListInsert(&L,0,0);
printf("在L的表头插入0后：L.data=");
ListTraverse(L);
printf("ListLength(L)=%d \n",ListLength(L));
GetElem(L,5,&e);
printf("第5个元素的值为：%d\n",e);
for(j=3;j<=4;j++)
{
k=LocateElem(L,j);
if(k)
printf("第%d个元素的值为%d\n",k,j);
else
printf("没有值为%d的元素\n",j);
}
k=ListLength(L); /* k为表长 */
for(j=k+1;j>=k;j--)
{
i=ListDelete(&L,j,&e); /* 删除第j个数据 */
if(i==ERROR)
printf("删除第%d个数据失败\n",j);
else
printf("删除第%d个的元素值为：%d\n",j,e);
}
printf("依次输出L的元素：");
ListTraverse(L);
j=5;
ListDelete(&L,j,&e); /* 删除第5个数据 */
printf("删除第%d个的元素值为：%d\n",j,e);
printf("依次输出L的元素：");
ListTraverse(L);
i=ClearList(&L);
printf("\n清空L后：ListLength(L)=%d\n",ListLength(L));
CreateListHead(&L,20);
printf("整体创建L的元素(头插法)：");
ListTraverse(L);
i=ClearList(&L);
printf("\n删除L后：ListLength(L)=%d\n",ListLength(L));
CreateListTail(&L,20);
printf("整体创建L的元素(尾插法)：");
ListTraverse(L);
return 0;
}
扫一扫
2695
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
