Python链表

链表
一、为什么需要链表
顺序表的构建需要预先知道数据大小来申请连续的存储空间，而在进行扩充时又需要进行数据的搬迁，所以使用起来并不是很灵活。

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

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

二、代码定义节点

class Node(object):
    """单链表的结点"""
    def __init__(self,item):
        # _item存放数据元素
        self.item = item
        # _next是下一个节点的标识
        self.next = None

定义单链表

class SingleLinkLink(object):
    """单链表"""
    def __init__(self,node=None):   #头节点为私有属性，加上下划线,用来指向第一个节点
        self._head=node             #头结点 指向用户传进来的node

单链表的操作
is_empty() 链表是否为空
length() 链表长度
travel() 遍历整个链表
add(item) 链表头部添加元素
append(item) 链表尾部添加元素
insert(pos, item) 指定位置添加元素
remove(item) 删除节点
search(item) 查找节点是否存在
class Node(object):
“”“节点”""
def init(self,elem): #定义的数据域和指针域
self.elem=elem
self.next=None

class SingleLinkLink(object):
    """单链表"""
    def __init__(self,node=None):   #头节点为私有属性，加上下划线,用来指向第一个节点
        self._head=node             #头结点 指向用户传进来的node

    def is_empty(self):  #链表是否为空
        return self._head==None

    def length(self):    #链表长度
        p = self._head  # p来移动遍历节点
        count = 0
        while (p != None):  #如果循环条件是p.next!=None，那么到进行到最后一个节点是就不满足条件退出，count没法计数
            count += 1
            p = p.next
        return count

    def travel(self):    #遍历整个链表
        p=self._head
        while(p!=None):
            print(p.elem,end=' ')
            p=p.next

    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:
            p = self._head
            while(p.next!=None):
                p=p.next
            p.next=node
    def insert(self,pos,item): #向任意位置增加节点
        if pos<=0:
            self.add(item)
        elif pos>(self.length()-1):
            self.append(item)
        else:
            pre = self._head
            node = Node(item)
            count = 0
            while (count < (pos - 1)):
                pre = pre.next
                count += 1
                # 当循环结束后，pre指向pos-1的位置
                node.next = pre.next
                pre.next = node


    def remove(self,item):    #删除某个节点
        pre=None
        p=self._head
        while(p!=None):  #保证每一个结点都遍历完
            if p.elem == item:
                if p==self._head:
                    self._head=p.next
                else:
                    pre.next=p.next
                break
            else:
                pre=p
                p=p.next

    def search(self, item):
        """链表查找节点是否存在，并返回True或者False"""
        p = self._head
        while p != None:
            if p.elem == item:
                return True
            p = p.next
        return False


if __name__ == '__main__':
    single_obj=SingleLinkLink()
    print(single_obj.is_empty())
    print(single_obj.length())
    single_obj.append(500)
    single_obj.append(600)
    single_obj.append(700)
    single_obj.append(800)
    single_obj.insert(2,5)
    single_obj.remove(700)
    single_obj.search(1)
    single_obj .travel()


    print(single_obj.length())

三、链表和顺序表的区别
1.顺序表存储（典型的数组）
原理：顺序表存储是将数据元素放到一块连续的内存存储空间，相邻数据元素的存放地址也相邻（逻辑与物理统一）。
优点：（1）空间利用率高。（局部性原理，连续存放，命中率高）
（2）存取速度高效，通过下标来直接存储。
缺点：（1）插入和删除比较慢，比如：插入或者删除一个元素时，整个表需要遍历移动元素来重新排一次顺序。
（2）不可以增长长度，有空间限制,当需要存取的元素个数可能多于顺序表的元素个数时,会出现"溢出"问题.当元素个数远少于预先分配的空间时,空间浪费巨大。
时间性能 :查找 O(1) ,插入和删除O（n）。
2.链表存储
原理：链表存储是在程序运行过程中动态的分配空间，只要存储器还有空间，就不会发生存储溢出问题，相邻数据元素可随意存放，但所占存储空间分两部分，一部分存放结点值，另一部分存放表示结点关系间的指针。
优点：（1）存取某个元素速度慢。
（2）插入和删除速度快，保留原有的物理顺序，比如：插入或者删除一个元素时，只需要改变指针指向即可。
（3）没有空间限制,存储元素的个数无上限,基本只与内存空间大小有关.
缺点：（1）占用额外的空间以存储指针(浪费空间，不连续存放，malloc开辟，空间碎片多)
（2）查找速度慢，因为查找时，需要循环链表访问，需要从开始节点一个一个节点去查找元素访问。
时间性能 :查找 O(n) ,插入和删除O（1）。
*频繁的查找却很少的插入和删除操作可以用顺序表存储，堆排序,二分查找适宜用顺序表.
*如果频繁的插入和删除操作很少的查询就可以使用链表存储
*顺序表适宜于做查找这样的静态操作；链表适宜于做插入、删除这样的动态操作。
*若线性表长度变化不大，如果事先知道线性表的大致长度，比如一年12月，一周就是星期一至星期日共七天，且其主要操作是查找，则采用顺序表；若线性表长度变化较大或根本不知道多大时，且其主要操作是插入、删除，则采用链表，这样可以不需要考虑存储空间的大小问题。
*顺序表:顺序存储，随机读取
链式:随机存储,顺序读取(必须遍历)