Python学习:常用数据结构

一、数组(array)

• 线性表数据结构,用一组连续的内存空间,来存储一组具有相同类型的数据
• 支持随机访问,根据下标随机访问的时间复杂度为O(1)

class array:
    def __init__(self, capacity: int):
        self._data = []
        self._capacity = capacity

    def __getitem__(self, position: int) -> object:
        return self._data[position]

    def __setitem__(self, index: int, value: object):
        self._data[index] = value

    def __len__(self):
        return len(self._data)

    def __iter__(self):
        for item in self._data:
            yield item

    def find(self,index: int):
        try:
            return self._data[index]
        except IndexError:
            return None

    def delete(self,index: int):
        try:
            self._data.pop(index)
            return True
        except IndexError:
            return None

    def insert(self,index: int,value: int):
        if len(self._data) >= self._capacity:
            return False
        else:
            return self._data.insert(index,value)

    def printall(self):
        for item in self:
            print(item)

if __name__ == "__main__":
    testarray = array(20)
    for i in range(10):
        testarray.insert(i,i)
    print(len(testarray))
    for i in range(3):
        testarray.delete(i)
    print(len(testarray))
    testarray.printall()

二、双向链表(linkedlist)

from typing import Optional

class Node:
    def __init__(self,data: object,left = None,right = None):
        self._data = data
        self._left = left
        self._right = right

class LinkedList:
    size = 0
    def __init__(self):
        self._head: Node = None
        self._tail: Node = None

    def insert(self,value:object):
        newnode = Node(value,self._tail)
        if not self._head:
            self._head = newnode

        if self._tail:
            self._tail._right = newnode

        self._tail = newnode
        self.size += 1

    def get(self,index: int):
        try:
            current = self._head
            for i in range(index):
               current = current._right
            return current._data
        except IndexError:
            return None

    def remove(self,index: int):
        try:
            current = self._head
            for i in range(index):
                current = current._right
            if current._right is not None:
                current._left._right = current._right
                current._right._left = current._left
            else:
                current._left._right = None
            self.size -= 1
        except IndexError:
            None

    def printall(self):
        current = self._head
        values = []
        while current:
            values.append(current._data)
            current = current._right
        for value in values:
            print(value)

if __name__ == "__main__":
    testlist = LinkedList()
    testlist.insert(1)
    testlist.insert(5)
    testlist.insert(6)
    testlist.printall()
    testlist.remove(2)
    testlist.printall()
    print(testlist.get(1))

三、栈(stack)

from typing import Optional

"""
    栈:先进后出,后进先出
"""
class Node:

    def __init__(self,data: int,next = None):
        self._data = data
        self._next = next

class stack:
    def __init__(self):
        self._top:Node = None

    def push(self,value:int):
        newnode = Node(value)
        newnode._next = self._top
        self._top = newnode

    def pop(self) -> Optional[int]:
        if self._top:
            value = self._top._data
            self._top = self._top._next
            return value

    def __repr__(self) -> str:
        current = self._top
        nums = []
        while current:
            nums.append(current._data)
            current = current._next
        return " ".join(f"{num}" for num in nums)


if __name__ == "__main__":
    teststack = stack()
    for i in range(9):
        teststack.push(i)
    print(teststack)
    for _ in range(3):
        teststack.pop()
    print(teststack)

四、队列(queue)

"""
    队列:先进先出,后进后出
"""
from typing import Optional


class Node:
    def __init__(self, data: str, next =None):
        self._data = data
        self._next = next

class queue:
    def __init__(self):
        self._head: Node = None
        self._tail: Node = None

    def enqueue(self,value: str):
        newnode = Node(value)
        if self._tail:
            self._tail._next = newnode
        else:
            self._head = newnode
        self._tail = newnode

    def dequeue(self) -> Optional[str]:
        if self._head:
            value = self._head
            self._head = self._head._next
            if not self._head:
                self._tail = None
            return value

    def __repr__(self):
        values = []
        current = self._head
        while current:
            values.append(current._data)
            current = current._next
        return "->".join(value for value in values)

if __name__ == "__main__":
    testqueue = queue()
    for i in range(10):
        testqueue.enqueue(str(i))
    print(testqueue)
    for i in range(3):
        testqueue.dequeue()
    print(testqueue)

五、树(tire)

class Node:
    def __init__(self,data: str):
        self._data = data
        self._children = [None] * 26
        self._isEnding = False

class tire:
    def __init__(self):
        self._head = Node('/')

    def insert(self,data: str):
        p = self._head
        for i in range(len(data)):
            index = ord(data[i]) - ord('a')
            if not p._children[index]:
                newnode = Node(data[i])
                p._children[index] = newnode
            p = p._children[index]
        p._isEnding = True

    def find(self,data: str):
        p = self._head
        for i in range(len(data)):
            index = ord(data[i]) - ord('a')
            if not p._children[index]:
                return False
            p = p._children[index]
        return p._isEnding

if __name__ == "__main__":
    strs = ["how", "hi", "her", "hello", "so", "see"]
    tire = tire()
    for s in strs:
        tire.insert(s)
    print(tire.find('how'))
    print(tire.find('he'))

六、树(BinarySearch)

class Node:
    def __init__(self,data,left = None,right = None):
        self._data = data
        self._left = left
        self._right = right
        
class SearchTree:
    def __init__(self):
        self._head = None
        
    def find(self,data):
        p = self._head
        while p and p._data != data:
            p = p._left if p._data > data else p._right
        return p

    def insert(self,data):
        newnode = Node(data)
        if self._head is None:
            self._head = newnode
            return
        p = self._head
        while p:
            if p._data > data:
                if p._left is None:
                    p._left = newnode
                    return
                p = p._left
            else:
                if p._right is None:
                    p._right = newnode
                    return
                p = p._right

	def delete(self,data):
		#待删除节点有两个节点
		#待删除节点只有一个节点
		
    def printall(self):
        self.inprint(self._head)

	#中序遍历	
    def inprint(self,p):
        if p:
            self.inprint(p._left)
            print(p._data)
            self.inprint(p._right)


if __name__ == '__main__':
    tree = SearchTree()
    tree.insert(4)
    tree.insert(8)
    tree.insert(12)
    tree.insert(1)
    tree.insert(3)
    tree.insert(7)
    tree.printall()

七、Python中的可变与不可变类型

所谓可变类型与不可变类型是指:数据能够直接进行修改,如果能直接修改那么就是可变,否则就是不可变
可变类型

• 列表
• 字典
• 集合

不可变类型

• 整型
• 浮点型
• 字符串
• 元组

在python中:

• 变量的赋值,只是表示让变量指向了某个对象,并不表示拷贝对象给变量;而一个对象,可以被多个变量所指向
• 可变对象(列表、字典、集合等)的改变,会影响所有指向该对象的变量
• 对于不可变对象(字符串、整型、元组等),所有指向该对象的变量的值总是一样的,也不会改变,但是可以通过某些操作(+=)更新不可变对象的值时,会返回一个新的对象
• 变量可以被删除,但是对象无法被删除