最常见的程序员面试题(7)二叉树转链表

最新推荐文章于 2022-05-11 16:16:03 发布
最新推荐文章于 2022-05-11 16:16:03 发布
阅读量580 收藏 1
点赞数
分类专栏： 数据结构&算法
二叉树通过遍历可以用于转化成一个链表(插入构建链表)。但是如果没有而外的链表呢? 这就用到"线索化二叉树"，也就是一个二叉树(可以是排序二叉树)在座遍历(例如中序)的时候，去更新每个节点的"前驱"和"后继"的节点关系，得到一个二叉链表。然后从最左节点开始，遍历所有的"后继"节点，就得到一个二叉链表的所有数据。分别用C++和Java来实现。

(1)第一种情况，也是简单的情况，允许以侵入的方式把二叉树变成双向链表。这需要做几件事情。对于任意一个节点来说，如果左子树存在，那么左子树变成2叉链表以后，左子树的"最后的指针"指向当前节点。如果右子树存在，那么当前节点的新的右节点(也就是2叉链表的next)，就是右节点的最左元素。函数返回右子树的"最后指针"。Java程序如下:

[java] view plain copy print ?
  1. public class my{  
  2.     public static void main(String[] args){  
  3.         class node{  
  4.             node left=null;  
  5.             node right=null;  
  6.             int data=0;  
  7.             node(int d){data=d;}  
  8.             void appendLeft(node n){  
  9.                 if(left==null)left=n;  
  10.                 else left.append(n);  
  11.             }  
  12.             void appendRight(node n){  
  13.                 if(right==null)right=n;  
  14.                 else right.append(n);  
  15.             }  
  16.             void append(node n){  
  17.                 if(data>n.data)appendLeft(n);  
  18.                 else appendRight(n);  
  19.             }  
  20.             void print(){  
  21.                 if(left!=null)left.print();  
  22.                 System.out.print(","+data);  
  23.                 if(right!=null)right.print();  
  24.             }  
  25.             node helper(){//返回最后的节点   
  26.                 if(left!=null){  
  27.                     node leftPtr=left.helper();  
  28.                     leftPtr.right=this;  
  29.                 }  
  30.                 node ret=this;  
  31.                 if(right!=null){  
  32.                     ret=right.helper();  
  33.                     node rightPtr=right.LeftestNode();  
  34.                     right=rightPtr;  
  35.                 }  
  36.                 return ret;//叶子节点总是返回自身   
  37.             }  
  38.             node LeftestNode(){//叶子节点总是返回自身   
  39.                 node p=this;  
  40.                 while(p.left!=null){  
  41.                     p=p.left;  
  42.                 }  
  43.                 return p;  
  44.             }  
  45.         }  
  46.         class tree{  
  47.             node root=null;  
  48.             tree(int d){root=new node(d);}  
  49.             void append(int d){root.append(new node(d));}  
  50.             void display(){root.print();}  
  51.             void Tree2List(){  
  52.                 node leftest=root.LeftestNode();  
  53.                 root.helper();  
  54.                 while(leftest!=null){  
  55.                     System.out.print(","+leftest.data);  
  56.                     leftest=leftest.right;  
  57.                 }  
  58.             }  
  59.         }  
  60.         tree t=new tree(5);  
  61.         t.append(2);  
  62.         t.append(7);  
  63.         t.append(1);  
  64.         t.append(6);  
  65.         t.append(8);  
  66.         t.append(3);  
  67.         t.display();  
  68.         System.out.println("\n===========");  
  69.         t.Tree2List();  
  70.     }  
  71. }  
public class my{
	public static void main(String[] args){
		class node{
			node left=null;
			node right=null;
			int data=0;
			node(int d){data=d;}
			void appendLeft(node n){
				if(left==null)left=n;
				else left.append(n);
			}
			void appendRight(node n){
				if(right==null)right=n;
				else right.append(n);
			}
			void append(node n){
				if(data>n.data)appendLeft(n);
				else appendRight(n);
			}
			void print(){
				if(left!=null)left.print();
				System.out.print(","+data);
				if(right!=null)right.print();
			}
			node helper(){//返回最后的节点
				if(left!=null){
					node leftPtr=left.helper();
					leftPtr.right=this;
				}
				node ret=this;
				if(right!=null){
					ret=right.helper();
					node rightPtr=right.LeftestNode();
					right=rightPtr;
				}
				return ret;//叶子节点总是返回自身
			}
			node LeftestNode(){//叶子节点总是返回自身
				node p=this;
				while(p.left!=null){
					p=p.left;
				}
				return p;
			}
		}
		class tree{
			node root=null;
			tree(int d){root=new node(d);}
			void append(int d){root.append(new node(d));}
			void display(){root.print();}
			void Tree2List(){
				node leftest=root.LeftestNode();
				root.helper();
				while(leftest!=null){
					System.out.print(","+leftest.data);
					leftest=leftest.right;
				}
			}
		}
		tree t=new tree(5);
		t.append(2);
		t.append(7);
		t.append(1);
		t.append(6);
		t.append(8);
		t.append(3);
		t.display();
		System.out.println("\n===========");
		t.Tree2List();
	}
}

