【Python数据结构与算法】线性结构小结

#左边为顶,右边为低
class Stack:
    def __init__(self):
        self.items = []
 
    def isEmpty(self):
        return self.items == []
 
    def push(self,item):
        self.items.insert(0,item)
 
    def pop(self):
        return self.items.pop(0)
 
    def peek(self):
        return self.items[0]
 
    def size(self):
        return len(self.items)

2.右为栈顶,时间复杂度O(1)

python 复制代码

# 左边为低,右边为顶--->更高效
class Stack:#Stack---->ADT
    def __init__(self):
        self.items =[]
 
    def isEmpty(self):
        return self.items == []
 
# 满足这些属性(行为)的是栈
    def push(self,item):
        self.items.append(item)
 
    def pop(self):
        return self.items.pop()
 
    def peek(self):
        return self.items[len(self.items)-1]
 
    #
    def size(self):
        return len(self.items)
 
s = Stack()

链接👉:http://t.csdnimg.cn/hYT1x

2.队列Queue

队列Queue维持了数据项先进先出FIFO的次序
queue的基本操作包括enqueue， dequeue,isEmpty 有助于构建时序模拟

书写表达式的方法有前缀prefix、中缀infix和后缀postfix三种由于栈结构具有次序反转的特性，所以栈结构适合用于开发表达式求值和转换的算法
"模拟系统"可以通过一个对现实世界问题进行抽象建模，并加入随机数动态运行为复杂问题的决策提供各种情况的参考队列queue可以用来进行模拟系统的开发

链接👉:http://t.csdnimg.cn/3xKyl

3.双端队列Deque

双端队列Deque可以同时具备栈和队列的功能

deque的主要操作包括addFront，addRear, removeFront, removeRear, isEmpty

python 复制代码

#创建一个双端队列(Dequeue)
class Dequeue:
    #定义一个初始化函数然后创建一个空列表用于传递数据items
    def __init__(self):
        self.items = []
 
    #判断列表是否为空
    def isEmpty(self):
        return self.items == []
 
     #在队首加入元素items
    def addFront(self,item):
        self.items.append(item)
 
    #在队尾加入元素items
    def addRear(self,item):
        self.items.insert(0,item)
 
 
    #从队首移除数据,返回值为移除数据项
    def removeFront(self):
        return self.items.pop()
 
    #从队尾移除数据,返回移除数据项
    def removeRear(self):
        return self.items.pop(0)
 
    #判断列表是否为空
    def isEmpty(self):
        return self.items == []
 
    #返回Dequeue中包含的数据项的个数
    def size(self):
        return len(self.items)
 
#palindrome - 回文检查
def  pal_checker (ps):
    #实例化对象
    d = Dequeue()
    for char in  ps:
        d.addRear(char)
 
    #假设元素左右相等
    still_equal = True
    #依次取出首尾元素进行判断,然后再判断它是否满足 :
    # 奇数个元素的时候,双端队列里面还剩下一个元素
    #偶数个元素的时候,双端队列里面没有元素
    while d.size() > 1 and still_equal :
        #从队首取出一个元素
        first = d.removeFront()
        #从队尾取出一个元素
        last = d.removeRear()
        if first != last:
            still_equal = False
    return still_equal
 
print(pal_checker ("上海自来水来自海上"))
print(pal_checker ("110110"))

链接👉:http://t.csdnimg.cn/GxnBy

4.列表List

列表List是数据项能够维持相对位置的数据集

python 复制代码

# 通过链表实现 无序表-列表
#列表 和 链表 都是无序表 unordered list
#实现链表
class Node:
    def __init__(self,init_data):
        self.data = init_data
        self.next = None
    #获得数据项
    def get_data(self):
        return self.data
    #获得节点
    def get_next(self):
        return self.next
    #设置数据项
    def set_data(self,new_data):
        self.data = new_data
    #设置节点
    def set_next(self,new_next):
        self.next = new_next
 
#结点示例
temp = Node(93)
print(temp.get_data())

链接👉:http://t.csdnimg.cn/nXztJ

5.链表

链表的实现，可以****保持列表维持相对位置( 保证逻辑顺序**)的特点，而不需要连续的存储空间**
**链表实现时，其各种方法，**对链表头部head需要特别的处理

a.无序链表的实现

python 复制代码

