Python数据结构与算法3-链表1

d - 线性表
1）顺序表
2）链表: 不连续地储存数据，而是在每一个储存节点里存放下一个节点的位置。可以充分利用计算机的储存空间，实现动态的内存管理。

• 单向链表
  每个节点包含信息域（元素域）和链接域（指针域），每个节点指向下一个节点，尾节点指向空值。
  
  elem用来存放数据，next用来存放下一节点位置，p为头指针，指向头节点位置。

• Python变量标示本质

python中，变量名并不代表储存数据的内存空间的别名，而是另一个单独的内存空间。
如下例：

a = 10
b = 20
a,b = b,a

python中的“=”是改变指向的意思，而非将右边值存入左边的内存空间内。

• 节点实现

# 构造节点
class Node(object):
    def __init__(self, elem):
        self.elem = elem
        self.next = None

• 单链表各种操作的实现

# 构造单链表
class SingleLinkedList(object):
    def __init__(self, node = None):
        self.__head = node
        
    def is_empty(self):
        '''链表是否为空'''
        return self.__head == None
    
    def length(self):
        '''链表长度'''
        cur = self.__head
        count = 0
        while cur != None:
            count += 1
            cur = cur.next
        return count 
    
    def travel(self): 
        '''遍历整个链表'''
        cur = self.__head
        while cur != None:
            print(cur.elem, end = " ")
            cur = cur.next
        print("")
    
    def add(self, item):
        '''链表头部添加元素，头插法'''
        node = Node(item)
        # 先将新节点指向第一个节点
        node.next = self.__head
        # 再讲头指针指向新节点
        self.__head = node
    
    def append(self, item):
        '''链表尾部添加元素, 尾插法'''
        node = Node(item)
        if self.is_empty():
            self.__head = node
            
        else:
            cur = self.__head
            while cur.next != None:
                cur = cur.next
            cur.next = node
    
    def insert(self, pos, item):
        '''指定位置添加元素'''
        if pos <= 0:
            # 当pos<=0时，认为是在头部添加.
            self.add(item)
            
        elif pos > self.length()-1:
            # 当pos大于总长度时，认为是在尾部添加
            self.append(item)
            
        else:
            node = Node(item)
            pre = self.__head
            count = 0
            #指针移动到插入位置前一个节点处
            while count < pos-1:
                count += 1
                pre = pre.next

            node.next = pre.next
            pre.next = node
    
    def remove(self, item):
        '''删除节点'''
        cur = self.__head
        pre = None
        while cur != None:
            if cur.elem == item:
                if not pre:
                    # 如果删除元素在头节点,头指针指向头节点后继节点
                    self.__head = cur.next
                
                else:
                    # 如果在其他位置上，前节点指针直接指向现节点的后继节点
                    pre.next = cur.next
                break
            else:
                pre = cur
                cur = pre.next
                
    
    def search(self, item):
        '''查找节点是否存在'''
        cor = self.__head
        while cor != None:
            if cor.elem == item:
                return True
            else:
                cor = cor.next
        return False

• 链表与顺序表的比对
  
  顺序表：需要连续整块的存储空间，如没有相应大小的存储空间，则无法达到要求，但能够快速访问元素。

  链表：可以充分利用离散的存储空间，但是空间额外开销大，且失去了快速访问元素的能力。

  顺序表和链表插入数据时间复杂度都为O(n)，但顺序表主要将时间用于数据搬迁，而链表主要用于数据遍历。