(2) 如果不允许修改2叉树本身，那么就要借助于线索化2叉树，这个会复杂一点，但是能够做到同样的效果。

分别用C++和Java实现

[cpp] view plain copy print ?
  1. #include<functional>   
  2. using namespace std;  
  3. template<class Comp>  
  4. class node{  
  5.     size_t data;  
  6.     node* pLeft;  
  7.     node* pRight;  
  8.     bool lTag;//true表示node*pLeft/pRight是线索,false表示指针   
  9.     bool rTag;  
  10. public:  
  11.     node( size_t d ):  
  12.         data(d),  
  13.         pLeft(nullptr),  
  14.         pRight(nullptr),  
  15.         lTag(true),  
  16.         rTag(true)  
  17.     {}  
  18.     void append( node* p ){  
  19.         if( Comp()( p->data, data ) ){  
  20.             appendLeft( p );  
  21.         }else{  
  22.             appendRight( p );  
  23.         }  
  24.     }  
  25.     void appendLeft( node* p ){  
  26.         if( pLeft == nullptr ){  
  27.             pLeft = p;  
  28.         }else{  
  29.             pLeft->append( p );  
  30.         }  
  31.         lTag=false;  
  32.     }  
  33.     void appendRight( node* p ){  
  34.         if( pRight == nullptr ){  
  35.             pRight = p;  
  36.         }else{  
  37.             pRight->append( p );  
  38.         }  
  39.         rTag=false;  
  40.     }  
  41.     ~node(){  
  42.         if(pLeft && (lTag==false))delete pLeft;  
  43.         if(pRight&& (rTag==false))delete pRight;  
  44.     }  
  45.     void printTree(){//中序遍历打印   
  46.         if(pLeft)pLeft->printTree();  
  47.         printf("%d,",data);  
  48.         if(pRight)pRight->printTree();  
  49.     }  
  50.     void ToThreadedBinarytree(){//中序线索2叉树   
  51.         static node* pre=nullptr;  
  52.         if(pLeft){  
  53.             pLeft->ToThreadedBinarytree();  
  54.         }else{  
  55.             pLeft=pre;  
  56.             lTag=true;  
  57.         }  
  58.         if(pre){  
  59.             if(pre->pRight==nullptr){  
  60.                 pre->pRight=this;  
  61.                 pre->rTag=true;  
  62.             }           
  63.         }  
  64.         pre=this;  
  65.         if(pRight){  
  66.             pRight->ToThreadedBinarytree();  
  67.         }  
  68.     }  
  69.     void printList(){  
  70.         node*p=this;  
  71.         while(p->pLeft && (p->lTag==false)){  
  72.             p=p->pLeft;  
  73.         }//找到当前树的最左节点   
  74.         p->printThreaded();  
  75.     }  
  76.     void printThreaded(){//寻找后继结点并打印   
  77.         printf("%d,",data);  
  78.         if(rTag){  
  79.             if(pRight)pRight->printThreaded();  
  80.         }else{  
  81.             if(pRight)pRight->printList();  
  82.         }  
  83.     }  
  84. };  
  85. template<class T>  
  86. struct sortedTree{  
  87.     node<T>* pRoot;  
  88.     sortedTree():pRoot(nullptr){}  
  89.     ~sortedTree(){if(pRoot)delete pRoot;}  
  90.     void append( size_t n ){  
  91.         node<T>* p=new node<T>(n);  
  92.         if( pRoot == nullptr ){  
  93.             pRoot = p;  
  94.         }else{  
  95.             pRoot->append( p );  
  96.         }  
  97.     }  
  98.     void printTree(){  
  99.         if(pRoot)pRoot->printTree();  
  100.     }  
  101.     void convertList(){  
  102.         if(pRoot){  
  103.             pRoot->ToThreadedBinarytree();  
  104.             printf("\n");  
  105.             pRoot->printList();  
  106.         }  
  107.     }  
  108. };  
  109. int main(int argc, char* const argv[]){  
  110.     sortedTree< less<size_t> > tree;  
  111.     tree.append( 3 );  
  112.     tree.append( 7 );  
  113.     tree.append( 4 );  
  114.     tree.append( 2 );  
  115.     tree.append( 5 );  
  116.     tree.append( 1 );  
  117.     tree.append( 6 );  
  118.     tree.printTree();  
  119.     printf("\n");  
  120.     tree.convertList();//打印线索化的二叉树   
  121.     printf("\n");  
  122.     return 0;  
  123. }  
