算法学习day11----双链表--概念

双链表实际上就是单链表增加一个往前指的指针，通过前面单链表的学习，我们知道链表的创建需要两步，一步是指针创建，一步是初始化的头部元素（头节点）创建，那我们增加一个往前的指针，自然也需要配套的尾部元素初始化（尾节点）

在对链表进行操作函数定义时，不仅要像单链表那样指明从左到右的next，也要有从右到左的prior

在代码的改动上只需加上一行即可，比较容易理解

class LNode:                                       
    def __init__(self, elem, next_ = None):
        self.prior = prior//前驱指针，方向为从右往左
        self.elem = elem     					                     
        self.next_ = next_ 
   				                  
 
class LList:                                        
    def __init__(self):
        self.head = None
        self.tail = None//尾节点                  		       

做了注释的就是基于上一篇博客的改动点

操作类也是如此

头插法：

    def insert_head(self, elem):
   
        node = LNode(elem)
 
        if self.head == None:
            self.head = node
            self.tail = self.head//只有一个链表元素时头节点等于尾节点
        else:
            self.head.prior = node//依旧逆向思维
            node.next_ = self.head
            self.head = node

尾插法：

    def insert_tail(self, elem):
        node = LNode(elem)
        if self.head is None:
            self.head = node
            self.tail = node//头即是尾
        else:
            cur = self.head
            while cur.next_ is not None:
                cur = cur.next_
            cur.next_ = node
            node.prior = cur //前指针指一下
            self.tail = node//尾插一个元素，更新链表尾元素

一般插值法：

    def insert_general(self, pos, elem):
    
        node = LNode(elem)
 
        if pos == 0://分类讨论
            if self.head is None:
                self.head = node
                self.tail = node
            else:
                node.next_ = self.head
                self.head.prior = node//往前指
                self.head = node
         count = 0
         cur = self.head
 
         while count < pos - 1:
             cur = cur.next_
             count += 1
 
         node.next_ = cur.next_
         node.prior = cur//往前指
         cur.next_ = node

删除操作：
 

    def remove_general(self, pos):
    
        if pos == 0:
            self.head = self.head.next_
            self.head.prior = None//让新的头前面没有节点    
            return
    
        count = 0
        cur = self.head
    
   
        while count < pos - 1:
            cur = cur.next_
            count += 1
    
    
        cur.next_ = cur.next_.next_
        cur.next_.next_.prior = cur//跳过cur.next_直接让下下的元素的前面指向cur，完成对pos位置节点的删除

查找操作：
不变

    def find_position(self, item):
 
        cur = self.head
        pos = 0
    
        while cur is not None:
            if cur.elem == item:
                return pos  
            cur = cur.next_
            pos += 1
    
        return -1  

总结双链表类：

今天才发现昨天的代码缩进比较乱，盖斯的蟒蛇
 

class LNode:                                       
    def __init__(self, elem, next_ = None):
        self.prior = prior
        self.elem = elem     					                     
        self.next_ = next

class LList:                                        
    def __init__(self):
        self.head = None
        self.tail = None
    
    def insert_head(self, elem):
        node = LNode(elem)
        if self.head == None:
            self.head = node
            self.tail = self.head
        else:
            self.head.prior = node
            node.next_ = self.head
            self.head = node
    
    def insert_tail(self, elem):
        node = LNode(elem)
        if self.head is None:
            self.head = node
            self.tail = node
        else:
            cur = self.head
            while cur.next_ is not None:
                cur = cur.next_
            cur.next_ = node
            node.prior = cur
            self.tail = node
    
    def insert_general(self, pos, elem):
        node = LNode(elem)
        if pos == 0:
            if self.head is None:
                self.head = node
                self.tail = node
            else:
                node.next_ = self.head
                self.head.prior = node
                self.head = node
         count = 0
         cur = self.head
         while count < pos - 1:
             cur = cur.next_
             count += 1
         node.next_ = cur.next_
         node.prior = cur
         cur.next_ = node

    def remove_general(self, pos):
        if pos == 0:
            self.head = self.head.next_
            self.head.prior = None  
            return
        count = 0
        cur = self.head
        while count < pos - 1:
            cur = cur.next_
            count += 1
        cur.next_ = cur.next_.next_
        cur.next_.next_.prior = cur