C语言实现单向链表

1      单向链表定义

对于数组，逻辑关系上相邻的两个元素的物理位置也是相邻的，这种结构的优点是可以随机存储任意位置的元素，但缺点是如果从数组中间删除或插入元素时候，需要大量移动元素，效率不高。

链式存储结构的特点，元素的存储单元可以是连续的，也可以是不连续的，因此为了表示每个元素 a ，与其接后的元素 a+1 之间的关系，对于元素 a ，除了存储其本身信息外，还需要存储一个指示其接后元素的位置。这两部分数据成为结点 (node) 。

一个结点中存储的数据元素被成为 数据域 。存储接后存储位置的域叫做 指针域 。 n 个结点 (ai(1<=i<=n) 的存储映像链接成一个 链表 。

整个链表必须从头结点开始进行，头结点的指针指向下一个结点的位置，最后一个结点的指针指向 NULL 。

在链表中，通过指向接后结点位置的指针实现将链表中每个结点“链”到一起。链表中第一个结点称之为 头结点 。

2 单向链表的实现（C语言）

代码：
#include <stdio.h>
#include <stdlib.h>

typedef struct _LIST_ONE //定义一个链表结构体
{
int data;
struct _LIST_ONE *next;
} LIST_ONE;

LIST_ONE * create_list() //创建一链表（定义一链表头元素指针）
{
return calloc(sizeof(LIST_ONE), 1);
}

void traverse(LIST_ONE *first)//遍历链表
{
LIST_ONE *tmp = first;
while (tmp)
{
printf("%d\n", tmp->data);
tmp = tmp->next;
}
}

void insert(LIST_ONE *first, LIST_ONE *list, int n)
{
LIST_ONE *p = first;
while (p &&--n) 
{
p = p ->next;
}
if (p == NULL)
{
return NULL;
}
list->next = p->next; //插入进来的list 的指针域指向让当前n位置的元素（p->next）
p->next = list;//再让p->的指针域指向list
}

void delete(LIST_ONE *first, int n)//链表中删除一个元素
{
LIST_ONE *p = first;
while (p &&--n)
{
p = p->next;
}
if (p == NULL)
{
return NULL;
}
LIST_ONE *tmp = p->next;//将要被删除的元素放进tmp待释放
p->next = p->next->next;//直接让n位置的元素的指针域指向下下一个元素
free(tmp);//释放被删除的元素
return 1;
}

int length(LIST_ONE *first)//返回链表长度
{
LIST_ONE *p = first;
int cnt = 0;
while (p)
{
p = p->next;
cnt++;
}
return cnt;
}

void truncate(LIST_ONE *first)//清空链表，只留下首节点
{
LIST_ONE *p = first->next;
while (p)
{
LIST_ONE *tmp = p ;
p = p->next;
free(tmp);
}
first->next = NULL;//链表的最后一下字段必须指向空
return 1;
}

int is_empty(LIST_ONE *first) //判断链表是否为空
{
if (first->next) 
return 0;
else 
return 1;
}

LIST_ONE * return_n(LIST_ONE *first, int n) //返回第n个节点元素
{
LIST_ONE *p = first;
while (p&&n--)
{
p = p->next;
}
if (p == NULL)
return NULL;
return p;
}

LIST_ONE * return_node(LIST_ONE *first, int data)// 返回指定值的节点;
{
LIST_ONE * p = first;
while (p)
{
if (p->data == data)
return p;
p = p->next;
}
return NULL;
}

int return_index(LIST_ONE *first, int data)// 返回指定值节点的索引
{
int index = 0;
LIST_ONE *p =first;
while (p)
{
if (p->data == data)
return index;
p = p->next;
index++;
}
return -1;
}

LIST_ONE * get_LastNode(LIST_ONE *first) //返回链表中的最后一个节点元素
{
LIST_ONE *p = first;
while (p ->next)
{
p = p->next;
}
return p;
}

LIST_ONE * add(LIST_ONE *first1, LIST_ONE *first2)//把first2链表加在first1之后
{
LIST_ONE *p = get_LastNode(first1);
p->next = first2;
return first1;
}
LIST_ONE * add_without_one(LIST_ONE *first1, LIST_ONE *first2)//把first2链表加在first1之后 不要first2的头节点
{
LIST_ONE *p = get_LastNode(first1);
p->next = first2->next;
return first1;
}

int main()
{
LIST_ONE *first = create_list();
LIST_ONE *second = create_list();
LIST_ONE *third = create_list();
LIST_ONE *forth = create_list();
LIST_ONE *fifth = create_list();
first->next = second;
second->next = third;
third->next = NULL;//对于链表的最后一个元素一定要指向NULL,
first->data = 1;
second->data = 2;
third->data = 3;
forth->data = 4;
fifth->data = 5;
insert(first, forth, 2);
insert(first, fifth, 2);
delete(first, 2);
printf("length = %d\n", length(first));
traverse(first);
//LIST_ONE ls = *return_n(first, 0);
//printf("第一个元素data为：%d", ls.data);
//truncate(first);
//traverse(first);
LIST_ONE ls = *return_node(first, 4);
printf("ls.next.data=%d\n", ls.next->data);
int index = return_index(first, 4);
printf("第一个值为4的节点下标为：%d\n", index);
LIST_ONE ls1 = *get_LastNode(first);
printf("lastnode.data = %d\n", ls1.data);
LIST_ONE *one = create_list();
one->data = 100;
for (int i = 0; i < 4; i++)
{
LIST_ONE *list = create_list();
list->data = (i+1)*10;
insert(one, list, 1);
}
traverse(one);
printf("---add---\n");
add_without_one(first, one);//add(first, one);//算上头节点的情况
traverse(first);

return 0;
}

遗留问题：单向链表的逆置：

思路：

1.  判断首节点的next是否为NULL；

2.  判断首节点next的next是否为空，如果为空证明链表除首节点之外只有一个节点，所以不需要逆置；

3.  定义一个指针last，指向首节点的next域，因为逆置之后，该域为链表尾节点；

4.  定义三个指针，分别代表前一个节点，当前节点，下一个节点；

5.  前节点指向链表首节点；

6.  当前节点指向链表首节点的next域；

7.  下一个节点为NULL；

8.  循环条件判断当前节点是否为NULL，如果为NULL退出循环；

a)        下一个节点指向当前节点的下一个节点；

b)        当前节点的下一个节点指向前一个节点；

c)        前一个节点指向当前节点；

d)       当前节点指向下一个节点；

9.   循环完成；

10. 设置last节点的next为NULL；

11.  设置链表首节点的next为前一个节点。