#include<functional>
using namespace std;
template<class Comp>
class node{
    size_t data;
    node* pLeft;
    node* pRight;
    bool lTag;//true表示node*pLeft/pRight是线索,false表示指针
    bool rTag;
public:
    node( size_t d ):
        data(d),
        pLeft(nullptr),
        pRight(nullptr),
        lTag(true),
        rTag(true)
    {}
    void append( node* p ){
        if( Comp()( p->data, data ) ){
            appendLeft( p );
        }else{
            appendRight( p );
        }
    }
    void appendLeft( node* p ){
        if( pLeft == nullptr ){
            pLeft = p;
        }else{
            pLeft->append( p );
        }
        lTag=false;
    }
    void appendRight( node* p ){
        if( pRight == nullptr ){
            pRight = p;
        }else{
            pRight->append( p );
        }
        rTag=false;
    }
    ~node(){
        if(pLeft && (lTag==false))delete pLeft;
        if(pRight&& (rTag==false))delete pRight;
    }
    void printTree(){//中序遍历打印
        if(pLeft)pLeft->printTree();
        printf("%d,",data);
        if(pRight)pRight->printTree();
    }
    void ToThreadedBinarytree(){//中序线索2叉树
        static node* pre=nullptr;
        if(pLeft){
            pLeft->ToThreadedBinarytree();
        }else{
            pLeft=pre;
            lTag=true;
        }
        if(pre){
            if(pre->pRight==nullptr){
                pre->pRight=this;
                pre->rTag=true;
            }         
        }
        pre=this;
        if(pRight){
            pRight->ToThreadedBinarytree();
        }
    }
    void printList(){
        node*p=this;
        while(p->pLeft && (p->lTag==false)){
            p=p->pLeft;
        }//找到当前树的最左节点
        p->printThreaded();
    }
    void printThreaded(){//寻找后继结点并打印
        printf("%d,",data);
        if(rTag){
            if(pRight)pRight->printThreaded();
        }else{
            if(pRight)pRight->printList();
        }
    }
};
template<class T>
struct sortedTree{
    node<T>* pRoot;
    sortedTree():pRoot(nullptr){}
    ~sortedTree(){if(pRoot)delete pRoot;}
    void append( size_t n ){
        node<T>* p=new node<T>(n);
        if( pRoot == nullptr ){
            pRoot = p;
        }else{
            pRoot->append( p );
        }
    }
    void printTree(){
        if(pRoot)pRoot->printTree();
    }
    void convertList(){
        if(pRoot){
            pRoot->ToThreadedBinarytree();
            printf("\n");
            pRoot->printList();
        }
    }
};
int main(int argc, char* const argv[]){
    sortedTree< less<size_t> > tree;
    tree.append( 3 );
    tree.append( 7 );
    tree.append( 4 );
    tree.append( 2 );
    tree.append( 5 );
    tree.append( 1 );
    tree.append( 6 );
    tree.printTree();
    printf("\n");
    tree.convertList();//打印线索化的二叉树
    printf("\n");
    return 0;
}
[java] view plain copy print ?
  1. public class TreeToList{  
  2.     static class node{  
  3.         node pLeft;  
  4.         node pRight;  
  5.         boolean lTag;//true代表是线索   
  6.         boolean rTag;  
  7.         int data;  
  8.         node(int d){  
  9.             data=d;  
  10.             pLeft=null;  
  11.             pRight=null;  
  12.             lTag=false;  
  13.             rTag=false;  
  14.         }  
  15.         void append(node n){  
  16.             if(data>n.data){  
  17.                 appendLeft(n);  
  18.             }  
  19.             else{  
  20.                 appendRight(n);  
  21.             }  
  22.         }  
  23.         void appendLeft(node n){  
  24.             if(pLeft==null){  
  25.                 pLeft=n;  
  26.             }  
  27.             else{  
  28.                 pLeft.append(n);  
  29.             }  
  30.             lTag=false;  
  31.         }  
  32.         void appendRight(node n){  
  33.             if(pRight==null){  
  34.                 pRight=n;  
  35.             }  
  36.             else{  
  37.                 pRight.append(n);  
  38.             }  
  39.             rTag=false;  
  40.         }  
  41.         void printNode(){  
  42.             if(pLeft !=null){  
  43.                 pLeft.printNode();  
  44.             }  
  45.             System.out.println(","+data);  
  46.             if(pRight!=null){  
  47.                 pRight.printNode();  
  48.             }  
  49.         }  
  50.         static node pre;  
  51.         static{  
  52.             pre=null;  
  53.         }  
  54.         void ToThreadedBinaryTree(){  
  55.             if(pLeft!=null){  
  56.                 pLeft.ToThreadedBinaryTree();  
  57.             }else{  
  58.                 pLeft=pre;  
  59.                 lTag=true;  
  60.             }  
  61.             if(pre!=null){  
  62.                 if(pre.pRight==null){  
  63.                     pre.pRight=this;  
  64.                     pre.rTag=true;  
  65.                 }  
  66.             }  
  67.             pre=this;  
  68.             if(pRight!=null){  
  69.                 pRight.ToThreadedBinaryTree();  
  70.             }  
  71.         }  
  72.         void printList(){  
  73.             node p=this;  
  74.             while(p.pLeft!=null && p.lTag==false){  
  75.                 p=p.pLeft;  
  76.             }//找到当前树的最左节点   
  77.             p.printThreaded();  
  78.         }  
  79.         void printThreaded(){  
  80.             System.out.println(","+data);  
  81.             if(rTag){  
  82.                 if(pRight!=null){  
  83.                     pRight.printThreaded();  
  84.                 }  
  85.             }else{  
  86.                 if(pRight!=null){  
  87.                     pRight.printList();  
  88.                 }  
  89.             }  
  90.         }  
  91.     }//end class node   
  92.     static class BTree{  
  93.         node pRoot;  
  94.         void append(node n){  
  95.             if(pRoot==null){  
  96.                 pRoot=n;  
  97.             }  
  98.             else{  
  99.                 pRoot.append(n);  
  100.             }  
  101.         }  
  102.         void printTree(){  
  103.             if(pRoot!=null){  
  104.                 pRoot.printNode();  
  105.             }  
  106.         }  
  107.         void convertList(){  
  108.             if(pRoot!=null){  
  109.                 pRoot.ToThreadedBinaryTree();  
  110.                 pRoot.printList();  
  111.             }  
  112.         }  
  113.     }//end class BTree   
  114.   
  115.     public static void main(String[] args) {  
  116.         BTree t=new BTree();  
  117.         t.append(new node(3));  
  118.         t.append(new node(7));  
  119.         t.append(new node(4));  
  120.         t.append(new node(2));  
  121.         t.append(new node(5));  
  122.         t.append(new node(1));  
  123.         t.append(new node(6));  
  124.         t.printTree();  
  125.         System.out.println("========");  
  126.         t.convertList();  
  127.     }  
  128. }  
