Reverse a doubly linked list in O(1) time

最新推荐文章于 2025-08-10 23:14:27 发布
原创 最新推荐文章于 2025-08-10 23:14:27 发布 · 1.2k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#list #null #functor #struct

本文详细介绍了双向链表的实现，并通过一系列测试验证了其实现的有效性和正确性。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

#ifndef GYM_CLRS_V3_10_2_8_LINKED_LIST_H_6D4EBDB0_5B18_4FC1_A34A_CBBF36FE95E4
#define GYM_CLRS_V3_10_2_8_LINKED_LIST_H_6D4EBDB0_5B18_4FC1_A34A_CBBF36FE95E4

#include <assert.h>
#include <stdint.h>
#include <boost/call_traits.hpp>

namespace pratique
{
    namespace clrs_version
    {
        namespace detail
        {
            template <typename T>
            struct Node
            {
                T data;
                uintptr_t link;
            };

            template <typename T>
            inline Node<T> * next( Node<T> * previous, Node<T> * node )
            {
                uintptr_t n = reinterpret_cast<uintptr_t>( previous ) ^ node->link;
                return reinterpret_cast<Node<T>*>( n );
            }

            template <typename T>
            inline Node<T> * previous( Node<T> * node, Node<T> * next )
            {
                uintptr_t p = node->link ^ reinterpret_cast<uintptr_t>( next );
                return reinterpret_cast<Node<T>*>( p );
            }

            template <typename T>
            inline uintptr_t compound( Node<T> * previous, Node<T> * next )
            {
                return reinterpret_cast<uintptr_t>( previous ) ^ reinterpret_cast<uintptr_t>( next );
            }
        }

        template <typename T>
        class DoublyLinkedList
        {
            detail::Node<T> * m_head, * m_last;

            inline static detail::Node<T> * forward( detail::Node<T> ** previous, detail::Node<T> ** node )
            {
                detail::Node<T> * tmp = *node;
                *node = detail::next( *previous, *node );
                *previous = tmp;
                return tmp;
            }

            inline static detail::Node<T> * backward( detail::Node<T> ** node, detail::Node<T> ** next )
            {
                detail::Node<T> * tmp = *node;
                *node = detail::previous( *node, *next );
                *next = tmp;
                return tmp;
            }

            inline void free()
            {
                if ( m_head != NULL ) {
                    detail::Node<T> * p = NULL, * n = m_head;
                    do {
                        delete forward( &p, &n );
                    } while ( n != m_head );
                    m_head = m_last = NULL;
                }
            }
        public:
	        typedef size_t size_type;

            DoublyLinkedList() : m_head( NULL ), m_last( NULL ) {}

            ~DoublyLinkedList()
            {
                free();
            }

            DoublyLinkedList( DoublyLinkedList<T> const & dll ) : m_head( NULL ), m_last( NULL )
            {
                if ( dll.m_head != NULL ) {
                    assert( dll.m_last != NULL );
                    detail::Node<T> * p = NULL, * n = dll.m_head, * tmp;
                    detail::Node<T> * mya = NULL, * myp = NULL, * myn = NULL;
                    ScopeGuard copy_destructor(
                        [&]() {
                            for ( detail::Node<T> * p = NULL, * n = m_head; n != myp; ) {
                                delete forward( &p, &n );
                            }
                            delete myp;
                        }
                    );
                    do {
                        tmp = forward( &p, &n );
                        myn = new detail::Node<T>;
                        myn->data = tmp->data;
                        if ( m_head == NULL ) {
                            m_head = myn;
                        }
                        if ( myp != NULL ) {
                            myp->link = detail::compound( mya, myn );
                        }
                        mya = myp;
                        myp = myn;
                    } while ( n != dll.m_head );
                    copy_destructor.dismiss();
                    myp->link = detail::compound( mya, m_head );
                }
            }
            DoublyLinkedList<T> & operator=( DoublyLinkedList<T> const & dll )
            {
                if ( this != &dll ) {
                    DoublyLinkedList<T>( dll ).swap( *this );
                }
                return *this;
            }

            void swap( DoublyLinkedList<T> & dll )
            {
                using std::swap;
                swap( m_head, dll.m_head );
                swap( m_last, dll.m_last );
            }

