算法学习07：反转单向和双向链表

题目

分别实现反转单向链表和反转双向链表的函数。要求：如果链表长度为N，时间复杂度要求为O(N)，额外空间复杂度为O(1)

反转单链表分析

用三个指针分别记录前一个节点temp，当前节点pre和后一个节点phead。循环中，将temp后移到pre的位置，pre后移到phead的位置，phead移动到下一个节点，并将当前节点pre的指针域指向前一个节点temp。当phead到达链表末尾时，即phead-next=null的时候，当前的末节点是pre，将其指针域指向temp。恰好完成整个链表的反转，循环结束，返回反转后链表的头结点pre

link InvertList(link head){
	link pre,phead,temp;
	phead = head;  //将phead指向链表头，做游标使用
	pre = NULL;  //pre为头指针之前的节点
	while(phead != NULL){
		temp = pre;
		pre = phead;
		phead = phead->next;
		pre->next = temp;  //pre接到之前的节点 
	}
	return pre; 
}

完整代码

#include<iostream>
#include<cstdlib>
using namespace std;

class list {
public:
	int data;
	class list* next;
};
typedef class list node;
typedef node* link;

link FindNode(link head, int position_data) {
	link phead;
	phead = head;
	while (phead != NULL) {
		if (phead->data == position_data)return phead;
		phead = phead->next;
	}
	return phead;
}

link InsertNode(link head, int position_data, int data) {
	link phead = new node;
	phead = FindNode(head, position_data);
	link insertnode = new node;
	if (!insertnode) return NULL;
	insertnode->data = data;
	insertnode->next = NULL;
	if (phead == NULL) {  //插入第一个节点
		insertnode->next = head;
		return insertnode;
	}
	else if (phead->next == NULL) phead->next = insertnode;  //插入最后一个节点
	else {  //插入中间节点 
		insertnode->next = phead->next;
		phead->next = insertnode;
	}
	return head;
}

link DeleteNode(link head, int position_data) {
	link top = head;  //保留头指针 
	link phead = FindNode(head, position_data);
	if (head == phead) {  //删除头结点 
		head = head->next;
		delete phead;
	}
	else {
		while (top->next != phead) top = top->next;
		if (phead->next == NULL) {  //删除尾结点 
			top->next = NULL;
			delete phead;
		}
		else {
			top->next = phead->next;
			delete phead;
		}
	}
	return head;
}

link InvertList(link head) {
	link pre, phead, temp;
	phead = head;  //将phead指向链表头，做游标使用
	pre = NULL;  //pre为头指针之前的节点
	while (phead != NULL) {
		temp = pre;
		pre = phead;
		phead = phead->next;
		pre->next = temp;  //pre接到之前的节点 
	}
	return pre;
}

link CreateList(int a[], int n) {
	link head, phead, newnode;
	phead = new node;
	if (!phead) return NULL;
	phead->data = a[0];
	head = phead;
	for (int i = 1; i < n; i++) {
		newnode = new node;
		newnode->data = a[i];
		newnode->next = NULL;
		phead->next = newnode;
		phead = phead->next;
	}
	return head;
}

void PrintList(link head) {
	link phead = new node;
	phead = head;
	cout << "链表元素如下: " << endl;
	while (phead != NULL) {
		cout << phead->data << "->";
		head = phead;
		phead = phead->next;  //phead按序往后遍历整个链表
		if (!phead) cout << "NULL" << endl;
	}
}

int main() {
	int position_data, data;
	link head, phead;
	int n=5;
	cout << "请输入初始链表元素个数: " << endl;
	//cin >> n;
	int a[5];
	cout << "请依次输入链表元素: ";
	for (int i = 0; i < n; i++) cin >> a[i];
	head = CreateList(a, n);
	PrintList(head);
	cout << "请输入预插入位置之前的元素和要插入的元素（例：5 8）: ";
	cin >> position_data >> data;
	head = InsertNode(head, position_data, data);
	cout << "插入之后的";
	PrintList(head);
	cout << "请输入想删除的链表元素: ";
	cin >> position_data;
	head = DeleteNode(head, position_data);
	cout << "删除之后的";
	PrintList(head);
	cout << "反转之后的";
	head = InvertList(head);
	PrintList(head);
	return 0;
}

反转双链表

双向链表的反转，就是交换每个节点的前向指针和后向指针，然后调整链表的头指针和尾指针。
构建双向链表节点,与单链表节点相比，多了一个指向前一个元素的指针域。

struct Node{
	int data;
	Node* next;
	Node* prev;
	};

完整代码

#include <iostream>
 
struct Node
{
	int data;
	Node *next; // 指向下一个节点
	Node *prev; // 指向前一个节点
};
 
//对链表进行反转
void reverse(Node **head)
{
	Node *temp = NULL;
	Node *current = *head;
 
	//交换每个节点的后向指针和前向指针
	// 1-->2-->3, 假设2为current.
	while (current != NULL)
	{
		temp = current->prev; //temp=1
		current->prev = current->next; //3-->2
		current->next = temp;            //2-->1 
		current = current->prev; //3-->2-->1, current变为3，继续往后循环。
	}
	//总结：先处理前向指针，然后处理后向指针。这些操作都只对当前节点(current),不涉及其它节点。
	//1.缓存前向指针
	//2.将后向指针赋值给前向指针
	//3.将缓存的前者指针，赋值给后向指针
	//4.当前节点指针移动到下一个待处理节点
 
	//修改头指针之前，先检测链表是否为空链表，或者只有一个节点的情况
	if (temp != NULL)
		*head = temp->prev;
}
 
// 给定链表的头指针(head)以及一个整数，插入一个新的节点至链表的头部  
// 之所以传入双指针，因为函数中需要修改链表  
void push(Node** head, int newData)
{
	//1. 分配新节点内存  
	Node* newNode = new Node;
 
	//2. 赋值  
	newNode->data = newData;
 
	//3. 将原始头节点做为新节点的后向指针，而前向指针置为NULL  
	newNode->next = (*head);
	newNode->prev = NULL;
 
	//4. 将原始头节点的前向指针置为新的节点  
	if ((*head) != NULL)
		(*head)->prev = newNode;
 
	//5. 将头指针置为新的节点  
	(*head) = newNode;
}
 
void printList(Node *head)
{
	while (head != NULL)
	{
		std::cout<<" "<<head->data<<" ";
		head = head->next;
	}
	std::cout << std::endl;
}
 
 
int main()
{
	//初始化链表为：10<->8<->6<->4<->2<->0
	Node* head = NULL;
	push(&head, 0);
	push(&head, 2);
	push(&head, 4);
	push(&head, 6);
	push(&head, 8);
	push(&head, 10);
 
	std::cout << "Original DLL is: ";
	printList(head);
 
	reverse(&head);
 
	std::cout << "Reversed DLL is: ";
	printList(head);
	return 0;
}