public class TreeToList{
	static class node{
		node pLeft;
		node pRight;
		boolean lTag;//true代表是线索
		boolean rTag;
		int data;
		node(int d){
			data=d;
			pLeft=null;
			pRight=null;
			lTag=false;
			rTag=false;
		}
		void append(node n){
			if(data>n.data){
				appendLeft(n);
			}
			else{
				appendRight(n);
			}
		}
		void appendLeft(node n){
			if(pLeft==null){
				pLeft=n;
			}
			else{
				pLeft.append(n);
			}
			lTag=false;
		}
		void appendRight(node n){
			if(pRight==null){
				pRight=n;
			}
			else{
				pRight.append(n);
			}
			rTag=false;
		}
		void printNode(){
			if(pLeft !=null){
				pLeft.printNode();
			}
			System.out.println(","+data);
			if(pRight!=null){
				pRight.printNode();
			}
		}
		static node pre;
		static{
			pre=null;
		}
		void ToThreadedBinaryTree(){
			if(pLeft!=null){
				pLeft.ToThreadedBinaryTree();
			}else{
				pLeft=pre;
				lTag=true;
			}
			if(pre!=null){
				if(pre.pRight==null){
					pre.pRight=this;
					pre.rTag=true;
				}
			}
			pre=this;
			if(pRight!=null){
				pRight.ToThreadedBinaryTree();
			}
		}
		void printList(){
			node p=this;
			while(p.pLeft!=null && p.lTag==false){
				p=p.pLeft;
			}//找到当前树的最左节点
			p.printThreaded();
		}
		void printThreaded(){
			System.out.println(","+data);
			if(rTag){
				if(pRight!=null){
					pRight.printThreaded();
				}
			}else{
				if(pRight!=null){
					pRight.printList();
				}
			}
		}
	}//end class node
	static class BTree{
		node pRoot;
		void append(node n){
			if(pRoot==null){
				pRoot=n;
			}
			else{
				pRoot.append(n);
			}
		}
		void printTree(){
			if(pRoot!=null){
				pRoot.printNode();
			}
		}
		void convertList(){
			if(pRoot!=null){
				pRoot.ToThreadedBinaryTree();
				pRoot.printList();
			}
		}
	}//end class BTree

