[cpp]: 双向链表的实现

[cpp]:  双向链表的实现

 

 

 

 

一、思路或者原理

 

 

　　1、双向链表的实现思路：

　　　　1.1、【链节】：【链节】是【链表】的基本单位；

　　　　1.2、【链表】：由多个【链节】组成一个【链表】。

 

 

　　2、【链节】（data class）：【链节data】是组成【链表chains】的基本单元，【链节data】用于存储数据。

　　　　2.1、【链节】内的数据成员：从当前【链节data】指向前一个【链节data】的指针（前向指针：point_previous）；从当前【链节data】指向后一个【链节data】的指针（后向指针：point_next）；数据存储（保存数据）

　　　　2.2、【链节】内的函数成员：【链节data】的赋值；

　　　　2.3、【双向链表】的核心点是【链节】的前后向指针(point_previous/point_next)。

 

 

　　3、【双向链表】（chains class）：

　　　　3.1、【链表chains】的基本操作：创建【链节data】并赋值；在两个【链节data】之间建立连接关系；删除【链节data】；遍历【链表chains】

　　　　3.2、【链表chains】基本数据对象：first（指向【链表chains】的第一个【链节data】）；  last（指向【链表chains】的最后一个【链节data】）；

　　　　3.3、（析构函数~chain()）删除【链节data】。

 

 

 

 

二、程序代码

#include <iostream>


//  unit of chains
class data
{
public:

    data() = delete ;

    ~data()
    {
        std::cout << "[~data]#\t" << --data::dsize << std::endl ;
    }
    data(int e):val(e)
    {
        data::dsize++ ;
    }

    //  double chains
    data *pre = nullptr;
    data *next = nullptr;

    //  element of data
    int val = 0;

    //  count numbers of objects of 'data' type
    static unsigned int dsize ;
};

//  initialize count of object of 'data' type
unsigned int data::dsize = 0 ;


//  chain_of_data
class chains
{
private:

    //  head pointer of object of chain_data 'type'
    data *first = nullptr ;

    //  tail pointer of object of chain_data 'type'
    data *last = nullptr ;

public:

    //  initialize object of 'chains' type.
    //  initialize first element of 'data' type.
    chains(int e) 
    {
        if ( first == nullptr  &&  last == nullptr )
        {
            //  create first node of data type.
            data *first_data_node = new data(e) ;

            //  connect[data type]:  first_data_node->pre   to  nullptr. 
            first_data_node->pre = nullptr ;

            //  connect[chains type]:  chains_node->first  to  first_data_node. 
            first = first_data_node ;

            //  connect[chains type]:  chains_node->last  to  first_data_node. 
            last = first_data_node ;
        }
    }

    ~chains()
    {
        for ( ; first != nullptr ;   )
        {
            //  keep address of first_node pointing next node of data type. 
            data *keep = first ->next ;

            //  delete first node of data type.
            delete first ;
            
            //  connect[data type]:  first  =  first->next . 
            first = keep;
            
            std::cout << "[~chains]#\t work over. " << std::endl ;
        }
    }

    //  set element of 'data' type.
    void set_chains(int e)
    {
        if ( first != nullptr  &&  last != nullptr )
        {
            //  append object of data to the chains

            //  keep last object of data of the chains
            data *keep_current = last ;

            //  create new_node of data type;
            data *new_node = new data(e) ;

            //  connect[data type]:  last_node->next  to  new node. 
            keep_current->next = new_node ;

            //  connect[data type]:  new_node->pre  to  last. 
            new_node->pre = keep_current ;

            //  connect[data type]:  new_node->next  to  nullptr. 
            new_node->next = nullptr ;

            //  connect[chains type]:  chain_last  to  new_node. 
            last = new_node ;
        }
    }

    //  loop chains from begin to end.
    void loop_front_chains()
    {
        data *loop = nullptr ;
        if ( first != nullptr )
        {
            loop = first ;
            for ( ;  loop != nullptr ;  loop = loop->next )
            {
                std::cout << "[loop_front]#\t" << loop->val << std::endl ;
            }
        }
    }

    //  loop chains from end to begin.
    void loop_back_chains()
    {
        data *loop = nullptr ;
        if ( last != nullptr )
        {
            loop = last ;
            for ( ;  loop != nullptr ;  loop = loop->pre )
            {
                std::cout << "[loop_back]#\t" << loop->val << std::endl ;
            }
        }
    }
};


int main()
{
    chains g(0) ;
    g.set_chains(1) ;
    g.set_chains(2) ;
    g.set_chains(3) ;
    g.set_chains(4) ;
    
    g.loop_front_chains() ;
    g.loop_back_chains();

    return 0 ;
}

 

 

 

 

三、运行结果

[loop_front]#    0
[loop_front]#    1
[loop_front]#    2
[loop_front]#    3
[loop_front]#    4
[loop_back]#    4
[loop_back]#    3
[loop_back]#    2
[loop_back]#    1
[loop_back]#    0
[~data]#    4
[~chains]#     work over. 
[~data]#    3
[~chains]#     work over. 
[~data]#    2
[~chains]#     work over. 
[~data]#    1
[~chains]#     work over. 
[~data]#    0
[~chains]#     work over. 

 

 

 

 

四、参考资料：

 

　　1、　　数据结构、算法与应用（c++语言描述）edition 2  -- {作者：sartaj sahni；译者：王立柱，刘志宏； 出版社：机械工业出版社； 版次：2020.10，第1版第13次印刷 }

 

　　2、　　g++ prog.cc -Wall -Wextra -I/opt/wandbox/boost-1.83.0-gcc-13.2.0/include -std=gnu++2b