数据结构——链表基本功能的代码实现

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

单链表操作实现：
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 SingleLinkList(object):
    '''构造单向链表'''
    def __init__(self, node=None):
        self.__head = node ##双下划线表示私有变量

    def is_empty(self):
        '''链表是否为空'''
        return self.__head is None

    def length(self):
        '''链表长度'''
        #cur游标，用来移动遍历节点
        cur = self.__head
        #count计数器，记录数量
        count = 0
        while cur is not None:
            count += 1
            cur = cur.next
        return count

    def travel(self):
        '''遍历整个链表'''
        # cur游标，用来移动遍历节点
        cur = self.__head
        while cur is not 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 is not None:
                cur = cur.next
            cur.next = node

    def insert(self, pos, item):
        '''链表指定位置添加元素'''
        node = Node(item)
        pre = self.__head ##pre为游标，最终指向指定位置pos前一个节点
        count = 0
        if pos <= 0:
            self.add(item)
        elif pos > (self.length() - 1):
            self.append(item)
        else:
            while count < (pos - 1):
                count += 1
                pre = pre.next
            ##循环结束后，pre位于(pos - 1)节点处
            node.next = pre.next
            pre.next = node


    def remove(self, item):
        '''删除节点'''
        cur = self.__head
        pre = None
        while cur is not None:
            if cur.elem == item:
                #先判断此节点是否为首节点
                if cur == self.__head: #是首节点
                    self.__head = cur.next
                else:
                    pre.next = cur.next
                break
            else:
                pre = cur
                cur = cur.next


    def search(self, item):
        '''查找节点是否存在'''
        cur = self.__head
        while cur is not None:
            if cur.elem == item:
                return True
            else:
                cur = cur.next
        return False

if __name__ == '__main__':
    ll = SingleLinkList()
    print(ll.is_empty())
    print(ll.length())

    ll.append(1)
    print(ll.is_empty())
    print(ll.length())

    ll.append(2)
    ll.add(0)
    ll.append(3)
    ll.append(4)
    ll.append(5)
    ll.append(6)
    ll.insert(-1, -1) #-1,0,1,2,3,4,5,6
    ll.travel()
    ll.insert(2, 8) #-1,0,8,1,2,3,4,5,6
    ll.travel()
    ll.insert(10, 7) #-1,0,8,1,2,3,4,5,6,7
    ll.travel()
    print(ll.search(8)) #Ture
    ll.search(10) #False
    ll.remove(8)
    ll.travel() #-1,0,1,2,3,4,5,6,7

程序运行结果如下：

双向链表
一种更复杂的链表是“双向链表”或“双面链表”。每个节点有两个链接：一个指向前节点，此节点为第一个节点时，指向空值；而另一个指向下一个节点，此节点为最后一个节点时，指向空值。
双向链表操作实现：
is_empty() 链表是否为空
length() 链表长度
travel() 遍历整个链表
add(item) 链表头部添加元素
append(item) 链表尾部添加元素
insert(pos , item) 链表指定位置添加元素
remove(item) 删除节点
search(item) 查找节点是否存在

class Node(object):
    '''构造双向链表节点'''
    def __init__(self, item):
        self.elem = item
        self.prev = None
        self.next = None

class SingleLinkList(object):
    '''构造双向链表'''
    def __init__(self, node=None):
        self.__head = node ##双下划线表示私有变量

    def is_empty(self):
        '''链表是否为空'''
        return self.__head is None

    def length(self):
        '''链表长度'''
        #cur游标，用来移动遍历节点
        cur = self.__head
        #count计数器，记录数量
        count = 0
        while cur is not None:
            count += 1
            cur = cur.next
        return count

    def travel(self):
        '''遍历整个链表'''
        # cur游标，用来移动遍历节点
        cur = self.__head
        while cur is not None:
            print(cur.elem, end=' ')
            cur = cur.next
        print('')

    def add(self, item):
        '''链表头部添加元素'''
        node = Node(item)
        node.next = self.__head
        self.__head = node
        node.next.prev = node #原首节点的前驱链接指向新添加的节点
        #相同操作
        # self.__head.prev = node #原首节点的前驱链接指向新添加的节点
        # self.__head = node#head指向新添加节点

    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):
        '''链表指定位置添加元素'''
        node = Node(item)
        cur = self.__head #cur为游标，最终指向指定位置pos节点
        count = 0
        if pos <= 0:
            self.add(item)
        elif pos > (self.length() - 1):
            self.append(item)
        else:
            while count < pos:
                count += 1
                cur = cur.next
            ##循环结束后，cur位于pos节点处
            node.next = cur#新添加节点的后驱链接指向cur所指向的节点
            node.prev = cur.prev#新添加节点的前驱链接指向cur所指节点的前一个节点
            cur.prev.next = node #cur所指节点的前一个节点的后驱链接指向新添加节点
            cur.prev = node #cur所指节点的前驱链接指向新添加节点
            #相同操作
            # cur.prev = node  # cur所指节点的前驱链接指向新添加节点
            # node.prev.next = node  # node所指节点的前一个节点的后驱链接指向新添加节点（新添加的node已经代替代替了cur来的所指向节点的位置）


    def remove(self, item):
        '''删除节点'''
        cur = self.__head
        while cur is not None:
            if cur.elem == item:
                #先判断此节点是否为首节点
                if cur == self.__head: #是首节点
                    self.__head = cur.next #head指向原首节点的下一个节点
                    if cur.next:
                    #判断原链表是否只有一个节点（判断cur.next这个节点是否存在）
                        cur.next.prev = None #原首节点的下一个节点的前驱链接置空
                else:
                    cur.prev.next = cur.next#cur所指向节点的前一个节点的后驱链接指向cur所指向节点的后一个节点
                    if cur.next:
                    #判断此节点是否为尾节点（判断cur.next这个节点是否存在）
                        cur.next.prev = cur.prev#cur所指向节点的后一个节点的前驱链接指向cur所指向节点的前一个节点
                break
            else:
                cur = cur.next


    def search(self, item):
        '''查找节点是否存在'''
        cur = self.__head
        while cur is not None:
            if cur.elem == item:
                return True
            else:
                cur = cur.next
        return False

