python代码——顺序表和链表

python代码——顺序表和链表

顺序表：

import random
random.seed(10)

#定义顺序表类
class Sqlist():
    #初始化类
    def __init__(self,length):
        self.length = length
        self.sqlist = [random.randint(1,10) for i in range(length)]  #顺序表生成随机数
    #输出所有元素
    def Show(self):
        return self.sqlist
    #取值
    def GetEle(self,i):
        #判断要取的第i个元素，是否在取值范围
        if i>0 and i<=self.length:
            return self.sqlist[i-1]
        else:
            return False
    #查找
    def SearchEle(self,ele):
        SearchList=[]
        #通过遍历列表，查找ele元素,返回索引
        for i in range(self.length):
            if ele == self.sqlist[i]:
                SearchList.append(i)
        if SearchLisr != []:
            return SearchList
        else:
            return '没有找到'
    #插入
    def InsertEle(self,i,ele):
        if i=>0 and i<=self.length:
            return self.sqlist.insert(i,ele)  #list中的insert函数，i表示索引位置
        else:
            return False
    #删除
    def DeleEle(self,i):
        if i=>0 and i<=self.length:
            return self.sqlist.pop(i)  #list中的pop函数
        else:
            return False

单链表：

import random
random.seed(10)

# 定义节点，包含指针和数值
class SingleNode():
    def __init__(self,item):
        self.item = item
        self.next = None

#定义单链表类
class SingleLinkList():
    def __init__(self):
        self.head = None
    #判断列表是否为空
    def is_empty(self):
        return self.head = None
    #输出链表长度
    def GetLenth(self):
        return len(self.travel())
    #遍历链表
    def travel(self):
        show_list = []  #创建空数组，存储链表各结点元素值
        if self.is_empty():
            return None
        node = self.head  #从头节点开始遍历
        while node != None:  #当结点为空时，到链表尾部，停止遍历
            show_list.append(node.item)
            node = node.next # 跳向下一个结点
        return show_list
    #头插法（创建单链表）
    def add(self,newItem):
        node = SingleNode(newItem)
        node.next = self.head # 指针变换
        self.head = node
    #尾插法
    def append(self,newItem):
        node = SingleNode(newItem)
        # 从头结点开始遍历
        nod = self.head
        while nod.next != None: # 当下一个结点的next为None时，停止遍历
            nod = nod.next
        nod.next = node

    # 指定位置添加元素
    def insert(self, i, newItem): 
        if i < 1 or i > self.get_length():
            print("输入的位置有误！")
            return False
        elif i == 1:
            self.add()
        elif i == self.get_length():
            self.append()
        else:   #当要添加的元素位置，既不在链表头部也不再尾部时
            j = 1   #当j增加到i时
            add_node = SingleNode(newItem) # 要添加的结点
            node = self.head # 临时结点变量
            while j < i - 1:
                node = node.next
                j += 1
            add_node.next = node.next 
            node.next = add_node
            return True
    # 删除指定位置上的结点
    def remove(self,i):
        if i< 1 or i > self.get_length():
            print("输入的位置有误！")
            return False
        else:
            j = 1
            nod = self.head
            while j < i-1:
                node = node.next
                j += 1
            node.next = node.next.next
            return True
    # 查找指定位置的结点值
    def find(self, i):
        if i < 1 or i > self.get_length():
            print("输入的位置有误！")
            return False
        else:
            j = 1
            node = self.head
            while j < i:
                node = node.next
                j += 1
            return node.item
    # 更新链表中某个位置的值
    def update(self, i, newItem):
        if i < 1 or i > self.get_length():
            print("输入的位置有误！")
            return False
        else:
            j = 1
            node = self.head
            while j < i:
                node = node.next
                j += 1
            node.item = newItem
            return True
    # 清空链表
    def clear(self):
        self.head = None

循环单链表：

import random
random.seed(10)
# 定义结点类，包含两个成员：结点元素值和指向下一结点的指针
class SingleNode():
    # 结点类初始化
    def __init__(self, item):
        self.item = item  # item存放结点的数值
        self.next = None

# 定义单链表，
class SingleCycleLinkList():
    # 链表类初始化
    def __init__(self):
        self.head = None
    # 判断链表是否为空
    def is_empty(self):
        return self.head == None
    # 遍历整个链表
    def travel(self):
        show_list = []
        if self.is_empty():
            print("链表为空！")
            return None
        node = self.head
        while node.next != self.head: # 当结点的下一个指向不是头结点时
            show_list.append(node.item)
            node = node.next
        show_list.append(node.item) # 将尾结点的item添加到列表里
        return show_list
    
    # 头插法创建单链表
    def add(self, newItem):
        node = SingleNode(newItem) # 定义新结点对象
         # 如果为空链表
        if self.is_empty():
            self.head = node # 则头结点即为当前结点
            node.next = node # 只有一个头结点时，那么头结点下一指向即为当前结点（单向循环）
            return # 跳出函数
        # 如果不是空链表，那么就遍历找到尾结点
        nod = self.head
        while nod.next != self.head: # 当前结点的next为头结点时，停止遍历
            nod = nod.next
        node.next = nod.next # 在语句执行之前，尾结点指向头结点，所以先让新结点的next指向尾结点的next(即为头结点)
        nod.next = node # 再让尾结点的next指向新结点
        self.head = node # 头结点即为插入的新结点

    # 尾插法
    def append(self, newItem):
        node = SingleNode(newItem)
        nod = self.head # 定义nod为临时结点
        while nod.next != self.head: # 当nod下一结点为头结点时，停止遍历
            nod = nod.next
        node.next = nod.next # 在语句执行之前，尾结点指向头结点，所以先让新结点的next指向尾结点的next(即为头结点)
        nod.next = node
    
    # 输出链表长度
    def get_length(self):
        return len(self.travel())
    
    # 指定位置添加元素
    def insert(self, i, newItem):
        node = SingleNode(newItem)
        if i < 1 or i > self.get_length():
            print("输入的索引有误！")
            return False
        elif i == 1: 
            self.add(newItem)
        elif i == self.get_length():
            self.append(newItem)
        else:
            nod = self.head
            j = 1
            while j < i - 1:
                nod = nod.next
                j += 1
            node.next = nod.next
            nod.next = node
        return True
    
    # 删除指定位置上的结点
    def remove(self, i):
        if i < 1 or i > self.get_length():
            print("输入的索引有误！")
            return False
        else:
            nod = self.head
            j = 1
            while j < i - 1:
                nod = nod.next
                j += 1
            nod.next = nod.next.next
            return True

    # 查找指定位置的结点值
    def find(self, i):
        if i < 1 or i > self.get_length():
            print("输入的索引有误！")
            return False
        else:
            nod = self.head
            j = 1
            while j < i: # 找到指定位置得结点，停止循环
                nod = nod.next
                j += 1
            return nod.item
        
    # 更新链表中某个位置的值
    def updata(self, i, newItem):
        if i < 1 or i > self.get_length():
            print("输入的索引有误！")
            return False
        else:
            nod = self.head
            j = 1
            while j < i: # 找到指定位置得结点，停止循环
                nod = nod.next
                j += 1
            nod.item = newItem
            return True

    # 清空链表
    def clear(self):
        self.head = None

