1. 排序二叉树(Ordered Binary Tree)

2. 循环双向链表(Circular Doubly Linked List)

6. 代码实现

#include <iostream>

struct Node
{
	int data;
	struct Node *small;
	struct Node *large;
};

//辅助函数-合并两个节点。
void joinNode(Node* a, Node * b)
{
	/*
	a
	 	  	   b
	*/
	a->large = b;
	b->small = a;
}

//辅助函数 - 合并两个循环双向链表
Node* appendList(Node *a, Node *b)
{
	Node *aLast, *bLast;
	if (a == NULL)
		return b;
	if (b == NULL)
		return a;

	aLast = a->small;
	bLast = b->small;

	joinNode(aLast, b);
	joinNode(bLast, a);

	return a;
}

//递归函数
//将一棵已排序二叉树转换为一个循环双向链表，并返回链表。
Node* treeToList(Node *root)
{
	Node *aList, *bList;

	if (root == NULL)
		return NULL;

	aList = treeToList(root->small);
	bList = treeToList(root->large);

	//构造一个长度为length-1的链表
	root->small = root;
	root->large = root;

	aList = appendList(aList, root);
	aList = appendList(aList, bList);

	return aList;
}

Node* createNode(int data)
{
	Node * node = new Node;
	node->data = data;
	node->small = NULL;
	node->large = NULL;
	return node;
}

void insertNode(Node **rootRef, int data)
{
	Node *root = *rootRef;
	if (root == NULL)
		*rootRef = createNode(data);
	else
	{
		if (data <= root->data)
			insertNode(&(root->small), data);
		else
			insertNode(&(root->large), data);
	}
}

void printList(const Node *head)
{
	const Node *current = head;
	while (current != NULL)
	{
		std::cout << current->data << " ";
		current = current->large;
		if (current == head)   //已完成了一次链表遍历
			break;
	}
	std::cout << std::endl;
}

int main()
{
	Node *root = NULL, *head = NULL;

	//4-->2-->1-->3-->5
	insertNode(&root, 4);
	insertNode(&root, 2);
	insertNode(&root, 1);
	insertNode(&root, 3);
	insertNode(&root, 5);

	head = treeToList(root);

	printList(head);

	return 0;
}