单双链表

集合中存储的元素是有顺序的。顺序表的结构可以分为两种形式：单数据类型和多数据类型。

　　单数据类型：例如np.array

　　单数据类型：内存连续开辟，在内存中存储 int a = 10，20，30图例如下

　　

　　多数据类型：例如python中的list

　　多数据类型：内存非连续开辟，在内存中如何存储 li = 10,'a',96.5,如何获取每一个数据值呢？

　　

 　　- 顺序表的弊端：顺序表的结构需要预先知道数据大小来申请连续的存储空间，而在进行增加删除时又需要进行数据的搬迁。

　 　- Python中的 list 和 tuple 两种类型采用了顺序表的实现技术。

三、链表

　　相对于顺序表，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。

　　链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是不像顺序表一样连续存储数据，而是每一个结点（数据存储单元）里存放下一个结点的信息（即地址）：

　　

四、单向链表：

　　单向链表也叫单链表，是表中最简单的一种形式，它的每个节点包含两个域，一个信息域（元素域）和一个链接域。这个链接指向链表中的下一个节点，而最后一个节点的链接域则指向一个空值。

　　　　- 表中元素elem用来存放具体的数据。

　　　　- 链接域next用来存放下一个节点的位置。

　　　　- 变量p指向链表的头节点（首节点）的位置，从p出发能找到表中的任意节点。

　　单向链表的抽象数据类型定义：

　　　　. is_empty()：链表是否为空

　　　　. length()：链表长度

　　　　. travel()：遍历整个链表

　　　　. add(item)：链表头部添加元素

　　　　. append(item)：链表尾部添加元素

　　　　. insert(pos, item)：指定位置添加元素

　　　　. remove(item)：删除节点

　　　　. search(item)：查找节点是否存在

# 第一步：创建节点(node)
class Node(object):
    def __init__(self,item):
        # 存放新节点的值
        self.item = item
        # 新节点没有下一个链接地址
        self.next = None

# 创建链接
class Link(object):
    def __init__(self):
        # _head永远指向的第一个节点的地址
        self._head = None
        
    # 添加一个链接
    def add(self,item):
        # 创建新节点
        node = Node(item)
        # 将新节点的next地址指向 旧节点的_head指向
        node.next = self._head
        # 新节点地址指向新节点内存空间地址
        self._head = node
        
    # 获取链表值
    def travel(self):
        # 获取第一个节点指针
        cur = self._head
        
        # 判断链表next指向为空时，则为链表的最后一个节点
        while cur:
            # 打印节点item属性值
            print(cur.item)
            # 将新的节点指针赋值给cur变量
            cur = cur.next
            
    def length(self):
        # 获取第一个节点指针
        cur = self._head
        # 长度计数器
        count = 0
        
        # 判断链表next指向为空时，则为链表的最后一个节点
        while cur:
            # 打印节点item属性值
            count += 1
            # 将新的节点指针赋值给cur变量
            cur = cur.next
            
        # 打印计数器
        print("当前链表长度： ",count)
        return count
        


    # 判断链表是否为空
    def isEmpty(self):
        # 判断链表指针为None时，链表为空，返回True
        return self._head == None

    
    # 链表尾部追加元素
    def append(self,item):
        node = Node(item)

        # 判断链表是否为空
        if self.isEmpty():
            # 链表为空，添加新节点
            self._head = node
            return

        # 链表不为空，追加节点
        cur = self._head
        # 定义一个变量，保存前一个节点的地址
        pre = None

        # 判断
        while cur:
            pre = cur
            cur = cur.next

        # 最后next指针指向新加节点
        pre.next = node

    # 查询链表 查询成功返回True,否则返回False
    def search(self,item):
        find = False
        cur = self._head

        while cur:
            # 查询成功
            if cur.item == item:
                find = True
                break
            else:
                # 链表指针指向下一个链表节点
                cur = cur.next

        return find

    # 链表的插入操作
    def insert(self,pos,item):
        # 查询链表长度
        length = self.length()
        if pos <=0 or pos >length:
            print("插入位置超出范围！！！")
            return

        # pos添加的位置规定从1开始
        node = Node(item)
        cur = self._head
        pre = None
        
        # 在位置1插入
        if pos == 1:
            node.next = self._head
            self._head = node
            return 

        # for循环，使链表指针指向pos插入位置
        for i in range(1,pos):
            pre = cur
            cur = cur.next

        # 此时链表指针指向需要插入数据的位置
        # 此时把pre指向的上一个指针地址指向插入节点的地址
        pre.next = node
        # 把插入节点地址指针指向下一个节点地址
        node.next = cur

    # 删除指定位置节点
    def remove(self,item):
        # 获取第一个节点指针
        cur = self._head
        pre = None

        # 此处没有节点可以删除
        if self._head == None:
            return

        # 删除第一个节点
        if cur.item == item:
            self._head = cur.next
            return

        # 删除其他位置节点
        while cur:
            # 将新的节点指针赋值给下一个节点地址
            if cur.item == item:
                pre.next = cur.next
                break
            else:
                pre = cur
                cur = cur.next