if __name__ == '__main__':
    dll = SingleLinkList()
    print(dll.is_empty())
    print(dll.length())

    dll.append(1)
    print(dll.is_empty())
    print(dll.length())

    dll.append(2)
    dll.add(0)
    dll.append(3)
    dll.append(4)
    dll.append(5)
    dll.append(6)
    dll.insert(-1, -1) #-1,0,1,2,3,4,5,6
    dll.travel()
    dll.insert(2, 8) #-1,0,8,1,2,3,4,5,6
    dll.travel()
    dll.insert(10, 7) #-1,0,8,1,2,3,4,5,6,7
    dll.travel()
    print(dll.search(8)) #Ture
    dll.search(10) #False
    dll.remove(8)
    dll.travel() #-1,0,1,2,3,4,5,6,7

程序运行结果如下：

单向循环链表
单链表的一个变形是单向循环链表，链表中最后一个节点的next域不再为None，而是指向链表的头节点。
单向循环链表操作实现：
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 SingleCycleLinkList(object):
    '''构造循环单向链表'''

    def __init__(self, node=None):
        self.__head = node  ##双下划线表示私有变量
        #判断是否有节点存在（判断是否不是只有NOne）
        if node:
            node.next = node #有一个节点时候，它的next域指向首节点，也就是指向自身

    def is_empty(self):
        '''链表是否为空'''
        return self.__head is None

    def length(self):
        '''链表长度'''
        if self.is_empty(): #判断链表是否为空链表，是则直接返回长度为0
            return 0
        # cur游标，用来移动遍历节点
        cur = self.__head
        # count计数器，记录数量
        count = 1
        while cur.next is not self.__head:#当前游标所指节点的next域不是首节点就继续移动
            count += 1
            cur = cur.next
        return count

    def travel(self):
        '''遍历整个链表'''
        if self.is_empty():#判断是否为特殊情况：链表中没有节点
            return
        # cur游标，用来移动遍历节点
        cur = self.__head
        while cur.next is not self.__head:
            print(cur.elem, end=' ')
            cur = cur.next
        #退出循环，cur指向尾节点，但尾节点元素未打印
        print(cur.elem)
        #print('')

    def add(self, item):
        '''链表头部添加元素'''
        node = Node(item)
        if self.is_empty():
            self.__head = node
            node.next = node
        else:
            cur = self.__head
            while cur.next is not self.__head:
                cur = cur.next
            #退出循环，cur指向尾节点
            node.next = self.__head
            self.__head = node
            #cur.next = node
            cur.next = self.__head

    def append(self, item):
        '''链表尾部添加元素'''
        node = Node(item)
        if self.is_empty():
            self.__head = node
            node.next = node
        else:
            cur = self.__head
            while cur.next is not self.__head:
                cur = cur.next
            # 退出循环，cur指向尾节点
            # node.next = cur.next
            node.next = self.__head
            cur.next = node

    def insert(self, pos, item):
        '''链表指定位置添加元素'''
        node = Node(item)
        pre = self.__head  ##pre为游标，最终指向指定位置pos前一个节点
        count = 0
        if pos <= 0:
            self.add(item)
        elif pos > (self.length() - 1):
            self.append(item)
        else:
            while count < (pos - 1):
                count += 1
                pre = pre.next
            ##循环结束后，pre位于(pos - 1)节点处
            node.next = pre.next
            pre.next = node

    def remove(self, item):
        '''删除节点'''
        if self.is_empty(): #没有节点的情况下
            return
        cur = self.__head
        pre = None
        while cur.next is not self.__head:
            if cur.elem == item:
                # 先判断此节点是否为首节点
                if cur == self.__head:  # 是首节点
                    #是首节点的情况
                    #找尾节点
                    rear = self.__head
                    while rear.next is not self.__head:
                        rear = rear.next
                    #退出循环后，rear指向尾节点
                    self.__head = cur.next
                    rear.next = self.__head
                else:
                    #中间节点
                    pre.next = cur.next
                return 
            else:
                pre = cur
                cur = cur.next
            #退出循环，cur指向尾节点
            if cur.elem == item:
                if cur == self.__head:#链表中只有一个节点
                    self.__head = None
                else:
                    pre.next =cur.next


    def search(self, item):
        '''查找节点是否存在'''
        if self.is_empty():
            return False
        cur = self.__head
        while cur.next is not self.__head:
            if cur.elem == item:
                return True
            else:
                cur = cur.next
            #退出循环，cur指向尾节点
        if cur.elem == item:
            return  True
        return False


if __name__ == '__main__':
    ll = SingleCycleLinkList()
    print(ll.is_empty())
    print(ll.length())

    ll.append(1)
    print(ll.is_empty())
    print(ll.length())

    ll.append(2)
    ll.add(0)
    ll.append(3)
    ll.append(4)
    ll.append(5)
    ll.append(6)
    ll.insert(-1, -1)  # -1,0,1,2,3,4,5,6
    ll.travel()
    ll.insert(2, 8)  # -1,0,8,1,2,3,4,5,6
    ll.travel()
    ll.insert(10, 7)  # -1,0,8,1,2,3,4,5,6,7
    ll.travel()
    print(ll.search(8))  # Ture
    ll.search(10)  # False
    ll.remove(8)
    ll.travel()  # -1,0,1,2,3,4,5,6,7

程序运行结果如下：