单链表的基本操作(读取、插入、删除)及优缺点总结

1.单链表的读取

获取链表第i个数据的算法思路:
1. 声明一个指针p指向链表的第一个结点,初始化j从1开始;
2. 当j< i 时,遍历链表,让p的指针向后移动,不断指向下一结点,j累加1;
3. 若到链表末尾p为空,说明第i个元素不存在;
4. 否则查找成功,返回结点p的数据。

/*初始条件:顺序线性表L已存在,1≤i≤ListLength(L)*/
/*操作结果: 用e返回L中第i个数据元素的值*/
Status GetElem(LinkList L,int i ,ElemType *e)
{
int j;
LinkList p; /*声明一指针p*/
p = L->next; /*让p指向链表L的第一个结点*/
j = 1;  /*计数器*/
while(p && j<i) /*当p不为空或者j还没有大于等于i时,循环继续*/
    {
    p = p->next;  /*让p指向下一个结点*/
    ++j;
    }
if (!p || j>i)
    return ERROR; /*第i个元素不存在*/
*e = p->data;  /*取出第i个结点的数据*/
return OK;
}

由于单链表的结构中没有定义表长,所以不能事先知道要循环多少次,因此不方便用for循环来控制循环。

2.单链表的插入

插入过程,如下图所示:
这里写图片描述

只需让s->next 和p->next的指针做一点改变即可。

s->next = p->next;
p->next = s; 

单链表第i个数据插入结点的算法思路是:

  1. 声明一个指针p指向链表的第一个结点,初始化j从1开始;
  2. 当j< i 时,遍历链表,让p的指针向后移动,不断指向下一结点,j累加1;
  3. 若到链表末尾p为空,说明第i个元素不存在;
  4. 否则查找成功,在系统中生成一个空结点s;
  5. 将数据元素e赋值给s->data;
  6. 单链表的插入标准语句 s->next = p->next; p->next = s;
  7. 返回成功。
/*初始条件:顺序线性表L已存在,1≤i≤ListLength(L)*/
/*操作结果:在L中第i个位置之前插入新的数据元素e,L的长度加1*/
Status ListInsert(LinkList *L,int i ,ElemType e)
{
int j;
LintList p,s; 
p = *L;
j = 1;
while (p && j<i) /*寻找第i个结点*/
    {
    p = p->next;
    ++j;
    }
if (!p || j >i)
    return ERROR;  /*第i个元素不存在*/

s = (LinkList)malloc(sizeof(Node)); /*生成新的结点*/
s->data = e;
s->next = p->next;  /*将p的后继结点赋值给s的后继*/
p->next = s;  /*将s赋值给p的后继*/
return OK;
}

3.单链表的删除

这里写图片描述

实际上就是一步,p->next = p->next->next. 用p来取代p->next;

q=p->next;
p->next = q->next;

单链表第i个数据删除结点的算法思路:

  1. 声明一个指针p指向链表的第一个结点,初始化j从1开始;
  2. 当j< i 时,遍历链表,让p的指针向后移动,不断指向下一结点,j累加1;
  3. 若到链表末尾p为空,说明第i个元素不存在;
  4. 否则查找成功,将欲删除的结点p-next赋值给q;
  5. 单链表的删除标准语句 p->next = q->next;
  6. 将q结点中的数据赋值给e,作为返回;
  7. 释放q结点;
  8. 返回成功。
#include <stdio.h>
#define ERROR 0
#define OK 1
Status ListDelete(LinkList *L,int i ,ElemType *e)
{
int j;
LinkList p,q;
p = *L;
j = 1;
while(p->next && j <i)
    {
    p = p->next;
    ++j;
    }
if(!(p->next) || j>i)
    return ERROR;
q = p->next;
p->next = q->next;
*e = q->data;
free(q);
return OK;
}

对于基本的插入与删除操作,它们其实都是两部分组成:

1.遍历查找第i个结点;
2.插入和删除结点。

4.单链表的整表创建

单链表是一种动态结构。
对于每个链表来说,它所占用的空间大小和位置是不需要预先分配的。
所以创建单链表的过程,就是从“空表”的初始状态,一次建立各元素结点,并插入链表中、

单链表的整表创建的算法思路:
(头插法)
1.声明以指针p和计数器变量i;
2.创建一个空链表L;
3.让L的头结点的指针指向NULL;
4.循环:

  • 生成以新结点赋值给p
  • 随机生成以数字赋值给p->data;
  • 将p插入到头结点与前一新结点之间。

头插法,示意图:

这里写图片描述

/*随机产生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个元素的值,建立带表头结点的单链线性表(尾插法)*/
void CreateListTail(LinkList *L,int n)
{
LinkList p,r;
int i;
srand(time(0)); 
*L = (LinkList)malloc(sizeof(Node)) 
r =*L    /*r为指向尾部的结点*/
for(i=0;i<n;i++)
    {
    p = (Node *)malloc(sizeof(Node))  /*生成新结点*/
    p->data = rand() %100 +1;
    r->next = p;   /*将表尾终端结点的指针指向新结点*/
    r = p;  /*将当前的新结点定义为表尾终端结点*/
    }
r->next = NULL;   /*表示当前链表结束*/

5.单链表的整表删除

当我们不打算使用这个单链表时候,我们需要把它销毁,其实就是在内存中将它释放掉。

思路:
1.声明结点p和q;
2.将第一个结点赋值给p;
3.循环:

  • 将下一结点赋值给q;
  • 释放p;
/*初始条件:顺序线性表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;
}

6.总结

单链表结构与顺序存储结构优缺点

时间性能

顺序存储结构: 查找为O(1),因其是随机存取结构;插入与删除需要平均移动表长一半的元素,故为O(n);

单链表:查找为O(n),查找算法的时间复杂度取决于i的位置,当i=1时,则不需要遍历,第一个就取出数据了,而当i=n时则遍历n-1次才可以。因此最坏情况为O(n);单链表在确定出某位置的指针后,插入和删除时间仅为O(1);

空间性能

顺序存储结构:需要预分配存储空间;

单链表:不需要分配存储空间,只要有就可以分配,元素个数也不受限制。

  • 若线性表需要频繁查找,很少进行插入与删除操作时,宜采用顺序存储结构;若需要频繁插入和删除时,宜采用单链表结构。
  • 当线性表中的元素个数变化较大或未知时,最好使用单链表。如果实现知道线性表的大致长度则使用顺序存储结构效率会高很多。
展开阅读全文

没有更多推荐了,返回首页