算法-01-链表

基本概念

单链表实现

class linkNode():
    """
    链表节点类
    """
    def __init__(self,dat):
        self.dat=dat
        self.next=None
class sigLink():
    """
    self.length   用于记录链表的长度
    self.head     链表的头部
    self.tail     记录链表的尾部
    """
    def __init__(self,item):
        """
        item   一位数组，存放改链表的数组
        
        """
        self.length=len(item)
        if self.length<=0:
            return
        i=0
        self.head=linkNode(item[i])
        self.tail=self.head
        i+=1###此句不能少
        while i<self.length:
            self.tail.next=linkNode(item[i])
            self.tail=self.tail.next
            i+=1
    def printlink(self):
        """
            正序打印该链表
        """
        if self.head==None:
            print("该链表为空链表！")
        p=self.head
        while p!=None:
            print(p.dat,end=" ")
            p=p.next
    def getlength(self):
        """
            获取链表的长度
        """
        print("该链表的长度为：",self.length)
    def linkAppend(self,num):
        """在链表尾部追加节点"""
        self.tail.next=linkNode(num)
        self.tail=self.tail.next
        self.length+=1
    def insertNode(self,index,num):
        """
            在链表中间插入节点
            index：插入节点的序号
            num：插入点的值
        """
        if index>self.length:
            print("index参数超出范围")
            return
        if index==self.length:
            self.linkAppend(num)
            return
        if index==0:
            p=linkNode(num)
            p.next=self.head
            self.head=p
            self.length+=1
            return
        ptemp=self.head
        while index>1:
            ptemp=ptemp.next
            index-=1
        p=linkNode(num)
        p.next=ptemp.next
        ptemp.next=p
        self.length+=1
if __name__ == "__main__":
    a=[]
    flag=""
    NodeNum=int(input("请输入节点的个数："))
    for i in range(1,NodeNum+1):
        a.append(int(input("您输入的第%d个节点的值为："%i)))
        
    Link=sigLink(a)
    number=int(input("请你输入你要执行的次数："))
    i=0#标记次数
    while i<number:
        operation=input("请输入你要进行的操作名称：")
        name=flag+str(operation)
        i+=1
        if name=="printlink":
            print("遍历的结果为：")
            Link.printlink()
            print("\n")
        elif name=="getlength":
            Link.getlength()
        elif name=="linkAppend":
            num=int(input("请输入你要追加的数字："))
            Link.linkAppend(num)
            print("追加成功！")
            print("追加之后遍历的结果为：")
            Link.printlink()
            print("\n")
        elif name=="insertNode":
            Index=int(input("你要索引的位置为：："))
            NodeNum=int(input("你要在%d插入的数字："%Index))
            Link.insertNode(Index,NodeNum)
            print("插入成功！")
            print("插入之后遍历的结果为：")
            print("\n")
            Link.printlink()
        if name!="printlink" or name!="getlength"or name!="linkAppend" or name!="insertNode":
            print("输入操作名称有误，请重新输入！")
            

    while i>=number:
        print("\n")
        print("执行次数已经达到，结束程序！")
        i=i-1

双链表实现

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time: 2020-Jul-09
# @Author: xiaofu

class Node(object):
    def __init__(self, value):
        self.value = value
        self.next = None
        self.prev = None


class DoubleLinkedList(object):
    def __init__(self, node=None):
        self.__head = node

    def isEmpty(self):
        """check if the list is empty"""
        return self.__head is None

    def length(self):
        """length of the list"""
        # cur is current position
        cur = self.__head
        count = 0
        while cur != None:
            cur = cur.next
            count += 1
        return count

    def travel(self):
        """traverse through the list"""
        # cur is current position
        cur = self.__head
        while cur != None:
            print(cur.value, end=" ")
            cur = cur.next
        print('')

    def shift(self, value):
        """add a node to the start"""
        node = Node(value)
        if self.isEmpty() == True:
            self.__head = node
        else:
            # link before break
            node.next = self.__head
            self.__head.prev = node
            self.__head = node

    def append(self, value):
        """add a node to the end"""
        node = Node(value)
        if self.isEmpty():
            self.__head = node
        else:
            cur = self.__head
            while cur.next != None:
                cur = cur.next
            cur.next = node
            node.prev = cur

    def insert(self, pos, value):
        """insert a node at specific position"""
        if pos <= 0:
            self.shift(value)
        elif pos > (self.length() - 1):
            self.append(value)
        else:
            node = Node(value)
            cur = self.__head
            count = 0
            while count < pos:
                cur = cur.next
                count += 1
            node.next = cur
            node.prev = cur.prev
            cur.prev.next = node
            cur.prev = node

    def remove(self, value):
        """remove a node from list when a value first appears"""
        cur = self.__head
        # remove the first node
        if cur.value == value:
            if cur.next is None:
                self.__head = None
            else:
                self.__head = cur.next
                cur.next.prev = None
            return value
        # elif self.length() == 0:
        elif self.__head is None:
            return
        else:
            while cur.next != None:
                if cur.value == value:
                    cur.next.prev = cur.prev
                    cur.prev.next = cur.next
                    return value
                else:
                    cur = cur.next
            if cur.value == value:
                cur.prev.next = None
                return value
            return

    def exist(self, value):
        """whether a node exists in list"""
        cur = self.__head
        while cur != None:
            if cur.value == value:
                return True
            else:
                cur = cur.next
        return False


if __name__ == "__main__":
    dll = DoubleLinkedList()

    print(dll.exist(10))
    print(dll.length())
    print(dll.isEmpty())

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

    dll.append(2)
    dll.append(3)
    dll.append(4)
    dll.append(5)
    dll.append(6)
    dll.shift(8)
    dll.insert(2, 9)
    dll.insert(-2, 10)
    dll.insert(100, 11)
    dll.travel()
    print(dll.length())
    print(dll.isEmpty())
    print(dll.exist(100))
    print(dll.exist(6))

    dll.remove(6)
    dll.remove(10)
    dll.remove(11)
    print(dll.exist(6))

    dll.travel()

方法

1. 初始化
2. 末尾添加元素
3. 插入元素
4. 获取长度
5. 查找
6. 最大值
7. 最小值
8. 删除元素
9. 遍历