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为前一个节点。