# 链表测试
# 实例化链表对象
link = Link()
# 添加节点
link.add(1)
link.add(2)
link.add(3)
# 显示链表值
link.travel()

# 删除元素2
link.remove(2)
link.travel()

# 插入在链表位置1处插入一个节点6
link.insert(4,8)
link.travel()

五、单向循环链表

　　单链表的一个变形是单向循环链表，链表中最后一个节点的next域不再为None，而是指向链表的头结点。

　　基本操作和单链表基本一样，实现代码如下：

# coding=utf-8
# 单向循环链表


class Node:
    """节点"""
    def __init__(self, item):
        self.item = item
        self.next = None

    def __str__(self):
        return str(self.item)


class SinCycLinkedList:
    """单向循环链表"""
    def __init__(self):
        self._head = None

    def is_empty(self):
        """判断链表是否为空"""
        return self._head is None

    def length(self):
        """链表长度"""
        if self.is_empty():
            return 0
        count = 1
        cur = self._head
        while cur.next != self._head:
            # print("cur", cur.item)
            count += 1
            cur = cur.next
        return count

    def travel(self):
        """遍历"""
        if self.is_empty():
            return

        cur = self._head
        print(cur.item)
        while cur.next != self._head:
            cur = cur.next
            print(cur.item)

    def add(self, item):
        """在头部添加一个节点"""
        node = Node(item)
        if self.is_empty():
            self._head = node
            node.next = self._head
        else:
            node.next = self._head
            cur = self._head
            while cur.next != self._head:
                cur = cur.next

            cur.next = node
            self._head = node

    def append(self, item):
        """在尾部添加一个节点"""
        node = Node(item)
        if self.is_empty():
            self._head = node
            node.next = self._head
        else:
            cur = self._head
            # print(type(cur), cur.item, cur.next)
            while cur.next != self._head:
                cur = cur.next

            # print(cur.item)
            cur.next = node
            node.next = self._head

    def insert(self, pos, item):
        """指定位置pos添加节点"""
        if pos <= 0:
            self.add(item)
        elif pos > (self.length() - 1):
            self.append(item)
        else:
            node = Node(item)
            cur = self._head
            cur_pos = 0
            while cur.next != self._head:
                if (pos - 1) == cur_pos:
                    node.next = cur.next
                    cur.next = node
                    break
                cur_pos += 1
                cur = cur.next

    def remove(self, item):
        """删除一个节点"""
        if self.is_empty():
            return

        pre = self._head
        # 删除首节点
        if pre.item == item:
            cur = pre
            while cur.next != self._head:
                cur = cur.next

            cur.next = pre.next     # 删除首节点（跳过该节点）
            self._head = pre.next   # 重新指定首节点

        # 删除其他的节点
        else:
            cur = pre
            while cur.next != self._head:
                if cur.next.item == item:
                    cur.next = cur.next.next
                cur = cur.next

    def search(self, item):
        """查找节点是否存在"""
        if self.is_empty():
            return -1

        cur_pos = 0
        cur = self._head
        if cur.item == item:
            return cur_pos

        while cur.next != self._head:
            if cur.item == item:
                return cur_pos
            cur_pos += 1
            cur = cur.next

        if cur_pos == self.length() - 1:
            return -1


if __name__ == "__main__":
    ll = SinCycLinkedList()
    ll.add(1)       # 1
    ll.add(2)       # 2 1
    # ll.travel()
    ll.append(3)    # 2 1 3
    ll.insert(2, 4) # 2 1 4 3
    ll.insert(4, 5) # 2 1 4 3 5
    ll.insert(0, 6) # 6 2 1 4 3 5
    print("length:", ll.length())        # 6
    ll.travel()                           # 6 2 1 4 3 5
    print("search(3)", ll.search(3))     # 4
    print("search(7)", ll.search(7))     # -1
    print("search(6)", ll.search(6))    # 0
    print("remove(1)")
    ll.remove(1)
    print("length:", ll.length())       # 6 2 4 3 5
    print("remove(6)")
    ll.remove(6)
    ll.travel()