            bool operator==( DoublyLinkedList<T> const & dll ) const
            {
                bool equals = false;
                detail::Node<T> * p = NULL, * n = dll.m_head;
                detail::Node<T> * myp = NULL, * myn = m_head;
                if ( n != NULL && myn != NULL ) {
                    do {
                        if ( n->data == myn->data ) {
                            forward( &p, &n );
                            forward( &myp, &myn );
                        } else {
                            break;
                        }
                    } while ( n != dll.m_head && myn != m_head );
                    equals = ( n == dll.m_head && myn == m_head );
                } else {
                    equals = true;
                }
                return equals;
            }

            inline bool operator!=( DoublyLinkedList<T> const & dll ) const
            {
                return !( operator==( dll ) );
            }

            inline bool empty() const
            {
                return ( m_head == NULL );
            }

            size_type size() const
            {
                size_t count = 0;
                if ( m_head != NULL ) {
                    detail::Node<T> * previous = NULL, * current = m_head, * tmp;
                    do {
                        ++count;
                        tmp = current;
                        current = next( previous, current );
                        previous = tmp;
                    } while ( current != m_head );
                }
                return count;
            }

            void push_back( typename boost::call_traits<T>::param_type v )
            {
                detail::Node<T> * p = new detail::Node<T>;
                p->data = v;
                if ( m_head != NULL ) {
                    detail::Node<T> * previous = detail::previous( m_last, m_head );
                    m_last->link = detail::compound( previous, p );
                    p->link = detail::compound( m_last, m_head );
                } else {
                    detail::Node<T> * previous = NULL;
                    m_head = p;
                    m_head->link = detail::compound( previous, p );
                }
                m_last = p;
            }

            void pop_back()
            {
                if ( m_head != NULL ) {
                    detail::Node<T> * previous = detail::previous( m_last, m_head );
                    if ( previous != NULL ) {
                        detail::Node<T> * ancestor = detail::previous( previous, m_last );
                        delete m_last;
                        previous->link = detail::compound( ancestor, m_head );
                        m_last = previous;
                    } else {
                        assert( m_last == m_head );
                        delete m_head;
                        m_last = m_head = NULL;
                    }
                }
            }

            void push_front( typename boost::call_traits<T>::param_type v )
            {
                detail::Node<T> * null_previous = NULL;
                detail::Node<T> * p = new detail::Node<T>;
                p->data = v;
                if ( m_head != NULL ) {
                    detail::Node<T> * previous = detail::previous( m_last, m_head );
                    detail::Node<T> * next = detail::next( null_previous, m_head );
                    p->link = detail::compound( null_previous, m_head );
                    if ( previous != NULL ) {
                        m_last->link = detail::compound( previous, p );
                        m_head->link = detail::compound( p, next );
                    } else {
                        m_head->link = detail::compound( p, p );
                        m_last = m_head;
                    }
                } else {
                    p->link = detail::compound( null_previous, p );
                    m_last = p;
                }
                m_head = p;
            }

            void pop_front()
            {
                if ( m_head != NULL ) {
                    detail::Node<T> * null_previous = NULL;
                    detail::Node<T> * previous = detail::previous( m_last, m_head );
                    if ( previous != NULL ) {
                        detail::Node<T> * next = detail::next( null_previous, m_head );
                        if ( next != m_last ) {
                            detail::Node<T> * third = detail::next( m_head, next );
                            m_last->link = detail::compound( previous, next );
                            next->link = detail::compound( null_previous, third );
                        } else {
                            m_last->link = detail::compound( null_previous, m_last );
                        }
                        delete m_head;
                        m_head = next;
                    } else {
                        delete m_head;
                        m_head = m_last = NULL;
                    }
                }
            }

            void reverse()
            {
                if ( m_head != m_last ) {
                    detail::Node<T> * null_previous = NULL;
                    detail::Node<T> * previous = detail::previous( m_last, m_head );
                    detail::Node<T> * next = detail::next( null_previous, m_head );
                    m_last->link = detail::compound( null_previous, previous );
                    m_head->link = detail::compound( m_last, next );
                    std::swap( m_last, m_head );
                }
            }

            T const & front() const
            {
                assert( !empty() );
                return m_head->data;
            }

            T const & back() const
            {
                assert( !empty() );
                return m_last->data;
            }

            class Iterator
            {
                friend class DoublyLinkedList<T>;
                detail::Node<T> * m_previous, * m_current, * m_last;
                Iterator( DoublyLinkedList<T> const * dll ) : m_previous( NULL ), m_current( dll->m_head ), m_last( dll->m_last )  {}
            public:
                Iterator() : m_previous( NULL ), m_current( NULL ), m_last( NULL ) {}

