数据结构自学笔记 链表超进化

讲真,链表是个十分入门且简单的数据结构,虽然用的不多,但有时候还真非它莫属。然而,作为一名C++选手,我的链表总是被各种大常数以及难写的代码困扰。今天从算法导论上学来了点小技巧,赶紧代码实现了一下。 之前,我的链表都是这么写的。 
class list
{
    struct node
    {
        int key;
        node *next;
        node *prev;
    };
    
    node *head;
    node *tail;
    
    list(void)
    {
        head = NULL;
        tail = NULL;
    }
    
    void insert_to_head(int k)
    {
        node *t = new node;
        
        t -> key = k;
        
        t -> prev = NULL;
        t -> next = head;
        
        if (head != NULL)
            head -> prev = t;
        
        head = t;
    }
    
    void insert_to_tail(int k)
    {
        node *t = new node;
        
        t -> key = k;
        
        t -> prev = tail;
        t -> next = NULL;
        
        if (tail != NULL)
            tail -> next = t;
            
        tail = t;
    }
    
    void delete_a_node(node *t)
    {
        if (t -> prev != NULL)
            t -> prev -> next = t -> next;
        else
            head = t -> next;
            
        if (t -> next != NULL)
            t -> next -> prev = t -> prev;
        else
            tail = t -> prev;
            
        delete(t);
    }
    
    node *find_the_key(int k)
    {
        node *t = head;
        
        while (t != NULL && t -> key != k)
            t = t -> next;
            
        return t;
    }
};
 代码还是蛮好看的,自认为。然而接连不断地新建结点的常数总是让人吃不消。 于是,从Introduction to Algorithm中学来的第一招——用哨兵(哑结点)优化常数以及代码难度。原来,我们经常用到一个表示空结点的NULL,而且为了防止非法访问,还要各种边界特判,烦不胜烦。现在,我们新建一个名为NIL的哑结点,用来替代原来的所有NULL,省去了好多特判,代码也好写多了。重点是还能通过NIL把head和tail连在一起,形成了一个环状链表。 
class list
{
    struct node
    {
        int key;
        node *next;
        node *prev;
    };
    
    node *nil;
    
    list(void)
    {
        nil = new node;
        
        nil -> key = -1;
        nil -> next = nil;
        nil -> prev = nil;
    }
    
    void insert_to_head(int k)
    {
        node *t = new node;
        
        t -> key = k;
        
        t -> prev = nil;
        t -> next = nil -> next;
        t -> next -> prev = nil -> next = t;
    }
    
    void insert_to_tail(int k)
    {
        node *t = new node;
        
        t -> key = k;
        
        t -> next = nil;
        t -> prev = nil -> prev;
        t -> prev -> next = nil -> prev = t;
    }
    
    void delete_a_node(node *t)
    {
        t -> prev -> next = t -> next;
        t -> next -> prev = t -> prev;
            
        delete(t);
    }
    
    node *find_the_key(int k)
    {
        node *t = nil -> next;
        
        while (t != nil && t -> key != k)
            t = t -> next;
            
        return t;
    }
};
 后来,看到算法导论还说我们可以自己手写新建结点和释放结点函数,实现垃圾回收,感觉会快很多呢。我就顺便扩展了一下,实现了自动申请新的更多的空间。 
class list
{
    struct node
    {
        int key;
        node *next;
        node *prev;
    };
    
    const static int lim = 1000000;
    
    node *nil;
    node *fre;
    
    void apply_more(void)
    {
        node *lst = new node[lim];
        
        for (int i = 0; i < lim; ++i)
        {
            lst[i].next = fre;
            fre = lst + i;
        }
    }
    
    node *new_node(void)
    {
        if (fre == NULL)
            apply_more();
            
        node *ret = fre;
        fre = fre -> next;
        
        return ret;    
    }
    
    void free_node(node *t)
    {
        t -> next = fre;
        fre = t;
    }
    
    list(void)
    {
        fre = NULL;
        
        nil = new_node();
        
        nil -> key = -1;
        nil -> next = nil;
        nil -> prev = nil;
    }
    
    void insert_to_head(int k)
    {
        node *t = new_node();
        
        t -> key = k;
        
        t -> prev = nil;
        t -> next = nil -> next;
        t -> next -> prev = nil -> next = t;
    }
    
    void insert_to_tail(int k)
    {
        node *t = new_node();
        
        t -> key = k;
        
        t -> next = nil;
        t -> prev = nil -> prev;
        t -> prev -> next = nil -> prev = t;
    }
    
    void delete_a_node(node *t)
    {
        t -> prev -> next = t -> next;
        t -> next -> prev = t -> prev;
            
        free_node(t);
    }
    
    node *find_the_key(int k)
    {
        node *t = nil -> next;
        
        while (t != nil && t -> key != k)
            t = t -> next;
            
        return t;
    }
};
 @Author: YouSiki

相关内容推荐