	public static void main(String[] args) {
		BTree t=new BTree();
		t.append(new node(3));
		t.append(new node(7));
		t.append(new node(4));
		t.append(new node(2));
		t.append(new node(5));
		t.append(new node(1));
		t.append(new node(6));
		t.printTree();
		System.out.println("========");
		t.convertList();
	}
}
zealot_2002
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树与链表之间的转换
ashfiqa的博客
10-13 1823
一、二叉树与双链表之间的转换 牛客网链接：转换问题。 1、
红黑树的插入与删除
qq_41078889的博客
09-22 392
红黑树的性质： 红黑树每一个节点都是有颜色的，不是黑色就是红色。 根节点必须为黑色。 所有叶子节点都为黑色，叶子节点是null，不存储实际数据。 每个红色的节点必须要有两个黑色的子节点，或者说每个叶子结点到根节点的所有路径上不能有连续的红色节点。 从根节点开始到任意叶子节点的路径上，黑色节点的数量必须是一致的。 节点的左右高度差最多不能超过两倍。 ...
java 如何卸载qq_java二叉树删除如何操作？
weixin_28946193的博客
02-16 118
今天所讲的是二叉树的删除，小伙伴们点进来，肯定是对二叉树有说了解的吧啊，首先学习二叉树删除，建议先了解诶二叉树的建立，遍历，插入和查找，以便小伙伴们能够很好的掌握今天小编所讲的内容，接下来让我们一起来了解下吧。二叉树的删除操作是比较复杂的。首先要找到删除的节点。要删除的结点对象并不一定要进行删除操作。因为通过函数调用得到的只是他的副本。并不会真正的把他删掉。你只要让他不在树上就行了。让删除结点的父...
链表与二叉树的转化
StevenBian的博客
05-11 1030
（leetcode109） 有序链表转换二叉搜索树（中等）
面试题27：二叉搜索树与双向链表
weixin_33827731的博客
04-28 261
题目：输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。比如输入下图中左边儿茶搜索树，则输出转换后的排序双向链表。 10 / \ 6 14 / \ / \ 4 8 12 16 4=6=8=10=12=14=16  将二叉搜索树转化为有序双向链表，类似于中序遍历，中序遍...
《剑指Offer》刷题笔记——面试题07. 重建二叉树打印链表
01-20
难度：中等 一、题目描述： 二、解题分析： 1、剑指解析： 2、代码实现： from typing import List ###### 代码主体 ###### ... def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode: ...
常见：程序员面试题精选100题1
最新发布
08-08
总结，这个面试题涉及了二元查找树、双向链表和递归等核心计算机科学概念。掌握这些知识点对于准备程序员面试至关重要，尤其是对于那些需要处理复杂数据结构和算法的问题。通过深入理解和实践，可以提高解决问题的...
程序员面试金典 – 面试题 17.12. BiNode（BST中序遍历）
12-21
二叉树数据结构TreeNode可用来表示单向链表（其中left置空，right为下一个链表节点）。 实现一个方法，把二叉搜索树转换为单向链表，要求值的顺序保持不变，转换操作应是原址的，也就是在原始的二叉搜索树上直接修改...
程序员面试题集锦
10-12
【程序员面试题集锦】是针对IT行业，尤其是Java编程方向的面试者精心整理的一份资源，涵盖了各大公司的面试题目以及数据结构相关的知识点。这份资料旨在帮助应聘者全面准备面试，提升自己的技术水平和应试能力。 一...
程序员面试笔试真题库.7z
03-04
《程序员面试笔试真题库》是一份集合了各种面试技巧和常见问题的资源包，尤其对正在求职的程序员们极具价值。这份7z压缩文件包含了《程序员面试笔试真题库_2017版.pdf》，这是一本详尽的指南，涵盖了C语言的基础知识...
二叉树转换为双向链表
12-17
二叉树转换为双向链表 通过随机创建二叉排序树测试二叉树转换为双向链表是否正确 http://blog.csdn.net/ssuchange/article/details/17383625
leetcode114.二叉树转为链表
长舒的博客
08-31 463
//二叉树转链表 //思路:每次找到根结点上左子树上最右边的结点ltemp，将此时的根结点的右子树接到上面去， 根结点左移，如果根结点左子树为空，但是右子树不为空，就右移，重复上面步骤，否则就退出 void flattern(TreeNode *root) { if (!root) { return; } TreeNode *cur = root; TreeNode *rtemp...
二叉搜索树变成链表
Tlwhisper的博客
03-29 652
1、描述 二叉树数据结构TreeNode可用来表示单向链表（其中left置空，right为下一个链表节点）。实现一个方法，把二叉搜索树转换为单向链表，要求依然符合二叉搜索树的性质，转换操作应是原址的，也就是在原始的二叉搜索树上直接修改。 返回转换后的单向链表的头节点。 注意：本题相对原题稍作改动 示例： 输入： [4,2,5,1,3,null,6,0] 输出： [0,null,1,null,2,null,3,null,4,null,5,null,6] 来源：力扣（LeetCode） 链接：https://l
二叉树展开为链表
wh22141334的博客
05-02 548
思路： 根据二叉树的前序遍历，先得到二叉
二叉搜索树（搜索二叉树）转换成一个双向链表
weixin_30652271的博客
05-07 687
1.题目描述： 将一个二叉搜索树转换成一个双向链表； 2.二叉搜索树，直接看图： 如图就是一个二叉搜索树的模型，也就是转换函数的入口数据，也是下边函数中即将用到的例子，既然有输入，肯定有输出，先面在看一张图（第三条）： 3.输入输出模型： 右边就是最终的输出结果，5后边是空，下边来分析一下： 1.在二叉搜索树中，每个节点都有两个孩子，即左和右，而在双向链表中，每...
45.二叉树转链表
ZH956318的博客
07-03 662
题目：输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。 解析：二叉搜索树：左子树结点值大于右子树结点值 ①定义一个转换函数convertnode将root结点传进去做转换树为链表的操作； ②在convertnode函数中，判断root是否有左子树，有则继续调用convertnode函数将root.left传进去将左子树转化为链表；同...
二叉树转换为链表
王小东大将军的博客
09-12 1749
一、问题描述 输入一棵二叉搜索树，现在要将该二叉搜索树转换成一个排序的双向链表。而且在转换的过程中，不能创建任何新的结点，只能调整树中的结点指针的指向来实现。 查阅了相关内容，基本了解了这个问题的解析方法与思想。 二叉搜索树转换为有序双向链表 DList BSTreeToList(BSTree tree) { if(tree == NULL) r
将二叉树展开成一个链表
慢慢冲鸭子的博客
08-17 284
将二叉树中序遍历展开成一个链表 牛客网 26、二叉搜索树与双向链表的简化版 void inorder(TreeNode* root, TreeNode*& pre, TreeNode*& head) { if (!root) return; inorder(root->left, pre, head); if (!head) { head = root; ...
搜索二叉树转链表java_二叉树转化成双链表的JAVA实现
weixin_30990605的博客
02-24 295
import java.util.ArrayList;import java.util.List;public class BSTreeToLinkedList {/*把二元查找树转变成排序的双向链表题目：输入一棵二元查找树，将该二元查找树转换成一个排序的双向链表。要求不能创建任何新的结点，只调整指针的指向。10/ \6 14/ \ / \4 8 12 16转换成双向链表4=6=8=10=12=1...
常见：算法面试题1
08-08
2.如果需要求出俩个链表相交的第一个节点列?第8题此贴选一些 比较怪的题，，由于其中题目本身与算法关系不大，仅考考思维。特此并作一题。1.有两个房间，一间房里有

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值