Leecode 入门--单链表-- 递归操作

最新推荐文章于 2023-07-21 10:41:24 发布

小韭菜~

最新推荐文章于 2023-07-21 10:41:24 发布

阅读量562

点赞数

分类专栏： leecode 数据结构与算法

本文链接：https://blog.csdn.net/TI__boyue/article/details/118489128

版权

数据结构与算法同时被 2 个专栏收录

6 篇文章 0 订阅

订阅专栏

leecode

3 篇文章 0 订阅

订阅专栏

反转单链表

对于递归算法，最重要的就是明确递归函数的定义
对 reverseAll 函数定义：输入一个节点head，将「以head为起点」的链表反转，并返回反转之后的头结点。

链接
节点结构：

typedef int elemtype;
typedef struct node{
	elemtype data;
	struct node *next;
}node,*link_node;

1.递归反转整个链表

link_node reverseAll(link_node head){
	if(head->next == NULL) return head;
	link_node new_head=reverseAll(head->next);
	head->next->next = head;
	head->next = NULL;
	
	return new_head;
}

2.反转链表前 N 个节点

link_node successor = NULL;
link_node reverseN(link_node head,int n){
	if(n==1){
		successor =  head->next;
		return head;
	}
	
	link_node new_n_head = reverseN(head->next,n-1);
	head->next->next = head;
	head->next = successor;
	return new_n_head;
}

3.反转链表的一部分

问题转换，将该问题转换成反转前n节点：

link_node reverseBetween(link_node head,int m,int n){ // [m,n]
	if(m==1){
		return reverseN(head,n);
	}
	head->next = reverseBetween(head->next,m-1,n-1);
	return head;
}

整代码

#include<iostream>
using namespace std;

typedef int elemtype;
typedef struct node{
	elemtype data;
	struct node *next;
}node,*link_node;

void create_node_list(link_node head) {
	link_node p, q;

	elemtype array[] = {1,2,3,4,5,6,7,8,9,10};
	int length = sizeof(array) / sizeof(array[0]);
	q = head;
	head->data = length;
	head->next = NULL;

	for (int i = 0; i < length; i++) {
		p = new node;
		p->data = array[i];
		p->next = NULL; // 尾插法
		q->next = p;
		q = p;
	}
}
void out_elem(node head_node) {
	link_node p = head_node.next;
	while (p) {
		cout << p->data << ' ';
		p = p->next;
	}
	cout << endl;
}

link_node reverseAll(link_node head);
link_node reverseN(link_node head,int n);
link_node reverseBetween(link_node head,int m,int n);
int main(){
	node head_node; // 头节点
	cout<<"原链表"<<endl;
	create_node_list(&head_node);
	out_elem(head_node);
	cout<<"完全反转"<<endl;
	head_node.next=reverseAll(head_node.next);
	out_elem(head_node);
	cout<<"反转前N个：4"<<endl;
	head_node.next=reverseN(head_node.next,4);
	out_elem(head_node);
	cout<<"反转一部分[5-9]"<<endl;
	head_node.next=reverseBetween(head_node.next,5,9);
	out_elem(head_node);
	
	return 0;
}

link_node reverseAll(link_node head){
	if(head->next == NULL) return head;
	link_node new_head=reverseAll(head->next);
	head->next->next = head;
	head->next = NULL;
	
	return new_head;
}

link_node successor = NULL;
link_node reverseN(link_node head,int n){
	if(n==1){
		successor =  head->next;
		return head;
	}
	
	link_node new_n_head = reverseN(head->next,n-1);
	head->next->next = head;
	head->next = successor;
	
	return new_n_head;
}

link_node reverseBetween(link_node head,int m,int n){ // [m,n]
	if(m==1){
		return reverseN(head,n);
	}
	head->next = reverseBetween(head->next,m-1,n-1);
	return head;
}

在这里插入图片描述

K 个一组反转链表

链接
在这里插入图片描述

问题剖析：
该问题属于迭代问题：前n个节点反转，剩余链表继续对前n个节点反转（子问题）

reverseKGroup 函数定义：对前n个节点进行反转；反转后的节点与剩余链表进行拼接
递归终止条件：剩余链表元素个数少于 k 个

link_node reverseKGroup(link_node head, int k) {
	if (head == NULL) return head;
	
	link_node a, b;
	a = b = head;
	for (int i = 0; i < k; i++) {
		if (b == NULL) return head;
		b = b->next;
	}
	// 反转前k个
	link_node new_=reverseIteration(a, b);
	a->next = reverseKGroup(b, k);

	return new_;
}

