无头结点单链表的逆置_从无头单链表中删除节点及单链表的逆置

题目：

假设有一个没有头指针的单链表。一个指针指向此单链表中间的一个节点(非第一个节点， 也非最后一个节点)。请将该节点从单链表中删除。

解答：

典型的“狸猫换太子”， 若要删除该节点，正常情况下，应该要知道该节点的前面节点的指针，但是由于单链表中没有头结点，所以无法追溯到该节点前面的那个节点，因此，这里采用了“移花接木”的方法。设该节点为B，下一个节点为C。那么，首先将B节点的内容替换为C节点的内容，然后，将C节点删除，这样就达到了我们的目的。代码如下：

pcur->next = pnext->next;

pcur->data = pnext->date;

delete pnext;

代码：

void DeleteListNode(node* pCurrent)

{

assert(pCurrent != NULL);

node* pNext = pCurrent -> next;

if (pNext == NULL)

pCurrent = NULL;

else

{

pCurrent -> next = pNext -> next;

pCurrent -> data = pNext -> data;

delete pNext;

}

}

类似问题：

1、从无头单链表中删除节点问题：假设有一个没有头指针的单链表，一个指针p指向单链表中的一个节点(不是第一个，也不是最后一个)，请将该节点删除掉。

2、向无头单链表中添加节点问题：假设有一个没有头指针的单链表，一个指针p指向单链表中的一个节点(不是第一个，也不是最后一个)，请在该节点之前插入一个新的节点q。

由于链表是无头单向链表，所以我们无法由当前节点获得p的前一节点，而无论是删除当前节点还是向前面节点插入新节点都需要获得p的前一节点。在这里我们不妨换一下思路，对当前节点的后继结点进行操作，然后将前后节点的数据进行适当交换也可以得到相应效果。

问题1解法：将p后继结点p->next的数据拷贝到p，然后删除p->next，这样就达到了相同的效果，代码如下：

ListNode* p_next = p->next;

p->value=p_next->value;

p->next=p_next->next;

delete   p_next;

问题2解法：在p节点后添加q，然后交换p和q的数据即可。

q->next=p->next;

p->next=q;

swap(&p->value, &q->value);

假设一个没有头结点的单链表，一个指针指向此单链表中间的一个节点(不是第一个节点也不是最后一个节点)，请将该节点从单链表中删除

//删除不带头结点链表中的任意个节点

#include

using namespace std;

typedef struct  node

{

int data;

struct node *next;

}Node;

class List

{

public:

List();

~List();

void CreateList();

void DisplayList();

void DeleteNode(Node *d);

Node* GetNode(int n);

private:

Node * list;

};

List::List()

{

list=NULL;

};

List::~List()

{

if(list)

{

Node *p=list;

while(p)

{

list=p->next;

delete p ;

p=list;

}

}

}

void List::CreateList()   //创建不带头结点的链表

{

int num;

Node *p;

cout<

while(cin>>num)

{

if(!list)  //第一个节点特殊处理

{

list=new Node;

list->data=num;

list->next=NULL;

p=list;

}

else

{

Node *temp=new Node;

temp->data=num;

temp->next=NULL;

p->next=temp;

p=temp;

}

}

}

void List::DisplayList()

{

Node *p=list;

while(p)

{

cout

p=p->next;

}

cout<

}

Node* List::GetNode(int n)  //返回第n个节点

{

Node *p=list;

while(p && --n)

p=p->next;

return p;

}

void List::DeleteNode(Node *d)  //删除节点d

{

Node *pCurrent=d;

Node *pNext=pCurrent->next;  //删除该节点的下一个，然后将data赋给d，进行替换

pCurrent->next=pNext->next;

pCurrent->data=pNext->data;

}

int main()

{

List list;

list.CreateList();

list.DisplayList();

Node *p=list.GetNode(2);

cout

list.DeleteNode(p);

list.DisplayList();

system("pause");

return 0;

}

扩展问题：

将一个单链表，在只遍历一遍的情况下，将单链表中的元素顺序反转过来。

解答：

我的想法是这样的，用三个指针进行遍历，在遍历的途中，进行逆置。

这道题目有两种算法，既然是要反转，那么肯定是要破坏原有的数据结构的：算法：我们需要额外的两个变量来存储当前节点curr的下一个节点next、再下一个节点nextnext：

Java代码

public static Link ReverseLink1(Link head)

{

Link curr = head.Next;

Link next = null;

Link nextnext = null; //if no elements or only one element exists

if (curr == null || curr.Next == null) {

return head;

} //if more than one element

while (curr.Next != null) {

next = curr.Next; //1

nextnext = next.Next; //2

next.Next = head.Next; //3

head.Next = next; //4

curr.Next = nextnext; //5

}

return head;

}