双向链表：

import random
random.seed(10)

# 定义结点类，包含三个成员
class SingleNode():
    # 结点类初始化
    def __init__(self, item):
        self.item = item  # item存放结点的数值
        self.prior = None # 指向上一结点的指针
        self.next = None # 指向下一结点的指针

# 定义双向链表
class DoubleLinkList():
    # 链表类初始化
    def __init__(self):
        self.head = None # 头结点
        self.tail = None # 尾结点
    
    # 判断链表是否为空
    def is_empty(self):
        return self.head == None
    
    # 输出链表长度
    def get_length(self):
        return len(self.travel())
    
    # 遍历整个链表
    def travel(self):
        show_list = [] # 创建个空数组，存储链表各结点元素值
        if self.is_empty():
            print("链表为空！")
            return None
        nod = self.head # 从头节点开始遍历
        while nod != None: # 当结点为空时，到链表尾部，停止遍历
            show_list.append(nod.item)
            nod = nod.next # 跳向下一个结点
        return show_list
    
    # 头插法创建单链表
    def add(self, newItem):
        node = SingleNode(newItem)
        # 如果为空
        if self.is_empty():
            node.next = self.head # 指针变换
            self.tail = node # 当只有一个结点时，头结点即为尾结点，且头插法只定义这一次尾结点即可，因为是往前添加结点
            self.head = node # 头结点即为当前结点
            return
        # 如果不为空
        node.next = self.head
        self.head.prior = node
        self.head = node
    
    # 尾插法
    def append(self, newItem):
        node = SingleNode(newItem)
        if self.is_empty(): # 链表为空时，头结点与尾结点均为新插入的结点
            self.head = node 
            self.tail = node
            return
        # 从头结点开始遍历
        nod = self.head
        while nod.next != None: # 当下一个结点的next为None时，停止遍历//  注：跟网上不一样，回头用尾插法新建单链表试试
            nod = nod.next
        nod.next = node
        node.prior = nod
        self.tail = node # 尾插法时尾结点即为新插入的结点
    
    # 链表反转
    def reverse(self):
        reverse_list = [] # 创建个空数组，存储链表反转后各结点元素值
        if self.is_empty():
            print("链表为空！")
            return None
        nod = self.tail # 从尾节点开始遍历
        while nod != self.head: # 从尾结点使用前向指针往前遍历
            reverse_list.append(nod.item)
            nod = nod.prior # 前进一个结点
        reverse_list.append(nod.item) # 加入头结点的值
        return reverse_list
    
    # 指定位置添加元素
    def insert(self, pos, newItem): # 在指定pos位置上添加数据为newItem的结点
        if pos < 1 or pos > self.get_length():
            print("输入的位置有误！")
            return False
        elif pos == 1:
            self.add()
        elif pos == self.get_length():
            self.append()
        else: # 当要添加的元素位置，既不在链表头部也不再尾部时
            j = 1 # 当j增加到i时
            add_nod = SingleNode(newItem) # 要添加的结点
            nod = self.head # 临时结点变量
            while j < pos - 1:
                nod = nod.next
                j += 1
            add_nod.next = nod.next 
            nod.next = add_nod
            return True
    
    # 删除指定位置上的结点
    def remove(self, pos):
        if pos < 1 or pos > self.get_length():
            print("输入的位置有误！")
            return False
        else:
            j = 1
            nod = self.head
            while j < pos-1:
                nod = nod.next
                j += 1
            nod.next = nod.next.next
            return True
    
     # 查找指定位置的结点值
    def find(self, pos):
        if pos < 1 or pos > self.get_length():
            print("输入的位置有误！")
            return False
        else:
            j = 1
            nod = self.head
            while j < pos:
                nod = nod.next
                j += 1
            return nod.item
          
    # 更新链表中某个位置的值
    def update(self, pos, newItem):
        if pos < 1 or pos > self.get_length():
            print("输入的位置有误！")
            return False
        else:
            j = 1
            nod = self.head
            while j < pos:
                nod = nod.next
                j += 1
            nod.item = newItem
            return True
    
    # 清空链表
    def clear(self):
        self.head = None
        self.tail = None