[数据结构]:线性表之单链表.

是纤纤呀

已于 2022-01-20 19:58:14 修改

阅读量468

点赞数 1

分类专栏：数据结构文章标签：数据结构链表算法

于 2022-01-18 11:32:26 首次发布

本文链接：https://blog.csdn.net/Intention_pass/article/details/122554754

版权

数据结构专栏收录该内容

2 篇文章 0 订阅

订阅专栏

1.单链表的存储结构:

//单链表的存储结构.
typedef struct Node
{
	ElemType data;      //数据域
	struct Node* Next;  //指针域
}Node;
typedef struct Node* LinkList;

2.初始化:构造一个空表.

算法步骤:

1.生成新的结点作为头结点,用头指针L指向头结点. 2.头结点的指针域置空.

算法描述:

//初始化
Status InitList(LinkList L)
{
    L = new Node; //生成新节点作为头结点,用头指针指向头结点.
    L->Next = NULL;//头结点的指针域指空.
    return OK;
}

3.取值:

算法步骤:

1.用指针p指向首元结点,用j做计数器初值赋为1. 2.从首元结点开始依次顺着链域next向下访问,只要指向当前结点的指针p不为空(NULL),并且没有到达序号为i的结点,则循环执行以下操作: a: p指向下一结点; b: 计数器j相应加一. 3.退出循环时,如果指针p为空,或者计数器j大于i,说明指定的序号i值不合法(i大于表长n或小于等于0),取值失败返回ERROR;否则取值成功,此时j=i时,p指向的结点就是要找的第i个结点,用参数e保存当前结点的数据域,返回OK.

算法描述:

//取值.
Status GetElem(LinkList L, int i, ElemType* e)
{
	int j;
	LinkList p;

	p = L->Next;           //初始化,p指向首元结点.
	j = 1;                 //计数器j初值赋为1.
	while (p && j < i)     //依次向后扫描,直到p为空或p指向第i个元素.
	{
		p = p->Next;        //p指向下一结点.
		++j;               //计数器j相应加一
	}
	if (!p || j > i)       //i值不合法i>n或i<=0.
	{
		return ERROR;
	}
	*e = p->data;           //取第i个结点的数据域.
	return OK;
}

4.查找:从链表的首元结点出发,依次将结点值和给定值e进行比较,返回查找结果.

算法步骤:

1.用指针p指向首元结点. 2.从首元结点开始依次顺着链域next向下查找,只要当前结点的指针p不为空,并且p所指结点的数据域不等于给定值e,则循环执行以下操作:p指向下一结点. 3.返回p.若查找成功,p此时即为结点的地址值,若查找失败,p的值即为NULL.

算法描述:

//查找
Node* LocateElem(LinkList L, ElemType e)
{
	LinkList p;
	p = L->Next;   //p指向首元结点.

	while (p && p->data != e)//顺链域向后扫描,直到p为空或p所值结点的数据域等于e.
	{
		p = p->Next;//p指向下一结点.
	}
	return p;//查找成功,返回值为e的结点地址p,查找失败p为空.
}

5.插入:

算法步骤:

1.查找第i-1个结点并由指针p指向该结点. 2.生成一个新结点s. 3.将新结点的数据域赋值为e. 4.将新结点s的指针域指向第i个结点. 5.将结点p的指针域指向新结点s.

算法描述:

//插入
Status ListInsert(LinkList L, int i, ElemType e)
{
	LinkList p,s;
	int j=0;
	p = L;

	while (p && j < i - 1)  
	{
		p = p->Next;   //查找第i-1个结点,p指向该结点.
		++j;
	}
	if (!p || j > i - 1) //i值不合法.
	{
		return ERROR;
	}

	s = (LinkList)malloc(sizeof(Node));//生成新结点s.
    s->data=e;
	s->Next = p->Next;  //将新结点的指针域指向第i个结点.
	p->Next = s;  //将结点p的指针域指向结点s.
	return OK;
}

6.删除:

算法步骤:

1.查找第i-1个结点并由指针p指向该结点. 2.临时保存待删除的结点的地址在q中,以备释放. 3.将结点p的指针域指向第i个结点的直接后继结点. 4.释放第i个结点的空间.

算法描述:

//删除
Status ListDelete(LinkList L, int i)
{
	LinkList p,q;
	int j = 0;

	while (p->Next && j < i - 1)
	{
		p = p->Next;        查找第i-1个结点,p指向该结点.
		++j;
	}
	if (!(p->Next) || j > i - 1) {//i值不合法.
		return ERROR;
	} 
	q = p->Next;        //临时保存要被删除的结点.
	p->Next = q->Next;  //改变要被删除结点前驱结点的指针域.
	free(q);  //delete q;  //释放结点q.
	return OK;
}

7.前(头)插法创建单链表:

算法步骤:

1.创建一个只有头结点的空链表. 2.根据待创建链表包括的元素个数n,循环n次执行以下操作: a.生成一个新结点p; b.输入元素值赋给新结点p的数据域; c.将新结点p插入到头结点之后.

算法描述:

//头插法创建单链表(整表).
void CreateListHead(LinkList* L, int n)
{
	LinkList p;
	int i;

	*L = (LinkList)malloc(sizeof(Node));//初始化空链表L.
	(*L)->Next = NULL;

	for (i = 0; i < n; i++)
	{
		p = (LinkList)malloc(sizeof(Node));   //生成新结点p.
		cin >> p->data;
		p->Next = (*L)->Next;    //将新结点查入到头结点之后.
		(*L)->Next = p;
	}
}

8.尾插法创建单链表:

算法步骤:

1.创建一个只有头结点的空链表. 2.尾指针r初始化,指向头结点. 3.根据创建链表包括的元素个数n,循环n次执行以下操作: a.生成新结点p; b.输入元素值赋给新结点的数据域; c.将新结点p插入到尾结点r之后;尾指针r指向新的尾结点p.

算法描述:

//尾插法创建单链表(整表).
void CreateListTail(LinkList* L, int n)
{
	LinkList p, r;
	int i;

	*L = (LinkList)malloc(sizeof(Node));//初始化空链表L.
	r = *L;

	for (i = 0; i < n; i++)
	{
		p = (LinkList)malloc(sizeof(Node));//生成新结点p.
		cin >> p->data;
		p->Next = NULL;  //将新结点p插入到尾结点r之后.
		r->Next = p;
		r = p;  //r指向新的为节点p.
	}
	r->Next = NULL;
}

9.单链表的整表删除:

算法步骤:

1.声明结点p和q;2.将第一个结点赋值给p,下一结点赋值给q;3.循环执行释放p和q赋值给p的操作.

算法描述:

Status ClearList(LinkList* L)
{
	LinkList p, q;
	p = (*L)->Next;

	while (p)
	{
		q = p->Next;
		free(p);
		p = q;
	}
	(*L)->Next = NULL;
	return OK;
}