迭代法反转

link_node reverseIteration(link_node a, link_node b) { // [a,b)
	link_node pre, cur, nxt;
	pre = NULL; cur = nxt = a;
	while (cur != b) {
		nxt = cur->next;
		cur->next = pre;
		pre = cur;
		cur = nxt;
	}
	return pre;
}

整代码

#include<iostream>
using namespace std;

typedef int elemtype;
typedef struct node {
	elemtype data;
	struct node* next;
} node, *link_node;

void creatListNode(link_node head);
void outElem(link_node head);
link_node reverseKGroup(link_node head, int k);
link_node reverseIteration(link_node a, link_node b);
int main() {

	node head_node;
	cout << "原链表" << endl;
	creatListNode(&head_node);
	outElem(&head_node);
	cout << "k个元素一组反转:3" << endl;
	head_node.next=reverseKGroup(head_node.next,3);
	outElem(&head_node);

	return 0;
}

void creatListNode(link_node head) {
	link_node p, q;
	elemtype arr[] = { 1,2,3,4,5,6,7,8,9,10};
	int length = sizeof(arr) / sizeof(arr[0]);
	head->data = length;
	head->next = NULL;
	q = head;
	for (int i = 0; i < length; i++) {
		p = new node;
		p->data = arr[i];
		p->next = NULL;

		q->next = p;
		q = p;
	}
}
void outElem(link_node head) {
	link_node p = head->next;
	while (p) {
		cout << p->data << ' ';
		p = p->next;
	}
	cout << endl;
}

link_node reverseKGroup(link_node head, int k) {
	if (head == NULL) return head;
	
	link_node a, b; // 窗口指针
	a = b = head;
	for (int i = 0; i < k; i++) {
		if (b == NULL) return head;
		b = b->next;
	}
	// 反转前k个
	 // 剩余链表段的头部；第一层递归即整个链表的新头部
	link_node new_=reverseIteration(a, b);
	// 反转后 a 为反转链表的尾部，与剩余链表 连接
	a->next = reverseKGroup(b, k); 

	return new_;
}
link_node reverseIteration(link_node a, link_node b) { // [a,b)
	link_node pre, cur, nxt;
	pre = NULL; cur = nxt = a;
	while (cur != b) {
		nxt = cur->next;
		cur->next = pre;
		pre = cur;
		cur = nxt;
	}
	return pre;
}

在这里插入图片描述

判断回文单链表

链接

回文串就是正着读和反着读都一样的字符串
寻找回文串的核心思想是从中心向两端扩展

后序递归方式

link_node left_=NULL;
bool isPalindrome(link_node head) {
	left_ = head;
	return traverse(left_);
}

bool traverse(link_node right) {
	if (right == NULL) return true;
	bool res = traverse(right->next);
	// 后序遍历
	res = res && (right->data == left_->data);
	left_ = left_->next;
	return res;
}

空间复杂度优化 O(N)->O(1)

由于上述代码采用递归方式判断回文链表，须额外的栈空间，空间复杂度为O(N)

优化代码：
采用 快慢指针 找到链表中点 (慢指针单步，快指针 2步) ; 通过判断快指针是否满足(fast!=null 且 fast->next != null) ，看是否找到中点（slow指向）
将 后半段 链表进行反转
定义 left right 两指针向中间遍历比较；

在这里插入图片描述

bool isPalindromeOptimize(link_node head) { // 快慢指针
	link_node fast, slow;
	link_node p,q; // 用于复原 链表结构； p,q 分别指向需反转链表段的首尾 
	p = NULL; // 注释 会提示未初始化变量 ； 
	// 因为 p 的初始化都放在 存在判断语句的表示式中，在p->next位置会提示未初始化变量
	fast = slow = head;
	while (fast != NULL&&fast->next != NULL) { // 奇偶数 
		p = slow;  // 用于元素个数为偶数时 
		slow = slow->next;	// 一步
		fast = fast->next->next; //两步
	} 

	if (fast != NULL) {
		p = slow; // 用于元素个数为奇数时 ； 注意 p 指向，易成环
		slow = slow->next; // 奇数时，循环结束low指向中间元素，需右移一步
	}
	// 反转后半部分链表 
	link_node left_ = head;
	link_node right = reverse(slow); // 改变了原链表结构
	q = right;
	while (right != NULL) {
		if (left_->data != right->data) 
		{
			p->next = reverse(q);
			return false;
		}
		left_ = left_->next;
		right = right->next;
	}
	
	p->next = reverse(q); // 还原链表结构
	return true;
}

