算法进行时--单链表（二）常见题型01

1.用递归算法，删除带结点的单链表L中所有值为x的结点。

由于是带头结点的，所以并且查找值为x的结点时，从L->next的值开始判断，

如果L->next的data等于x，那么就要将L->next的值删除并且将L的后继结点换成L->next的后继结点，并且将它删除。

LNode *P = L->next ;

L->next=L->next->next;

free(P)

递归模型：

终止条件：

L->next == NULL

递归主体：

如果L->next->data= = x:

删除L->next结点，并执行L->next=L->next->next操作，继续执行下一个结点值判断。

如果L->next != x:

直接判断下一个结点。

LNode* delectList(LNode*L, int x)
{
if (L->next== NULL)
return L;
else
{

if (L->next->data==x)
{
LNode *P = L->next;
L ->next= L->next->next;
free(P);
delectList(L, x);
}
else
{
delectList(L->next, x);
}
}
}

2.在头结点的单链表，编写算法实现从尾到头反向输出每个结点的值。

第一种:

反向输出,可以头结点的后继结点开始，直到L->next=NULL，用头插法的方式将后面的结点插在头结点后面，然后在依次打印。

第二种：

栈是一种后进先出的结构，递归就是用栈的思想实现的。

void R_Print(LNode *L){
if (L->next != NULL)
{
R_Print(L->next);//递归
}
cout << L->data << endl;
}

3.将带头结点的链表就地逆置（就地要求辅助空间复杂度为O（1））。

其实这几道题的思想都差不多，这道题就是将头结点取下然后将后续结点用头插法的方式插入，直到最后一个结点。

LNode* Reverse_L(LNode *L)
{
LNode *move = L->next;//移动指针，头结点后的一个结点开始
L->next = NULL;
LNode *r;
while (move != NULL)
{
r = move->next;//存放带插入的结点
move->next = L->next;//头插法的方式
L->next = move;
move = r;//移动工作结点
}
return L;
}

4.将带头结点的链表删除最小值结点的高效算法（最小结点唯一）

思路：

第一步寻找最小值

第二步将最小值删除

在寻找最小值时用需要从头到尾一次比较，将最小值的前驱用指针保存。

删除时只需要将前驱的后继结点指向改变即可。

空间复杂度为O(1)，时间复杂度为O（n）

LNode* deletemin(LNode *L)
{
LNode *move = L->next;//移动的工作结点
LNode *min = L;//保存最小值前驱的结点
while (move->next != NULL)
{
if (min->next->data > move->next->data)
{
min = move;
}
move = move->next;
}
LNode *s = min->next;//要删除的结点
min->next = min->next->next;//前驱结点的后继结点改变
free(s);
return L;
}

全部代码：

/*
Instruction:Linklist insertion
author:huangpingyi
date:2017/02/23
*/

#include <iostream>
using namespace std;

struct LNode
{
int data;
LNode *next;
};

//尾插法
LNode* CreateListT(LNode *L, int x, int array[])
{
L->next = NULL;
LNode *q = L;
LNode *s;//插入的结点
int i = 0;
while (i < x)
{
s = new LNode;
s->data = array[i];
//以下三步是尾插法和头插法的区别
L->next = s;
s->next = NULL;
L = s;
i++;
}
return q;
}

//递归删除值为x的结点
LNode* delectList(LNode*L, int x) { if (L->next== NULL) return L; else { if (L->next->data==x) { LNode *P = L->next; L ->next= L->next->next; free(P); delectList(L, x); } else { delectList(L->next, x); } } }

//从头到尾反向输出结点
void R_Print(LNode *L){ if (L->next != NULL) { R_Print(L->next);//递归 } cout << L->data << endl; }

//就地逆置链表
LNode* Reverse_L(LNode *L) { LNode *move = L->next;//移动指针，头结点后的一个结点开始 L->next = NULL; LNode *r; while (move != NULL) { r = move->next;//存放带插入的结点 move->next = L->next;//头插法的方式 L->next = move; move = r;//移动工作结点 } return L; }

//删除链表中最小值结点
LNode* deletemin(LNode *L) { LNode *move = L->next;//移动的工作结点 LNode *min = L;//保存最小值前驱的结点 while (move->next != NULL) { if (min->next->data > move->next->data) { min = move; } move = move->next; } LNode *s = min->next;//要删除的结点 min->next = min->next->next;//前驱结点的后继结点改变 free(s); return L; }
//打印结果
void Print(LNode *L)
{

L = L->next;//第一个是头结点
while (L != NULL)
{
cout << L->data << endl;
L = L->next;
}

}
int main(){
int x, array[10];
cout << "请输入插入个数:" << endl;
cin >> x;
cout << "输入需要插入的数据:" << endl;
for (int i = 0; i < x; i++)
{
cin >> array[i];
}
LNode* L = new LNode;
CreateListT(L, x, array);//d调用后为啥L不变
cout << "用尾插法创建链表的结果:" << endl;
Print(L);
int delect;
cout << "请输入需要删除的数" << endl;
cin >> delect;
delectList(L, delect);
cout << "用递归法删除x后结果" << endl;
Print(L);
cout << "从头到尾反向输出结果" << endl;
R_Print(L->next);
cout << "此时链表的顺序" << endl;
Print(L);
Reverse_L(L);
cout << "就地逆置后的结果:" << endl;
Print(L);
cout << "删除结点的最小值结果" << endl;
deletemin(L);
Print(L);
system("pause");
return 0;
}

运行效果：