public static Link ReverseLink1(Link head)

{

Link curr = head.Next;

Link next = null;

Link nextnext = null; //if no elements or only one element exists

if (curr == null || curr.Next == null) {

return head;

} //if more than one element

while (curr.Next != null) {

next = curr.Next; //1

nextnext = next.Next; //2

next.Next = head.Next; //3

head.Next = next; //4

curr.Next = nextnext; //5

}

return head;

}

算法的核心是while循环中的5句话 我们发现，curr始终指向第1个元素。此外，出于编程的严谨性，还要考虑2种极特殊的情况：没有元素的单链表，以及只有一个元素的单链表，都是不需要反转的。

C语言实现

非递归方式：这是一般的方法，总之就是用了几个临时变量，然后遍历整个链表，将当前节点的下一节点置为前节点

C代码

void reverse(node*& head)

{

if ( (head == 0) || (head->next == 0) ) return;// 边界检测

node* pNext = 0;

node* pPrev = head;// 保存链表头节点

node* pCur = head->next;// 获取当前节点

while (pCur != 0)

{

pNext = pCur->next;// 将下一个节点保存下来

pCur->next = pPrev;// 将当前节点的下一节点置为前节点

pPrev = pCur;// 将当前节点保存为前一节点

pCur = pNext;// 将当前节点置为下一节点

}

head->next = 0; //将旧head节点设置为尾部节点

head = pPre;  //设置当前遍历的最后一个节点为新的头节点

}

void reverse(node*& head)

{

if ( (head == 0) || (head->next == 0) ) return;// 边界检测

node* pNext = 0;

node* pPrev = head;// 保存链表头节点

node* pCur = head->next;// 获取当前节点

while (pCur != 0)

{

pNext = pCur->next;// 将下一个节点保存下来

pCur->next = pPrev;// 将当前节点的下一节点置为前节点

pPrev = pCur;// 将当前节点保存为前一节点

pCur = pNext;// 将当前节点置为下一节点

}

head->next = 0; //将旧head节点设置为尾部节点

head = pPre;  //设置当前遍历的最后一个节点为新的头节点

}

递归方式：这个方法是采用了递归算法，也就是在反转当前节点之前先反转其后继节点，利用函数的调用堆栈构建了一个临时链表。采用此算法需要注意的是，头结点必须要传入的是引用，因为在递归跳出的时候要切断链表，否则链表将会形成一个回环。

C代码

node* reverse( node* pNode, node*& head)

{

if ( (pNode == 0) || (pNode->next == 0) ) // 递归跳出条件

{

head = pNode; // 将链表切断，否则会形成回环

return pNode;

}

node* temp = reserve(pNode->next, head);// 递归

temp->next = pNode;// 将下一节点置为当前节点，既前置节点

return pNode;// 返回当前节点

}

编写一个函数，给定一个链表的头指针，只要求遍历一次，将单链表中的元素顺序反转过来

#include

using namespace std;

typedef struct node

{

int data;

struct node *next;

}Node;

class List

{

public:

List();

~List();

void CreateList();

void DisplayList() const;

void ReverseList();

private:

Node *head;

};

List::List()

{

//分配头结点

head=new Node;

head->next=NULL;

head->data=0;

}

List::~List()

{

if(head)

{

Node *pCurrent=head;

while(head)

{

pCurrent=head->next;

head=pCurrent;

delete pCurrent;

}

}

}

void List::CreateList()

{

//创建带头结点的链表

int num;

cout<

Node *pCurrent=head;

while(cin>>num)

{

Node *pTemp=new Node;

pTemp->data=num;

pTemp->next=NULL;

pCurrent->next=pTemp;

pCurrent=pTemp;

}

}

void List::DisplayList() const

{

Node *pCurrent=head->next;

while(pCurrent)

{

cout

pCurrent=pCurrent->next;

}

cout<

}

void  List::ReverseList()  //思想是将指针的方向反向。将头节点指向尾节点

{

Node *pCurrent,*pNext,*pTemp;

pCurrent=head->next;  //指向第一个节点

pNext=pCurrent->next;  //第二个节点

if(!pCurrent || !pNext)  //当链表为空或者只含有一个节点

return;

pCurrent->next=NULL;     //将第一个节点变为为节点

while(pNext)

{

pTemp=pNext->next;    //保存下一个节点

pNext->next=pCurrent; //将指针方向

pCurrent=pNext;       //指向当前的节点

pNext=pTemp;          //下一个节点

}

head->next=pCurrent;  //头结点指向最后一个节点

}

int main()

{

List list;

list.CreateList();

list.DisplayList();

cout<

list.ReverseList();

list.DisplayList();

system("pause");

return 0;

}