link_node reverse(link_node head) {
	link_node pre, cur, nxt;
	pre = NULL; cur = nxt = head;
	while (cur != NULL) {
		nxt = cur->next;
		cur->next = pre;
		pre = cur;
		cur = nxt;
	}
	return pre;
}

整代码

#include<iostream>
using namespace std;

typedef int elemtype;
typedef struct node {
	elemtype data;
	struct node* next;
} node, *link_node;

void creatListNode(link_node head);
void outElem(link_node head);
bool isPalindrome(link_node head);
bool traverse(link_node right);
bool isPalindromeOptimize(link_node head);
link_node reverse(link_node head);

int main() {

	node head_node;
	cout << "原链表" << ' ';
	creatListNode(&head_node);
	outElem(&head_node);
	cout << "是否为回文链表： ";
	isPalindrome(head_node.next) ? cout << "True" << endl : cout << "False" << endl;
	cout << "优化后： ";
	isPalindromeOptimize(head_node.next) ? cout << "True" << endl : cout << "False" << endl;
	cout << "修改后复原: " ;
	outElem(&head_node);

	return 0;
}

void creatListNode(link_node head) {
	link_node p, q;
	elemtype arr[] = {1,2,3,4,6,5,4,3,2,1};
	int length = sizeof(arr) / sizeof(arr[0]);
	head->data = length;
	head->next = NULL;
	q = head;
	for (int i = 0; i < length; i++) {
		p = new node;
		p->data = arr[i];
		p->next = NULL;

		q->next = p;
		q = p;
	}
}
void outElem(link_node head) {
	link_node p = head->next;
	while (p) {
		cout << p->data << ' ';
		p = p->next;
	}
	cout << endl;
}

link_node left_=NULL;
bool isPalindrome(link_node head) {
	left_ = head;
	return traverse(left_);
}

bool traverse(link_node right) {
	if (right == NULL) return true;
	bool res = traverse(right->next);
	// 后序遍历
	res = res && (right->data == left_->data);
	left_ = left_->next;
	return res;
}

bool isPalindromeOptimize(link_node head) { // 快慢指针
	link_node fast, slow;
	link_node p,q; // 用于复原 链表结构； p,q 分别指向需反转链表段的首尾 
	p = NULL; // 注释 会提示未初始化变量 ； 
	// 因为 p 的初始化都放在 存在判断语句的表示式中，在p->next位置会提示未初始化变量
	fast = slow = head;
	while (fast != NULL&&fast->next != NULL) { // 奇偶数 
		p = slow;  // 用于元素个数为偶数时 
		slow = slow->next;	// 一步
		fast = fast->next->next; //两步
	} 

	if (fast != NULL) {
		p = slow; // 用于元素个数为奇数时 ； 注意 p 指向，易成环
		slow = slow->next; // 奇数时，循环结束low指向中间元素，需右移一步
	}
	// 反转后半部分链表 
	link_node left_ = head;
	link_node right = reverse(slow); // 改变了原链表结构
	q = right;
	while (right != NULL) {
		if (left_->data != right->data) 
		{
			p->next = reverse(q);
			return false;
		}
		left_ = left_->next;
		right = right->next;
	}
	
	p->next = reverse(q); // 还原链表结构
	return true;
}

link_node reverse(link_node head) {
	link_node pre, cur, nxt;
	pre = NULL; cur = nxt = head;
	while (cur != NULL) {
		nxt = cur->next;
		cur->next = pre;
		pre = cur;
		cur = nxt;
	}
	return pre;
}

偶数个数：
在这里插入图片描述
奇数个数：

非回文链表：

C++中substr函数的用法

小韭菜~

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
1
评论
Leecode 入门--单链表-- 递归操作

反转单链表对于递归算法，最重要的就是明确递归函数的定义对 reverseAll 函数定义：输入一个节点head，将「以head为起点」的链表反转，并返回反转之后的头结点。链接节点结构：typedef int elemtype;typedef struct node{ elemtype data; struct node *next;}node,*link_node;1.递归反转整个链表link_node reverseAll(link_node head){ if(head-&
复制链接

扫一扫

专栏目录