双向链表、双向循环链表

目录

多级双向链表

力扣 430. 扁平化多级双向链表

双向循环链表

力扣 426. 将二叉搜索树转化为排序的双向链表

---

多级双向链表

力扣 430. 扁平化多级双向链表

你会得到一个双链表，其中包含的节点有一个下一个指针、一个前一个指针和一个额外的?子指针?。这个子指针可能指向一个单独的双向链表，也包含这些特殊的节点。这些子列表可以有一个或多个自己的子列表，以此类推，以生成如下面的示例所示的?多层数据结构?。

给定链表的头节点?head?，将链表?扁平化?，以便所有节点都出现在单层双链表中。让?curr?是一个带有子列表的节点。子列表中的节点应该出现在扁平化列表中的?curr?之后?和?curr.next?之前?。

返回?扁平列表的?head?。列表中的节点必须将其?所有?子指针设置为?null?。

?

示例 1：

输入：head = [1,2,3,4,5,6,null,null,null,7,8,9,10,null,null,11,12]
输出：[1,2,3,7,8,11,12,9,10,4,5,6]
解释：输入的多级列表如上图所示。
扁平化后的链表如下图：

示例 2：

输入：head = [1,2,null,3]
输出：[1,3,2]
解释：输入的多级列表如上图所示。
扁平化后的链表如下图：

示例 3：

输入：head = []
输出：[]
说明：输入中可能存在空列表。

?

提示：

• 节点数目不超过?1000
• 1 <= Node.val <= 105

?

如何表示测试用例中的多级链表？

以?示例 1?为例：

 1---2---3---4---5---6--NULL
         |
         7---8---9---10--NULL
             |
             11--12--NULL

序列化其中的每一级之后：

[1,2,3,4,5,6,null]
[7,8,9,10,null]
[11,12,null]

为了将每一级都序列化到一起，我们需要每一级中添加值为 null 的元素，以表示没有节点连接到上一级的上级节点。

[1,2,3,4,5,6,null]
[null,null,7,8,9,10,null]
[null,11,12,null]

合并所有序列化结果，并去除末尾的 null 。

[1,2,3,4,5,6,null,null,null,7,8,9,10,null,null,11,12]

class Solution {
public:
	Node* flatten(Node* head) {
		return flatten2(head)[0];
	}
	vector<Node*> flatten2(Node* head) {
		vector<Node*>ans;
		ans.push_back(head);
		auto p = head;
		auto p2 = p;
		while (p) {
			p2 = p;
			if (p->child) {
				vector<Node*>cs = flatten2(p->child);
				cs[0]->prev = p;
				if (p->next) {
					cs[1]->next = p->next;
					p->next->prev = cs[1];
				}
				p->next = cs[0];
				p->child = nullptr;
			}
			p = p->next;
		}
		ans.push_back(p2);
		return ans;
	}
};

双向循环链表

力扣 426. 将二叉搜索树转化为排序的双向链表

将一个 二叉搜索树 就地转化为一个 已排序的双向循环链表 。

对于双向循环列表，你可以将左右孩子指针作为双向循环链表的前驱和后继指针，第一个节点的前驱是最后一个节点，最后一个节点的后继是第一个节点。

特别地，我们希望可以 就地 完成转换操作。当转化完成以后，树中节点的左指针需要指向前驱，树中节点的右指针需要指向后继。还需要返回链表中最小元素的指针。

示例 1：

输入：root = [4,2,5,1,3]?

输出：[1,2,3,4,5]

解释：下图显示了转化后的二叉搜索树，实线表示后继关系，虚线表示前驱关系。

示例 2：

输入：root = [2,1,3]
输出：[1,2,3]
示例 3：

输入：root = []
输出：[]
解释：输入是空树，所以输出也是空链表。
示例 4：

输入：root = [1]
输出：[1]
?

提示：

-1000 <= Node.val <= 1000
Node.left.val < Node.val < Node.right.val
Node.val 的所有值都是独一无二的
0 <= Number of Nodes <= 2000

//创建单节点双向循环链表
Node* getList(int val = 0)
{
	Node* p = new Node;
	p->left = p, p->right = p, p->val = val;
	return p;
}
//合并双向循环链表
void merge2list(Node* p1, Node* p2)
{
	if (!p1 || !p2)return;
	p1->left->right = p2, p2->left->right = p1;
	Node* tmp = p2->left;
	p2->left = p1->left;
	p1->left = tmp;
}

class Solution {
public:
	Node* treeToDoublyList(Node* root) {
		if (!root)return NULL;
		Node* n1 = getList(root->val);
		if (root->left) {
			Node* n2 = treeToDoublyList(root->left);
			merge2list(n2, n1);
			n1 = n2;
		}
		if (root->right) {
			Node* n3 = treeToDoublyList(root->right);
			merge2list(n1, n3);
		}
		return n1;
	}
};