数据结构与算法笔记(3) - 线性表之链表

用链接关系显示表示元素之间的顺序关系称为链接技术，基于链接技术实现的线性表称为链接表或者链表，链表主要由节点和连接关系组成。
链表的实现主要有以下几种:

1. 单向链表
2. 单向循环链表
3. 双向链表
4. 双向循环链表

1. 单向链表

单向链表的节点是一个二元组，元素域保存数据，指针域指向下一个节点。
单向链表需要一个变量指向首节点，尾结点需要指向空。
定义节点节点类：

class Node(object):
    def __init__(self, elem, next_=None):
        self.elem = elem
        self.next = next_

链表的基本操作：

class LinkedList(object):
    def __init__(self):
        """链表初始化"""
        self.head = None
        
    def is_empty(self):
        """判断表是否为空"""
        return self.head is None

    def length(self):
        """链表长度"""
        count = 0
        if not self.is_empty():
            cur = self.head
            while cur.next:
                cur = cur.next
                count += 1
        return count
    
    def append(self, elem):
          """尾端加入元素"""
          node = Node(elem)
          if self.is_empty():
              self.head = node
          else:
              cur = self.head
              while cur.next:
                  cur = cur.next
              cur.next = node

    def add(self, elem):
        """首端插入元素"""
        node = Node(elem)
        node.next = self.head
        self.head = node

    def insert(self, pos, elem):
        """定位插入元素"""
        if pos <= 0:
            self.add(elem)
        elif pos >= self.length():
            self.append(elem)
        node = Node(elem)
        cur = self.head
        idx = 0
        while idx <= pos-1:
            idx += 1
            cur = cur.next
        node.next = cur.next
        cur.next = node

    def delete(self, pos):
        “”“删除”“”
        if self.is_empty():
            return -1
        if pos == 0:
            self.head = self.head.next
        if pos < 0 or pos >= self.length():
            return -1
        idx = 0
        cur = self.head
        while idx <= pos-1:
            idx += 1
            cur = cur.next
        cur.next = cur.next.next
        
    def travel(self):
        """遍历"""
        cur = self.head
        while cur is not None:
            print(cur.elem)
            cur = cur.next

    def find(self, elem):
        """搜索"""
        cur = self.head
        while cur:
            if cur.elem == elem:
                return cur
            cur = cur.next

    def filter(self, elem):
        """搜索所有满足条件的节点"""
        cur = self.head
        while cur:
            if cur.elem == elem:
                yield cur
            cur = cur.next

    def reverse(self):
        """反转"""
        if self.is_empty():
            return -1
        pre = None
        while self.head.next:
            next_ = self.head.next
            self.head.next = pre
            pre = self.head
            self.head = next_

    def sort(self):
        """排序
        排序有很多种算法，这里只演示插入算法，暂时不考虑逆序。
        插入时通过调整指针的方式排序。
        """
        p = self.head
        if not p or not p.next:
            return
        rem = p.next
        p.next = None
        while rem:
            p = self.head
            q = None
            while p and p.elem <= rem.elem:
                q = p
                p = p.next 
            if q:
                q.next = rem
            else:
                self.head = rem
            q = rem
            rem = rem.next
            q.next = p