                typedef std::bidirectional_iterator_tag iterator_category;

                typedef T value_type;
                typedef detail::Node<T> * pointer;
                typedef ptrdiff_t difference_type;
                typedef T const & reference;

                reference operator*() const
                {
                    return m_current->data;
                }

                Iterator & operator++()
                {
                    DoublyLinkedList<T>::forward( &m_previous, &m_current );
                    return (*this);
                }

                Iterator operator++(int)
                {
                    Iterator tmp( *this );
                    ++*this;
                    return tmp;
                }

                Iterator & operator--()
                {
                    DoublyLinkedList<T>::backward( &m_previous, &m_current );
                    return (*this);
                }

                Iterator operator--(int)
                {
                    Iterator tmp( *this );
                    --*this;
                    return tmp;
                }

                bool operator==( const Iterator & i ) const
                {
                    return ( m_current == i.m_current && m_previous == i.m_previous );
                }

                bool operator!=( const Iterator& i ) const
                {
                    return ( m_current != i.m_current || m_previous != i.m_previous );
                }
            };

            typedef Iterator iterator;

            iterator begin() const { return Iterator( this ); }
            iterator end() const
            {
                Iterator i;
                i.m_previous = this->m_last;
                i.m_current = this->m_head;
                i.m_last = this->m_last;
                return i;
            }
        };
    }
}

#endif //GYM_CLRS_V3_10_2_8_LINKED_LIST_H_6D4EBDB0_5B18_4FC1_A34A_CBBF36FE95E4


The testing code is:

    typedef pratique::clrs_version::DoublyLinkedList<int> mydll;

    void must_be_equals( mydll const & l, mydll const & r )
    {
        if ( l != r ) {
            fprintf( stderr, "Bad implementation for the problem CRLS 10-2-8\n" );
            DebugBreak();
        }
    }

    void clrs_list_test()
    {
        {
            mydll dll;

            {
                mydll copy( dll );
                must_be_equals( dll, copy );
            }

            dll.push_back( 1 );
            dll.pop_back();

            {
                mydll copy( dll );
                must_be_equals( dll, copy );
            }
        }

        {
            mydll dll;

            dll.push_back( 1 );
            {
                mydll copy( dll );
                must_be_equals( dll, copy );
            }

            dll.push_back( 2 );
            dll.pop_back();

            {
                mydll copy( dll );
                must_be_equals( dll, copy );
            }
        }

        {
            mydll dll;
            const int limits = 128;
            int to_be_compared[ limits ];
            for ( int i = 0; i < limits; ++i ) {
                to_be_compared[i] = i;
            }

            for ( int i = 0; i < limits; ++i ) {
                dll.push_back( i );
                if ( !std::equal( dll.begin(), dll.end(), std::begin( to_be_compared ) ) ) {
                    fprintf( stderr, "Bad implementation for the problem CRLS 10-2-8\n" );
                    DebugBreak();
                    break;
                }
            }

            while ( !dll.empty() ) {
                dll.pop_back();
            }

            for ( int i = 0; i < limits; ++i ) {
                dll.push_back( i );
                if ( !std::equal( dll.begin(), dll.end(), std::begin( to_be_compared ) ) ) {
                    fprintf( stderr, "Bad implementation for the problem CRLS 10-2-8\n" );
                    DebugBreak();
                    break;
                }
            }

            dll.reverse();

            int count = 0;
            std::vector<int> result;
            while ( !dll.empty() ) {
                ++count;
                result.push_back( dll.back() );
                dll.pop_back();
            }

            for ( int i = 0; i < limits; ++i ) {
                if ( result[i] != i ) {
                    fprintf( stderr, "Bad implementation for the problem CRLS 10-2-8\n" );
                    DebugBreak();
                    break;
                }
            }

            mydll copy( dll );
            must_be_equals( dll, copy );
        }

        {
            mydll dll;

            dll.push_front( 1 );
            dll.pop_front();

            {
                mydll copy( dll );
                must_be_equals( dll, copy );
            }
        }

        {
            mydll dll;

            dll.push_front( 1 );
            {
                mydll copy( dll );
                must_be_equals( dll, copy );
            }

            dll.push_front( 2 );
            dll.pop_front();

            {
                mydll copy( dll );
                must_be_equals( dll, copy );
            }
        }

        {
            mydll dll;
            const int limits = 128;
            int to_be_compared[ limits ];
            for ( int i = 0; i < limits; ++i ) {
                to_be_compared[i] = i;
            }

            for ( int i = limits - 1; i >= 0; --i ) {
                dll.push_front( i );
                if ( !std::equal( dll.begin(), dll.end(), std::begin( to_be_compared ) + i ) ) {
                    fprintf( stderr, "Bad implementation for the problem CRLS 10-2-8\n" );
                    DebugBreak();
                    break;
                }
            }

            while ( !dll.empty() ) {
                dll.pop_back();
            }

            for ( int i = limits - 1; i >= 0; --i ) {
                dll.push_front( i );
                if ( !std::equal( dll.begin(), dll.end(), std::begin( to_be_compared ) + i ) ) {
                    fprintf( stderr, "Bad implementation for the problem CRLS 10-2-8\n" );
                    DebugBreak();
                    break;
                }
            }

            dll.reverse();

            int count = 0;
            std::vector<int> result;
            while ( !dll.empty() ) {
                ++count;
                result.push_back( dll.back() );
                dll.pop_back();
            }

            for ( int i = 0; i < limits; ++i ) {
                if ( result[i] != i ) {
                    fprintf( stderr, "Bad implementation for the problem CRLS 10-2-8\n" );
                    DebugBreak();
                    break;
                }
            }

            mydll copy( dll );
            must_be_equals( dll, copy );
        }
    }


 

