#ifndef _linklist_
#define _linklist_
#define success 0
#define failed -1
typedef int elemtype;
struct Node
{
elemtype data;
struct Node *next;
};
typedef struct Node node;
typedef node * linklist;
int listinit(linklist *);
int listinsert(linklist l,int k ,elemtype e);
int listlength(linklist l);
int listdelete(linklist l,int k ,elemtype *e);
int listtraver(linklist l,void(*visit)(elemtype));
linklist reverse(linklist l);
int listtraver2(linklist l,void(*visit)(elemtype));
int listinsert2(linklist l,int k);
int detory(linklist *l);
#endif
#include<stdio.h>
#include<stdlib.h>
#include"linklist.h"
int listinit(linklist *l)
{
(*l) = (linklist)malloc(sizeof(node));
if(l == NULL)
{
return failed;
}
(*l)->next = NULL;
return success;
}
int listinsert(linklist l,int k,elemtype e)
{
linklist p = l;
int j = 1;
if(l == NULL)
{
return failed;
}
while(p && j < k)
{
p = p->next;
j++;
}
if(!p || j > k)
{
return failed;
}
l = (linklist)malloc(sizeof(node));
if(l == NULL)
{
return failed;
}
l->data = k;
l->next = p->next;
p->next = l;
return success;
}
linklist reverse(linklist l)
{
linklist p,a,b;
p = l;
a = p->next;
l->next = NULL;
while(a != NULL)
{
b = a->next;
a->next = p;
p = a;
a = b;
}
return p;
}
/*int listinsert2(linklist l,int k)
{
linklist p = (node *)malloc(sizeof(node));
int j = 1;
if(l == NULL)
{
return failed;
}
while(p && j < k)
{
p = p->next;
j++;
}
if(!p || j > k)
{
return failed;
}
// l = (linklist)malloc(sizeof(node));
if(p == NULL)
{
return failed;
}
p->data = k;
l->next = p;
p->next = NULL;
return success;
}
*/
int listlength(linklist l)
{
linklist p = l;
int i = 0;
while(p->next)
{
p = p->next;
i++;
}
return i;
}
int listtraver(linklist l,void(*visit)(elemtype))
{
linklist p = l;
if(p == NULL)
{
return failed;
}
while(p->next)
{
p = p->next;
visit(p->data);
}
return success;
}
int listtraver2(linklist l,void(*visit)(elemtype))
{
linklist p = l;
if(p == NULL)
{
return failed;
}
while(p->next)
{
visit(p->data);
p = p->next;
}
return success;
}
int listdelete(linklist l,int k,elemtype *e)
{
linklist p = l;
int j = 1;
if(l == NULL)
{
return failed;
}
while(p->next && j < k)
{
p = p->next;
j++;
}
if(!(p->next) || j > k)
{
return failed;
}
l = p->next;
*e = p->next->data;
p->next = p->next->next;
return success;
free(l);
}
int listdeleteall(linklist l)
{
linklist p = l->next;
while(p)
{
l->next = p->next;
free(p);
p = l->next;
}
return success;
}
int destory(linklist *l)
{
free(*l);
*l = NULL;
return success;
}
线性表（Linear List ）：
由同类型元素构成有序序列的线性结构。
表中元素个数称为线性表的长度
线性表没有元素时，称为空表
表起始位置称表头，表结束位置称为表尾
线性表的链式存储：
不要求逻辑上相邻的两个元素物理上也相邻；通过“链”建立起数据元素之间的逻辑关系
插入、删除不需要移动数据元素，只需要修改“链”。
时间复杂度O（n）：
n称为问题的规模，当n不断变化时，时间频度T(n)也会不断变化。但有时我们想知道它变化时呈现什么规律。为此，我们引入时间复杂度概念。
一般情况下，算法中基本操作重复执行的次数是问题规模n的某个函数，用T(n)表示，若有某个辅助函数f(n),使得当n趋近于无穷大时，T（n)/f(n)的极限值为不等于零的常数，则称f(n)是T(n)的同数量级函数。记作T(n)=O(f(n)),称O(f(n)) 为算法的渐进时间复杂度，简称时间复杂度。
在各种不同算法中，若算法中语句执行次数为一个常数，则时间复杂度为O(1),另外，在时间频度不相同时，时间复杂度有可能相同，如T(n)=n2+3n+4与T(n)=4n2+2n+1它们的频度不同，但时间复杂度相同，都为O(n2)。
顺序表中的基本运算：
插入：平均移动结点次数为n/2；平均时间复杂度均为O（n）。
删除：平均移动结点次数为（n-1）/2；平均时间复杂度均为O（n）。
线性表的链式存储结构中结点的逻辑次序和物理次序不一定相同，为了能正确表示结点间的逻辑关系，在存储每个结点值的同时，还存储了其后继结点的地址信息（即指针或链）。这两部分信息组成链表中的结点结构。
一个单链表由头指针的名字来命名。
单链表运算：
建立单链表·头插法：s->next=head；head=s；生成的顺序与输入顺序相反。平均时间复杂度均为O（n）。
尾插法：head=rear=null；if（head=null） head=s；else r->next=s；r=s； 平均时间复杂度均为O（n）
加头结点的算法：对开始结点的操作无需特殊处理，统一了空表和非空表。
查找·按序号：与查找位置有关，平均时间复杂度均为O（n）。
按值：与输入实例有关，平均时间复杂度均为O（n）。
插入运算：p=GetNode（L，i-1）；s->next=p->next；p->next=s；平均时间复杂度均为O（n） ·删除运算：p=GetNode（L，i-1）；r=p->next；p->next=r->next；free（r）；平均时间复杂度均为O（n） 单循环链表是一种首尾相接的单链表，终端结点的指针域指向开始结点或头结点。
链表终止条件是以指针等于头指针或尾指针。
采用单循环链表在实用中多采用尾指针表示单循环链表。
优点是查找头指针和尾指针的时间都是O（1），不用 遍历整个链表。
双链表
双链表就是双向链表，就是在单链表的每个结点里再增加一个指向其直接前趋的指针域prior，形成两条不同方 向的链。由头指针head惟一确定。
双链表也可以头尾相链接构成双（向）循环链表。
双链表上的插入和删除时间复杂度均为O （1）。
顺序表和链表的比较：
基于空间：
顺序表的存储空间是静态分配，存储密度为1；适于线性表事先确定其大小时采用。
链表的存储空间是动态分配，存储密度＜1；适于线性表长度变化大时采用。
基于时间：
顺序表是随机存储结构，当线性表的操作主要是查找时，宜采用。
以插入和删除操作为主的线性表宜采用链表做存储结构。
若插入和删除主要发生在表的首尾两端，则宜采用尾指针表示的单循环链表。
线性结构
线性结构，多对多关系有：
存储结构：是逻辑结构用计算机语言的实现。
顺序存储结构：如数组。
链式存储结构：如链表。
索引存储结构：稠密索引：每个结点都有索引项。
稀疏索引：每组结点都有索引项。
散列存储结构：如散列表。