六、双向链表

　　一种更复杂的链表是 "双向链表" 或 "双面链表"。每个节点有两个链接：一个指向前一个节点，当次节点为第一个节点时，指向空值；而另一个指向下一个节点，当此节点为最后一个节点时，指向空值。

　　

　　代码实现：

# coding=utf-8
# 双向链表


class Node:
    """节点"""
    def __init__(self, item):
        self.item = item
        self.prev = None
        self.next = None


class DLinkList:
    """双向链表"""
    def __init__(self):
        self._head = None

    def is_empty(self):
        """判断链表是否为空"""
        return self._head is None

    def length(self):
        """获取链表长度"""
        if self.is_empty():
            return 0
        else:
            cur = self._head
            count = 1
            while cur.next is not None:
                count += 1
                cur = cur.next

            return count

    def travel(self):
        """遍历链表"""
        print("↓↓" * 10)
        if self.is_empty():
            print("")

        else:
            cur = self._head
            print(cur.item)
            while cur.next is not None:
                cur = cur.next
                print(cur.item)
        print("↑↑" * 10)

    def add(self, item):
        """链表头部添加节点"""
        node = Node(item)
        if self.is_empty():
            self._head = node
        else:
            cur = self._head

            node.next = cur
            cur.prev = node
            self._head = node

    def append(self, item):
        """链表尾部添加节点"""
        node = Node(item)
        if self.is_empty():
            self._head = node
        else:
            cur = self._head
            # 遍历找到最后一个节点
            while cur.next is not None:
                cur = cur.next

            # 在尾节点添加新的节点
            cur.next = node
            node.prev = cur

    def insert(self, pos, item):
        """指定位置添加"""
        # 头部添加
        if pos <= 0:
            self.add(item)

        # 尾部添加
        elif pos > (self.length() - 1):
            self.append(item)

        # 其他位置添加
        else:
            node = Node(item)

            cur = self._head
            cur_pos = 0
            while cur.next is not None:
                if cur_pos == (pos - 1):
                    # 与下一个节点互相指向
                    node.next = cur.next
                    cur.next.prev = node
                    # 与上一个节点互相指向
                    cur.next = node
                    node.prev = cur
                cur_pos += 1
                cur = cur.next

    def remove(self, item):
        """删除节点"""
        if self.is_empty():
            return
        else:
            cur = self._head
            # 删除首节点
            if cur.item == item:
                self._head = cur.next
                cur.next.prev = None

            # 删除其他节点
            else:
                while cur.next is not None:
                    if cur.item == item:
                        # 删除之前：1 ←→ [2] ←→ 3
                        # 删除之后：1 ←→ 3
                        cur.prev.next = cur.next
                        cur.next.prev = cur.prev
                    cur = cur.next

                # 删除尾节点
                if cur.item == item:
                    cur.prev.next = None


    def search(self, item):
        """查找节点是否存在"""
        if self.is_empty():
            return -1
        else:
            cur = self._head
            cur_pos = 0
            while cur.next is not None:
                if cur.item == item:
                    return cur_pos

                cur_pos += 1
                cur = cur.next

            if cur_pos == (self.length() - 1):
                return -1


if __name__ == "__main__":
    ll = DLinkList()
    ll.add(1)       # 1
    ll.add(2)       # 2 1
    ll.append(3)    # 2 1 3
    ll.insert(2, 4) # 2 1 4 3
    ll.insert(4, 5) # 2 1 4 3 5
    ll.insert(0, 6) # 6 2 1 4 3 5
    print("length:", ll.length())   # 6
    ll.travel()                 # 6 2 1 4 3 5
    print("search(3)", ll.search(3))
    print("search(4)", ll.search(4))
    print("search(10)", ll.search(10))
    ll.remove(1)
    print("length:", ll.length())
    ll.travel()
    print("删除首节点 remove(6)：")
    ll.remove(6)
    ll.travel()
    print("删除尾节点 remove(5)：")
    ll.remove(5)
    ll.travel()