chmodexplorer
关注
Doubly Linked List in Python
Random Notes & Thoughts on CS/ML/DL/CV
02-26 186
Doubly Linked List in Python1. 结点定义2. 双向链表的实现3. 测试程序 1. 结点定义 class Node: def __init__(self, data): self.data = data self.prev = None self.next = None def __eq__(self, data): return self.data == data def __str__
逆置双向链表 Reverse a doubly linked list
LUCKYOJ
12-29 2027
逆转单链表，参见http://blog.youkuaiyun.com/ojshilu/article/details/9312239。 本文是要逆转双向链表，其基本思想是一致的。只是要考虑的多一些。头尾结点都会出现NULL。 双线链表结点的结构为 struct Node { int data; Node *next; Node *prev } 这是个细心
双向链表(Doubly Linked List)
热门推荐
Catherine的笔记
05-03 1万+
双向链表(Doubly Linked List) 1. 双向链表的概念 1.1 双向链表的定义 双向链表又称为双链表，是链表的一种。 1.2 双向链表的结点结构 双向链表的结点包括三个部分：前驱指针域、数据域和后继指针域。 (1)前驱指针域(lLink)，又称为左链指针，用于存放一个指针，该指针指向上一个结点的开始存储地址。 (2)数据域(data)，用于存储该结点的数据元素，数据元素类型由应用问题决定。
Linked Lists：Reverse a doubly linked list
weixin_45405128的博客
02-14 230
def reverse(head): left=None right=head while right: tmp=right.next #先保存下一个 right.next=left #换顺序 left=right #进1 right=tmp #进1 return left ...
【Hackerrank】Reverse a doubly linked list
R_xiaozhu_Q的专栏
12-16 1266
You’re given the pointer to the head node of a doubly linked list. Reverse the order of the nodes in the list. The head node might be NULL to indicate that the list is empty. Input Format You have t
Doubly Linked List09
m0_51307473的博客
06-10 162
Doubly Linked List Design Doubly Linked List Design your implementation of the linked list. You can choose to use a singly or doubly linked list. A node in a singly linked list should have two attributes: val and next. val is the value of the current node,
Python数据结构实战——双向链表(DoublyLinkedList)
weixin_37763870的博客
04-26 807
文章目录1.定义结点类2.定义链表类2.1.打印正向链表2.2.打印反向链表2.3.寻找链表最后一个结点2.4.计算链表长度2.5.链表首部插入元素2.6.链表尾部插入元素2.7.链表任意位置插入元素2.8.链表任意位置删除元素2.9.链表中插入一堆元素3.测试 1.定义结点类 class Node: def __init__(self, data=None,next=None,prev=...
Java基础十三： List
qq_52506743的博客
08-07 1460
本文介绍了Java中几种重要集合类的高级应用与特性。1. LinkedList部分详细讲解了其作为双向链表的基本操作、特有方法以及实现队列和栈两种模式的应用；2. Vector部分分析了这个同步动态数组的线程安全特性及其历史发展，比较了与现代集合类的异同；3. Stack和HashSet部分分别阐述了栈结构的基本操作和HashSet基于哈希表的实现原理及特点。这些集合类各具特色，适用于不同的数据结构需求场景，理解它们的特性和适用环境对Java开发至关重要。
java报错“ NoSuchMethodError：com.test.Service.doRoomList(Ljava/lang/String；)V解决方案
最新发布
一见你就笑
08-10 147
如果不是自己的编写的类报错而是引入工具类jar包报错，则项目在引入多个版本的工具包冲突报错了。使用的是 Jackson 2.10+ 的 API，但运行时是 Jackson 2.6。即使方法名相同，如果参数类型、数量或返回类型不同，JVM 也会认为是“找不到方法”。查看确保没有旧版本被间接引入。
Delphi：TList/TObjectList 设计中的 Notify 设计范式
程序猿视角
08-09 773
Delphi中的TList/TObjectList采用混合设计模式实现灵活的集合管理。其核心是Notify方法，结合了观察者模式（状态变更时通知）和模板方法模式（父类定义流程，子类扩展行为）。当列表执行删除等操作时，自动触发Notify通知，子类TObjectList可重写该方法实现对象释放等定制逻辑。这种设计遵循开闭原则，通过虚方法扩展功能而不修改基类，同时保持职责分离——基类管理数据结构，子类处理业务逻辑。实际实现中需注意操作顺序，先处理业务逻辑再调用父类方法，避免访问已释放内存。这种模式在多种框架中广
Flutter 局部刷新方案对比：ValueListenableBuilder vs. GetBuilder vs. Obx
lxjlxj2333的博客
08-07 738
Flutter局部刷新方案对比摘要 ValueListenableBuilder、GetBuilder和Obx是Flutter三种UI局部刷新方案。ValueListenableBuilder是Flutter原生方案，基于ValueNotifier实现响应式更新，无依赖但需手动管理生命周期。GetBuilder属于GetX的命令式方案，需手动调用update()触发重建，适合复杂场景。Obx是GetX的响应式方案，通过.obs自动追踪依赖，代码最简洁但依赖GetX框架。综合对比，Obx在开发效率上完胜，Va
【Redis】hash哈希，List列表
2301_80224556的博客
08-06 963
通过消费者在获取元素后。
LinkedList 深度解析：核心原理与实践
Zyw907155124的博客
08-06 647
本文深入剖析Java LinkedList 的双向链表实现内核，从数据结构基础、JDK源码层解读，到时间复杂度与内存占用的定量分析。文章通过可视化图解揭示add(index, E)等关键操作的指针重定向过程，对比ArrayList在随机访问与插入删除场景的性能差异。针对并发场景下的Fail-Fast机制与线程安全问题提供解决方案，并结合JVM内存模型解析节点对象的内存布局。
从0开始的中后台管理系统-5（userList动态展示以及上传图片和弹出创建用户表单）
A6516565189的博客
08-08 371
本文介绍了使用Ant Design实现用户列表管理功能。通过Table组件展示50条随机生成的用户数据，支持分页、搜索和重置功能。父组件通过ref调用子组件(CreateUser)的open方法实现新增用户弹窗，并传递更新方法以保证数据同步。表单包含用户ID、名称、邮箱、角色等字段，支持状态筛选和操作按钮。通过useEffect监听分页参数变化，动态获取数据并更新表格展示。整体实现了用户列表的CRUD基本功能，展示了Ant Design组件在React项目中的实际应用。
【Spring IoC 核心实现类详解：DefaultListableBeanFactory】
许苑向上
08-10 465
核心类职责：保存 BeanDefinition、注册 BeanDefinition、创建 Bean、依赖注入、生命周期管理关系只是更高级的外观模式，底层真正管理 Bean 的还是。
从0开始的中后台管理系统-5（userList页面功能实现）
A6516565189的博客
08-10 556
本文实现了一个基于React和Express的用户管理系统，包含完整的增删改查功能。前端使用Ant Design组件库和ahooks的useAntdTable钩子实现表格展示、搜索分页和表单联动；后端通过Express处理数据请求，将用户信息持久化存储在JSON文件中。系统特点包括：1）前端采用useAntdTable简化分页搜索逻辑；2）支持批量删除操作；3）实现了用户状态筛选和模糊搜索；4）后端通过中间件进行token验证；5）文件上传功能采用multer处理。整个系统展示了前后端分离开发模式下，前端处
Java数据结构——LinkedList
Yoko_999的博客
08-10 397
摘要：本文介绍了LinkedList链表结构及其实现。第一部分讲解链表的概念和结构，重点分析无头双向循环链表的Java实现，包括头插法、尾插法、任意位置插入等基本操作。第二部分介绍Java中LinkedList的使用方法，包括构造方法、常用操作和三种遍历方式（for-each、正向迭代器、反向迭代器）。与ArrayList相比，LinkedList更适合频繁插入删除的场景，因其底层采用链表结构，操作时间复杂度更低。
WinForm 中 ListView 控件的实战应用与功能拓展
LZQqqqqo的博客
08-09 713
本文介绍了WinForm中ListView控件的常用功能实现，包括：1.初始化与列设置，通过ColumnHeader对象构建表格视图；2.右键菜单实现数据删除功能；3.支持大图标、小图标和详情视图的切换；4.数据查找与高亮显示；5.查找替换功能实现数据修改；6.通过分割字符串实现多列数据添加。文章还提供了ImageList和ContextMenuStrip等扩展资源的使用建议，以及推荐阿里巴巴图标库作为图标资源。这些功能组合使用可以构建出功能完善的列表展示界面，满足文件管理、信息展示等多种业务需求。
【C++/STL】list模拟实现和迭代器失效问题
2401_88238436的博客
08-10 212
即迭代器所指向的节点的无效，即该节点被删除了。因为list底层为带头结点的双向循环链表，所以在list中插入元素时不会导致迭代器失效，只有删除时才会失效，且失效的只是指向被删除节点的迭代器，其他迭代器不会被影响。list是带头双向循环链表。
1. Convert a binary search tree into a sorted circular doubly linked list 【Problem Description】 Given a binary search tree, you need to convert it into a circular doubly linked list, the elements in the linked list are sorted. For example, a binary search tree in Fig.1 is converted into a sorted circular doubly linked list in Fig.2. 【Basic Requirements】 The input data is a set of data elements to build a binary search tree, you should design algorithms to realize the conversion process and verify the accuracy of your code on multiple test data. The output includes the following: (1) Print the binary search tree (2) Traverse the binary search tree (3) Print the converted doubly linked list (4) Output all elements of the doubly linked list in positive and reverse order
05-29
【Solution】 To convert a binary search tree into a sorted circular doubly linked list, we can use the following steps: 1. Inorder traversal of the binary search tree to get the elements in sorted order. 2. Create a doubly linked list and add the elements from the inorder traversal to it. 3. Make the list circular by connecting the head and tail nodes. 4. Return the head node of the circular doubly linked list. Here's the Python code for the solution: ``` class Node: def __init__(self, val): self.val = val self.prev = None self.next = None def tree_to_doubly_list(root): if not root: return None stack = [] cur = root head = None prev = None while cur or stack: while cur: stack.append(cur) cur = cur.left cur = stack.pop() if not head: head = cur if prev: prev.right = cur cur.left = prev prev = cur cur = cur.right head.left = prev prev.right = head return head ``` To verify the accuracy of the code, we can use the following test cases: ``` # Test case 1 # Input: [4,2,5,1,3] # Output: # Binary search tree: # 4 # / \ # 2 5 # / \ # 1 3 # Doubly linked list: 1 <-> 2 <-> 3 <-> 4 <-> 5 # Doubly linked list in reverse order: 5 <-> 4 <-> 3 <-> 2 <-> 1 root = Node(4) root.left = Node(2) root.right = Node(5) root.left.left = Node(1) root.left.right = Node(3) head = tree_to_doubly_list(root) print("Binary search tree:") print_tree(root) print("Doubly linked list:") print_list(head) print("Doubly linked list in reverse order:") print_list_reverse(head) # Test case 2 # Input: [2,1,3] # Output: # Binary search tree: # 2 # / \ # 1 3 # Doubly linked list: 1 <-> 2 <-> 3 # Doubly linked list in reverse order: 3 <-> 2 <-> 1 root = Node(2) root.left = Node(1) root.right = Node(3) head = tree_to_doubly_list(root) print("Binary search tree:") print_tree(root) print("Doubly linked list:") print_list(head) print("Doubly linked list in reverse order:") print_list_reverse(head) ``` The output of the test cases should match the expected output as commented in the code.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值