# 通过链表实现 无序表-列表
#列表 和 链表 都是无序表 unordered list
#实现链表 -- 链表相当于火车(顺藤摸瓜结构,如果放在链表后面,找那个车厢需要从头开始往后找)
class Node:#结点Node相当于车厢
    def __init__(self,init_data):
        self.data = init_data
        self.next = None
    #获得数据项
    def get_data(self):
        return self.data
    #获得节点
    def get_next(self):
        return self.next
    #设置数据项
    def set_data(self,new_data):
        self.data = new_data#属性
    #设置节点
    def set_next(self,new_next):
        self.next = new_next#属性

#结点示例
temp = Node(93)
temp2 = Node(17)
temp3 = Node(77)
print(temp.get_data())
print(temp2.get_data())
print(temp3.get_data())


# 链表:1.有序表 2.无序表
#链表实现: 无序表 UnorderedList
#设立一个属性head , 保存对对第一个节点的引用
#空表的 head 为 None
class UnorderedList:
    def __init__(self):
        self.head = None
# mylist = UnorderedList()
# print (mylist.head)

    #为item数据项生成一个结点-Node 叫做item
    def add(self,item):
        #然后将这个结点命名为临时变量
        temp = Node(item)
        #将下一个临时结点设置为表头
        temp.set_next(self.head)
        #表头指向新增加的临时结点
        self.head = temp

    def size(self):
        #当前节点设为表头第一个节点
        current = self.head
        count = 0
        while current != None:
            count += 1
            #将当前节点设为下一个结点的结点,循环往复
            current = current.get_next()
                #返回结点的个数
        return count

    def search(self,item):
        current = self.head
        found = False
        while current != None and not found:
            #判断当前节点数据项是否等于我想要找的数据
            if current.get_data() == item:
                found = True
            else:
                current = current.get_next()
        return found

    def remove(self,item):#删除找到的元素--引用两个指针当前和上继指针
        current = self.head
        previous = None
        found = False
        #先判断是不是我要找的那个元素
        while not found:
            if current.get_data == item:
                found = True
            else:
                #通过current的指针给初始没有指针的previous指路
                previous = current
                #然后current指针继续往下走
                current = current.get_next

# 如果中间位置找不到,那我们再判断表头
#当前删除的车厢部位值item 位于头部时,可以利用 previous 指向空
        if previous == None:#当前想要删除的是不是车头处的元素
            self.head = current.get_next()
        else:
            previous.set_next(current.get_next())#删除的是中间元素

    def traverse(self):
        current = self.head
        while current != None:
            print(current.get_data())
            current = current.get_next()

#实例化无序表:
ll  = UnorderedList()

# 加入新节点
ll.add(7)
ll.add(9)
ll.add(6)
ll.add(8)
ll.add(10)

print(ll.search(1000))
ll.traverse()

b.有序链表的实现

python 复制代码

class Node:#结点Node相当于车厢
    def __init__(self,init_data):
        self.data = init_data
        self.next = None
    #获得数据项
    def get_data(self):
        return self.data
    #获得节点
    def get_next(self):
        return self.next
    #设置数据项
    def set_data(self,new_data):
        self.data = new_data#属性
    #设置节点
    def set_next(self,new_next):
        self.next = new_next#属性

class Orderedlist:
    def __init__(self):
        self.head = None

    def search(self,item):
        current = self.head
        found = False
        stop = False
        while current != None and not found and not stop:
            if current.get_data() == item:
                found = True
            else:
                if current.get_data()  > item:
                    stop = True
                else:
                    current = current.get_next()
        return found

    def add(self,item):
        current = self.head#指针1
        previous = None#p2
        stop = False
        while current != None and not stop:
            #发现插入位置
            if current.get_data() > item:
                stop = True
            else:
                previous = current
                current = current.get_next()

        temp = Node(item)
        #插在表头
        if previous == None:
            temp.set_next(self.head)
            self.head = temp
        #插在表中
        else:
            temp.set_next(current)
            previous.set_next(temp)

    def size(self):
        current = self.head
        count = 0
        while current != None:
            count += 1
            current = current.get_next()
        return count


    def remove(self, item):
        current = self.head
        previous = None
        found = False
        while not found and current != None:
            if current.get_data() == item:
                found = True
            else:
                previous = current
                current = current.get_next()
        if found:
            if previous == None:
                self.head = current.get_next()
            else:
                previous.set_next(current.get_next())

    def traverse(self):
        current = self.head
        while current != None:
            print(current.get_data())
            current = current.get_next()

ol = Orderedlist()
ol.add(7)
ol.add(9)
ol.add(6)
ol.add(8)
ol.add(10)
print(ol.search(6))
ol.traverse()

链接👉:http://t.csdnimg.cn/uTilE