单链表

单链表

---

单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。

单链表的最大特点是可以将物理地址上不连续的数据连接起来，通过指针来对物理地址进行操作，实现增删改查等功能。

单链表分为两种：有头链表和无头链表。

• 无头单链表，也就是phead一只是一个指针，指向链表的第一个结点

• 带头节点的单链表：只不过头结点的data不保存信息。
  

python实现单链表

单链表最重要的是实现一些基本的操作，下面用python来实现单链表。

#单链表是由结点连接起来的，首先定义结点类
class Node():
    #结点有两部分组成，数据和指针
    #数据存放该结点的数据元素，指针存放下一个元素的地址,初始化指向None
    def __init__(self,elem):
        self.elem = elem
        self.next = None
#定义单链表类，并实现单链表的各种操作
class SingleLinkList():
    # 初始化单链表,头结点为None
    def __init__(self,node=None):
        self.__head = node
    def is_empty(self):
        '''链表是否为空'''
        # 如果头结点为None，说明为空，返回true
        return self.__head == None
    def length(self):
        '''求链表长度：求链表长度需要从头开始遍历并计数'''
        # 定义游标cut表示指向当前结点，初始指向头结点
        cur = self.__head
        # 定义count用来计数，从0开始
        count = 0
        #循环退出条件：当游标cur指向None时，所有结点都已经被计数
        while cur != None:
            #游标cur没有指向None，循环一次，count计数加1
            count += 1
            #游标cur也向后移动一个结点
            cur = cur.next
        # 循环结束，count的值即为链表长度，返回count
        return count 
        ''' 
        求链表长度时注意考虑特殊情况，即链表为空链表，即头结点为None，
        此处如果为空链表则不会进入循环，count为0，符合要求           
        '''
    def travel(self):
        '''遍历整个链表:需要从头开始，输出每个结点的元素'''
        #定义游标cur表示指向当前结点，初始指向头结点
        cur = self.__head
        #循环退出条件：当游标cur指向None时，所有结点都已经被遍历
        while cur != None:
            #输入当前指向元素
            print(cur.elem, end=" ")
            #游标向后移动一个结点
            cur = cur.next
        # 遍历结束后换行
        print("")
        ''' 
        遍历单链表是注意考虑特殊情况，即链表为空链表，即头结点为None，
        此处如果为空链表则不会进入循环，不会输出任何元素，符合要求           
        '''
    def add(self,item):
        '''头插法：在头部插入结点，不需要遍历'''
        #定义要插入的结点
        node = Node(item)
        # 现将要插入的结点的next指向头结点
        node.next = self.__head
        # 再将头结点变成要插入的结点
        self.__head = node

        '''考虑特殊情况，链表为空链表，即头结点为None，符合要求，无需单独判断处理''' 
    def append(self,item):
        '''尾插法：在尾部插入结点，需要从头遍历找到尾结点，在其后插入结点；
        考虑特殊情况，即向空链表尾部插入结点，空链表即头结点为空，
        需单独考虑，故需要在开始是判断链表是否为空'''
        #定义要插入的结点
        node = Node(item)
        # 判断是否为空链表
        if self.__head == None:
            # 如果是空链表，头结点即指向要插入的结点
            self.__head = node
        else:
            # 如果不是空链表，则需要循环遍历知道链表尾部            
            # 定义游标cur表示指向当前结点，初始时指向头结点
            cur = self.__head
            #循环退出条件，找到尾结点退出，即cur.next 指向None
            while cur.next != None:
                # 游标向后移动一个结点
                cur = cur.next
            # 循环结束后，游标刚好指向尾结点，插入元素,即将当前结点的next指向要插入的结点
            cur.next = node
    
    def insert(self,pos,item):
        '''在指定位置插入结点：插入前需要遍历找到指定位置，在指定位置前插入
        注意考虑特殊情况，如果pos输入的值小于等于0，则认为是在头部插入一个结点，
        如果输入的pos值比链表长度还大，则认为要在为不插入结点'''
         # 定义要插入的结点
        node = Node(item)
        # 判断指定位置的合法性
        # 如果指定位置小于等于0，就默认在头部插入结点
        if pos <= 0:
            self.add(item)
        # 如果指定位置大于最大索引值，就默认在尾部插入结点
        elif pos > self.length()-1:
            self.append(item)
        else:
            # 定义游标pre表示指向所找位置的前一个结点,初始从头结点开始
            pre = self.__head
            #从头开始循环并用count计数，循环退出条件为 count < pos-1
            # count =0  pre指向0号结点  count=1 pre指向1号结点，pre到pos-1的结点即可
            count = 0
            while count < pos-1:
                # count加1
                count += 1
                # pre向后移动一个结点
                pre = pre.next 
            #循环结束，pre指向pos-1的结点，即pos的前一个结点，在pos结点的前面，pos-1结点的后面插入元素
            node.next = pre.next
            pre.next = node
    def remove(self,item):
        '''删除指定元素结点：遍历找到元素为item的结点，便删除，如果链表中有多个结点的元素与item相同，则只删除第一个
        注意考虑特殊情况,链表为空，即cur开始就指向None，则不会进入循环，直接返回false，符合要求'''

        #定义游标cur指向当前结点，初始指向头结点
        cur = self.__head
        #定义游标pre指向当前结点的前一个结点，初始指向None
        pre = None
        # 从头开始循环遍历每个结点
        while cur != None:
            if cur.elem == item:
                #如果找到了，先判断此结点是否为头结点
                if cur == self.__head:
                # 如果删除的元素为头结点，则执行下面代码即可删除
                    # 将当前元素的下一个结点作为头结点
                    self.__head = cur.next
                else:
                    #如果眼删除的不是头结点  
                    pre.next = cur.next
                    #返回True，循环结束
                    return True
            else:
                #如果没有找到，游标pre向后移动一个结点
                pre = cur
                # 游标cur也移动一个结点，注意，一定是先移动pre后移动cur，保持前后关系
                cur = cur.next
        #如果循环结束，即整个链表遍历完了，说明没有找到，则返回flase
        return False
    def search(self,item):
        '''查询指定元素结点：从头循环遍历链表，找到第一个元素为item的结点，输出值
        注意考虑特殊情况 如果链表为空，则cur就是指向None，无法进入循环，直接返回false，符合要求'''
        # 定义游标cur 表示指向当前结点，初始指向头结点
        cur = self.__head
        #循环遍历链表，查找
        while cur != None:
            if cur.elem == item :
                # 如果找到了，则输出，并返回True
                print(cur.elem)
                return True
            else:
                #如果没有找到，cur向后移动一个结点
                cur = cur.next
        # 整个链表遍历结束仍然没有找到，返回false
        return False

if __name__ == '__main__':
    # 实例化一个单链表
    ll = SingleLinkList()
    #判空
    print(ll.is_empty())
    #求长度
    res = ll.length()
    print(res)
    # 在链表尾部添加元素
    ll.append(10)
    ll.append(8)
    ll.append(3)
    ll.append(5)
    ll.append(4)
    # 遍历单链表
    ll.travel()
    # 在链表头部插入元素
    ll.add(100)
    # 再次遍历链表
    ll.travel()
    # 再次判空
    print(ll.is_empty())
    # 在指定位置插入元素
    ll.insert(3,50)
    # 遍历链表
    ll.travel()
    # 搜索元素
    ll.search(3)
    # 删除某元素
    ll.remove(8)
    # 遍历链表
    ll.travel()

True
0
10 8 3 5 4 
100 10 8 3 5 4 
False
100 10 8 50 3 5 4 
3
100 10 50 3 5 4