排序二叉树转换为双向链表

排序二叉树转换为双向链表的算法实现与测试
 
public class TreeNode {

	public int data;
	public TreeNode left;
	public TreeNode right;
	public TreeNode(int data)
	{
		this.data=data;
		left=null;
		right=null;
	}
}


public class Tree {
 public TreeNode root;
 //排序二叉树中插入节点
 public void add(int data)
 {
	 TreeNode node=new TreeNode(data);
	 if(root==null)
		 root=node;
	 else
	 {
		 TreeNode current=root;
		 TreeNode parent=root;
		 boolean isLeft=true;
		 while(current!=null)
		 {
			 parent=current;
			 if(data<current.data)
			 {
				 isLeft=true;
				 current=current.left;
			 }
			 else
			 {
				 isLeft=false;
				 current=current.right;
			 }
		 }
		 if(isLeft)
			 parent.left=node;
		 else
			 parent.right=node;
	 }
 }
 
 //将两个链表合并
 public TreeNode append(TreeNode node1,TreeNode node2)
 {
	 if(node1==null)
		 return node2;
	 if(node2==null)
		 return node1;
	 TreeNode tail=node1;
	 while(tail.right!=null)
		 tail=tail.right;
	 tail.right=node2;
	 node2.left=tail;
	 return node1;
 }
 //转换
 public TreeNode convertoList(TreeNode node)
 {
	 if(node==null)
		 return null;
	 TreeNode left=convertoList(node.left);
	 TreeNode right=convertoList(node.right);//将父节点独立
	 node.left=null;
	 node.right=null;
	 left=append(left,node);
	 left=append(left,right);
	 return left;
	 
 }
 public void display(TreeNode head)
 {
	 TreeNode current=head;
	 TreeNode parent=head;
	 while(current!=null)
	 {
		 System.out.print(current.data+"  ");
		 parent=current;
		 current=current.right;
	 }
	 System.out.println();
	 while(parent!=null)
	 {
		 System.out.print(parent.data+"  ");
		 parent=parent.left;
	 }
	 
 }
}



public class Test {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Tree tree=new Tree();
		tree.add(49);
		tree.add(25);
		tree.add(55);
		tree.add(10);
		tree.add(51);
		tree.add(65);
        TreeNode head=tree.convertoList(tree.root);
        tree.display(head);
	}

}

关于排序二叉树转换为双向链表的问题,以前自己做过,只是用了一个栈,后来在金山的笔试题目里面碰到了,而且不能使用任何额外的空间,就没想起来怎么办。前些天就在网上看一些常规的算法的运算,发现了有人将算法上传了,是将排序二叉树转换为双向循环链表,貌似比现在讨论的这个问题更复杂哈。其实是比目前这个容易解决的,因为头和尾能直接找到,而对于双向链表,要找尾节点还是需要从头遍历到尾的。废话少说,先说这个算法的思路,就是先把一个节点的左右孩子分别转换为双向链表,将父节点独立之后,先将左子树的链表与父节点连在一起,然后就上面的链表跟右子树的链表连接在一起,两个链表合并的操作是,将头一个链表的尾节点与第二个链表的头节点连在一起,就可以了。

  我还做了一个测试,就是从前到后从后到前来输出链表的内容,结果证明是正确的。

二叉排序树转换为有序的双向链表的C语言实现: ```c #include <stdio.h> #include <stdlib.h> // 定义二叉树节点结构体 typedef struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; } TreeNode; // 定义双向链表节点结构体 typedef struct ListNode { int val; struct ListNode *prev; struct ListNode *next; } ListNode; // 将二叉排序树转换为有序的双向链表 ListNode* treeToList(TreeNode* root) { if (root == NULL) { return NULL; } // 将左子树转换为有序的双向链表 ListNode *leftList = treeToList(root->left); // 将右子树转换为有序的双向链表 ListNode *rightList = treeToList(root->right); // 创建当前节点的双向链表节点 ListNode *curNode = (ListNode*)malloc(sizeof(ListNode)); curNode->val = root->val; curNode->prev = NULL; curNode->next = NULL; // 将左子树的双向链表和当前节点连接起来 if (leftList != NULL) { ListNode *leftTail = leftList; while (leftTail->next != NULL) { leftTail = leftTail->next; } leftTail->next = curNode; curNode->prev = leftTail; } else { leftList = curNode; } // 将右子树的双向链表和当前节点连接起来 if (rightList != NULL) { rightList->prev = curNode; curNode->next = rightList; } return leftList; } // 创建二叉树节点 TreeNode* createNode(int val) { TreeNode *node = (TreeNode*)malloc(sizeof(TreeNode)); node->val = val; node->left = NULL; node->right = NULL; return node; } // 插入节点到二叉排序树TreeNode* insertNode(TreeNode *root, int val) { if (root == NULL) { return createNode(val); } if (val < root->val) { root->left = insertNode(root->left, val); } else { root->right = insertNode(root->right, val); } return root; } // 中序遍历二叉树 void inorderTraversal(TreeNode *root) { if (root == NULL) { return; } inorderTraversal(root->left); printf("%d ", root->val); inorderTraversal(root->right); } // 打印双向链表 void printList(ListNode *head) { ListNode *curNode = head; while (curNode != NULL) { printf("%d ", curNode->val); curNode = curNode->next; } printf("\n"); } int main() { // 创建二叉排序树 TreeNode *root = NULL; root = insertNode(root, 5); insertNode(root, 3); insertNode(root, 7); insertNode(root, 2); insertNode(root, 4); insertNode(root, 6); insertNode(root, 8); // 中序遍历二叉树 printf("Inorder traversal of binary search tree:\n"); inorderTraversal(root); printf("\n"); // 将二叉排序树转换为有序的双向链表 ListNode *head = treeToList(root); // 打印双向链表 printf("Doubly linked list:\n"); printList(head); return ; } ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值