昨天我们谈了关于单链表的插入操作，今天我们就来看看与插入操作对应的删除操作。

• 前面了解了链表的插入，现在删除就简单了，因为是个反过程嘛。还是画个图容易理解一些。

单链表删除第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. 返回成功。

设计的函数如下：

/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 */
Status ListDelete(LinkList *L,int i,ElemType *e)
{
	int j;
	LinkList p,q;
	p = *L;	// 声明一结点p指向链表第一个结点
	j = 1;
	while (p->next && j < i)	/* 遍历寻找第i个元素 */
	{
        p = p->next;
        ++j;
	}
	if (!(p->next) || j > i)
	    return ERROR;           /* 第i个元素不存在 */
	q = p->next;
	p->next = q->next;			/* 将q的后继赋值给p的后继 */
	*e = q->data;               /* 将q结点中的数据给e */
	free(q);                    /* 让系统回收此结点，释放内存 */
	return OK;
}

• 这段算法代码里，我们又用到了另一个C语言的标准函数free。它的作用就是让 系统回收一个Node结点，释放内存。

分析一下刚才我们讲解的单链表插入和删除算法，我们发现，它们其实都是由两部分组成：第一部分就是遍历査找第i个元素；第二部分就是插入和删除元素。

从整个算法来说，我们很容易推导出：它们的时间复杂度都是0(n)。如果在我们不知道第i个元素的指针位置，单链表数据结构在插入和删除操作上，与线性表的顺序存储结构是没有太大优势的。但如果我们希望从第i个位置，插入10个元素，对于顺序存储结构意味着，每一次插入都需要移动n-i个元素，每次都是0(n〕。而单链表，我们只需要在第一次时，找到第i个位置的指针，此时为0(n),接下来只是简单地通过赋值移动指针而已，时间复杂度都是0(1)。显然，对于插入或删除数据越频繁的操作，单链表的效率优势就越是明显。

最后附上完整的源代码：

#include "stdio.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 */

typedef struct Node
{
    ElemType data;
    struct Node *next;
}Node;
/* 定义LinkList */
typedef struct Node *LinkList;

/* 初始化顺序线性表 */
Status InitList(LinkList *L)
{
    *L=(LinkList)malloc(sizeof(Node)); /* 产生头结点,并使L指向此头结点 */
    if(!(*L)) /* 存储分配失败 */
    {
        return ERROR;
    }
    (*L)->next=NULL; /* 指针域为空 */

    return OK;
}

/* 初始条件：顺序线性表L已存在。操作结果：返回L中数据元素个数 */
int ListLength(LinkList L)
{
    int i=0;
    LinkList p=L->next; /* p指向第一个结点 */
    while(p)
    {
        i++;
        p=p->next;
    }
    return i;
}

/* 初始条件：顺序线性表L已存在 */
/* 操作结果：依次对L的每个数据元素输出 */
Status ListTraverse(LinkList L)
{
    LinkList p=L->next;
    while(p)
    {
        visit(p->data);
        p=p->next;
    }
    printf("\n");
    return OK;
}

Status visit(ElemType c)
{
    printf("-> %d ",c);
    return OK;
}

/* 初始条件：顺序线性表L已存在,1≤i≤ListLength(L)， */
/* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */
Status ListInsert(LinkList *L,int i,ElemType e)
{
	int j;
	LinkList p,s;
	p = *L;     /* 声明一个结点 p，指向头结点 */
	j = 1;
	while (p && j < i)     /* 寻找第i个结点 */
	{
		p = p->next;
		++j;
	}
	if (!p || j > i)
		return ERROR;   /* 第i个元素不存在 */
	s = (LinkList)malloc(sizeof(Node));  /*  生成新结点(C语言标准函数) */
	s->data = e;
	s->next = p->next;      /* 将p的后继结点赋值给s的后继  */
	p->next = s;          /* 将s赋值给p的后继 */
	return OK;
}

/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 */
Status ListDelete(LinkList *L,int i,ElemType *e)
{
	int j;
	LinkList p,q;
	p = *L;
	j = 1;
	while (p->next && j < i)	/* 遍历寻找第i个元素 */
	{
        p = p->next;
        ++j;
	}
	if (!(p->next) || j > i)
	    return ERROR;           /* 第i个元素不存在 */
	q = p->next;
	p->next = q->next;			/* 将q的后继赋值给p的后继 */
	*e = q->data;               /* 将q结点中的数据给e */
	free(q);                    /* 让系统回收此结点，释放内存 */
	return OK;
}

int main()
{
    LinkList L;
    Status i;
    int j,k,pos;
    char opp;
    ElemType e;

    i=InitList(&L);
    printf("链表L初始化完毕，ListLength(L)=%d\n",ListLength(L));

    printf("\n1.遍历操作 \n2.插入操作 \n3.删除操作  \n0.退出 \n请选择你的操作：\n");
    while(opp != '0'){
        scanf("%c",&opp);
        switch(opp){
            case '1':
                ListTraverse(L);
                printf("\n");
                break;

            case '2':
                srand((unsigned)time(NULL));
                for(j=1;j<=10;j++)
                {
                    i=ListInsert(&L,1,rand()%100);
                }
                printf("在L的表头依次插入10个随机数后：\n");
                ListTraverse(L);
                printf("\n");
                break;

            case '3':
                printf("要删除第几个元素？");
                scanf("%d",&pos);
                ListDelete(&L,pos,&e);
                printf("删除第%d个元素成功，现在链表为：\n", pos);
                ListTraverse(L);
                printf("\n");
                break;

            case '0':
                exit(0);
        }
    }

}

延伸阅读

此文章所在专题列表如下：

1. 第01话：线性表的概念与定义
2. 第02话：线性表的抽象数据类型ADT定义
3. 第03话：线性表的顺序存储结构
4. 第04话：线性表的初始化
5. 第05话：线性表的遍历、插入操作
6. 第06话：判断线性表是否为空与置空操作
7. 第07话：线性表的查找操作
8. 第08话：线性表删除某个元素
9. 线性表顺序存储的优缺点
10. 线性表链式存储结构的由来与基本概念
11. 单链表的头指针、头结点与首元结点
12. 单链表的结构体定义与声明
13. 单链表的初始化
14. 单链表的插入与遍历操作
15. 单链表的删除某个元素的操作
16. 获取单链表中的指定位置的元素
17. 查找某数在单链表中的位置
18. 用头插法实现单链表整表创建
19. 用尾插法实现单链表整表创建
20. 将单链表重置为空表
21. 单链表反转/逆序的两种方法
22. 单链表反转/逆序的第三种方法
23. 求单链表倒数第N个数
24. 用标尺法快速找到单链表的中间结点
25. 如何判断链表是否有环的存在
26. 单链表建环，无环链表变有环
27. 删除单链表中的重复元素

本文地址：http://www.nowamagic.net/librarys/veda/detail/2224，欢迎访问原出处。