python 常用数据结构

文章目录

• 顺序表
• 单向链表
• 双向链表
• 栈
• 队列
• 二叉树

顺序表

# 导入模块
from timeit import Timer


# 定义append_test
def append_test():
    li = []
    for i in range(10000):
        li.append(i)


def insert_test():
    li = []
    for i in range(10000):
        li.insert(0, i)


# 测试执行时间
append_timer = Timer('append_test()', 'from __main__ import append_test')
print('append插入执行时间：', append_timer.timeit(1000))

insert_timer = Timer('insert_test()', 'from __main__ import insert_test')
print('insert插入执行时间：', insert_timer.timeit(1000))

单向链表

class Node(object):
    def __init__(self, elem):
        # elem指数据元素
        self.elem = elem
        # 指向下一个节点的链接域
        self.next = None


# 构造单向链表类
class SingleLinkList:
    # 初始化方法
    def __init__(self, node=None):
        # 判断node是否为空
        if node != None:
            headNode = Node(node)
            self.__head = headNode
        else:
            self.__head = node  # 这个是 头部元素

    # 在头部添加元素
    def add(self, item):
        # 将传入的值构造成节点
        node = Node(item)
        # 将新节点的链接域next指向头节点
        node.next = self.__head
        # 将链表的头__head指向新节点
        self.__head = node

    # 在单向链表尾部追加元素
    def append(self, item):
        # 将传入的值构造成节点
        node = Node(item)
        if self.is_empty():  # 单链表为空时候
            self.__head = node
        else:  # 单链表不为空
            curNode = self.__head
            while curNode.next != None:
                curNode = curNode.next
            # 修改节点指向  最后一个节点的next指向node
            curNode.next = node

    # 在指定位置添加元素
    def insert(self, pos, item):
        # 如果传入的pos是小于等于0的数，默认的将节点插入头部
        if pos <= 0:
            self.add(item)
        # 如果pos的值大于链表长度，直接将节点添加到尾部
        elif pos > (self.length() - 1):
            self.append(item)
        else:
            # 构造节点
            node = Node(item)
            count = 0
            preNode = self.__head
            while count < (pos - 1):  # 找前一个节点
                count += 1
                preNode = preNode.next
            # 修改指向
            # 将前一个节点的next指向插入位置节点
            node.next = preNode.next
            # 将插入位置的前一个节点的next指向新节点
            preNode.next = node

    # 删除节点
    def remove(self, item):
        curNode = self.__head
        preNode = None
        while curNode != None:
            if curNode.elem == item:
                # 判断是否是头节点
                if preNode == None:  # 是头节点
                    self.__head = curNode.next
                else:
                    # 删除
                    preNode.next = curNode.next
                break
            else:
                preNode = curNode
                curNode = curNode.next

    # 查找节点是否存在
    def search(self, item):
        curNode = self.__head
        while curNode != None:
            if curNode.elem == item:
                return True
            curNode = curNode.next
        return False

    # 判断单向链表是否为空
    def is_empty(self):
        return self.__head == None

    # 计算单向链表的长度
    def length(self):
        count = 0
        curNode = self.__head
        while curNode != None:
            count += 1
            curNode = curNode.next
        return count

    def travel(self):
        curNode = self.__head
        while curNode != None:
            print(curNode.elem, end='	')
            curNode = curNode.next
        print("")


if __name__ == '__main__':
    # 初始化元素值为20的单向链表
    # singleLinkList=SingleLinkList(20)
    # 初始化一个空的单向链表
    singleLinkList = SingleLinkList()
    print('是否是空链表：', singleLinkList.is_empty())
    print('链表的长度：', singleLinkList.length())
    print('----------遍历单链表----------')
    singleLinkList.travel()
    print('--------查找---------')
    print(singleLinkList.search(20))
    print(singleLinkList.search(30))
    print('------头部插入-----------')
    singleLinkList.add(1)
    singleLinkList.add(2)
    singleLinkList.add(3)
    singleLinkList.travel()
    print('------尾部追加-----------')
    singleLinkList.append(10)
    singleLinkList.append(20)
    singleLinkList.append(30)
    singleLinkList.travel()
    print('链表的长度：', singleLinkList.length())
    print('----------指定位置插入----------')
    singleLinkList.insert(2, 100)
    singleLinkList.travel()
    singleLinkList.insert(-1, 200)
    singleLinkList.travel()
    singleLinkList.insert(100, 300)
    singleLinkList.travel()
    print('---------删除节点--------')
    singleLinkList.remove(100)
    singleLinkList.travel()
    singleLinkList.remove(200)
    singleLinkList.travel()
    singleLinkList.remove(300)
    singleLinkList.travel()

双向链表

# 双向链表的节点
class Node:
    def __init__(self, elem):
        self.elem = elem
        self.next = None  # 后继 下一个节点
        self.prev = None  # 前驱  前一个节点


class DoubleLinkList:
    # 初始化方法
    def __init__(self, node=None):
        # 判断node是否为空
        if node != None:
            headNode = Node(node)
            self.__head = headNode
        else:
            self.__head = node

    # 在头部添加元素
    def add(self, item):
        # 将传入的值构造成节点
        node = Node(item)
        # 判断是否是空链表
        if self.is_empty():
            self.__head = node
        else:
            # 将新节点的链接域next指向头节点
            node.next = self.__head
            # 将__head的头节点的prev指向node
            self.__head.prev = node
            # 将链表的头__head指向新节点
            self.__head = node

    # 在尾部追加元素
    def append(self, item):
        # 将传入的值构造成节点
        node = Node(item)
        if self.is_empty():  # 单链表为空时候
            self.__head = node
        else:  # 不为空
            curNode = self.__head
            while curNode.next != None:
                curNode = curNode.next
            # 修改节点指向  最后一个节点的next指向node
            curNode.next = node
            # 将node节点的前驱指向当前节点
            node.prev = curNode

    # 在指定位置添加元素
    def insert(self, pos, item):
        # 如果传入的pos是小于等于0的数，默认的将节点插入头部
        if pos <= 0:
            self.add(item)
        # 如果pos的值大于链表长度，直接将节点添加到尾部
        elif pos > (self.length() - 1):
            self.append(item)
        else:
            # 构造节点
            node = Node(item)
            count = 0
            curNode = self.__head
            while count < (pos - 1):  # 找前一个节点
                count += 1
                curNode = curNode.next
            # 修改指向
            # 将node节点的前驱指向当前节点
            node.prev = curNode
            # 将node节点的后继指向当前节点的下一个节点
            node.next = curNode.next
            # 将当前节点的下一个节点的前驱指向node节点
            curNode.next.prev = node
            # 将当前节点的后继指向node节点
            curNode.next = node

    # 删除节点
    def remove(self, item):
        curNode = self.__head
        while curNode != None:
            if curNode.elem == item:
                # 判断是否是头节点
                if curNode == self.__head:  # 是头节点
                    self.__head = curNode.next
                    # 判断当前节点是否只有一个节点，如果只有一个节点，则不需要移动下一个节点的前驱
                    if curNode.next:
                        curNode.next.prev = None
                else:
                    # 删除
                    curNode.prev.next = curNode.next
                    # 判断当前节点是否是最后一个节点，如果是最后一个节点，最后一个节点的下一个节点指向None
                    if curNode.next:
                        curNode.next.prev = curNode.prev
                break
            else:
                curNode = curNode.next

    # 查找节点是否存在
    def search(self, item):
        curNode = self.__head
        while curNode != None:
            if curNode.elem == item:
                return True
            curNode = curNode.next
        return False

    # 判断是否为空
    def is_empty(self):
        return self.__head == None

    # 计算链表的长度
    def length(self):
        count = 0
        curNode = self.__head
        while curNode != None:
            count += 1
            curNode = curNode.next
        return count

    # 遍历链表
    def travel(self):
        curNode = self.__head
        while curNode != None:
            print(curNode.elem, end='	')
            curNode = curNode.next
        print("")


if __name__ == '__main__':
    doubleLinkList = DoubleLinkList()
    doubleLinkList.add(11)
    doubleLinkList.add(22)
    doubleLinkList.add(33)
    doubleLinkList.travel()
    print('-----------追加-----------')
    doubleLinkList.append(100)
    doubleLinkList.append(200)
    doubleLinkList.append(300)
    doubleLinkList.travel()
    print('指定位置插入')
    doubleLinkList.insert(-1, 44)
    doubleLinkList.travel()
    doubleLinkList.insert(100, 400)
    doubleLinkList.travel()
    doubleLinkList.insert(2, 1000)
    doubleLinkList.travel()
    print('------删除节点--------')
    doubleLinkList.remove(44)
    doubleLinkList.travel()
    doubleLinkList.remove(1000)
    doubleLinkList.travel()
    doubleLinkList.remove(400)
    doubleLinkList.travel()
    print('链表的长度：', doubleLinkList.length())
    print('查找节点11', doubleLinkList.search(11))
    print('查找节点111', doubleLinkList.search(111))

栈

class Stack(object):
    # 定义初始化方法
    def __init__(self):
        # 初始化一个空列表
        self.__list = []

    # 压栈
    def push(self, item):
        self.__list.append(item)

    # 弹出元素
    def pop(self):
        return self.__list.pop()

    # 返回栈顶元素
    def peek(self):
        return self.__list[len(self.__list) - 1]

    # 判断栈是否为空
    def is_empty(self):
        return self.__list == []

    # 计算栈的大小
    def size(self):
        return len(self.__list)


if __name__ == '__main__':
    stack = Stack()
    print('是否空栈吗', stack.is_empty())
    # 压栈
    stack.push(1)
    stack.push(2)
    stack.push(3)
    stack.push(4)
    print('是否空栈吗', stack.is_empty())
    print('栈的长度：', stack.size())
    # 弹出
    print(stack.pop())
    print(stack.pop())
    print(stack.pop())
    print(stack.pop())

队列

class Queue:
    def __init__(self):
        self.__list = []

    # 进队
    def enqueue(self, item):
        # self.__list.append(item)
        self.__list.insert(0, item)

    # 出队
    def dequeue(self):
        # return self.__list.pop(0)
        return self.__list.pop()

    # 判断队列是否为空
    def is_empty(self):
        return self.__list == []

    # 计算队列的大小
    def size(self):
        return len(self.__list)


if __name__ == '__main__':
    queue = Queue()
    queue.enqueue(10)
    queue.enqueue(20)
    queue.enqueue(30)
    # 判断队列是否空
    print(queue.is_empty())
    print('队列大小', queue.size())
    print('-----出队---------')
    print(queue.dequeue())
    print(queue.dequeue())
    print(queue.dequeue())

二叉树

# 定义二叉树的节点
class Node:
    def __init__(self, elem):
        self.elem = elem
        self.lchild = None
        self.rchild = None


class Tree:
    def __init__(self):
        self.root = None

    # 添加节点
    def add(self, elem):
        # 创建节点
        node = Node(elem)
        if self.root == None:
            self.root = node
        else:
            queue = []
            queue.append(self.root)
            while queue:
                curNode = queue.pop(0)
                if curNode.lchild == None:
                    curNode.lchild = node
                    return
                else:
                    queue.append(curNode.lchild)

                if curNode.rchild == None:
                    curNode.rchild = node
                    return
                else:
                    queue.append(curNode.rchild)

    # 广度优先遍历
    def travel(self):
        queue = []
        # 判断根节点是否存在
        if self.root is None:
            return
        else:
            queue.append(self.root)
        while queue:
            curNode = queue.pop(0)
            print(curNode.elem, end='	')
            if curNode.lchild is not None:
                queue.append(curNode.lchild)
            if curNode.rchild is not None:
                queue.append(curNode.rchild)
        print()

    # 先序遍历  根  左  右 0 1 3 7 8 4 9 2 5 6
    def preOrder(self, root):
        if root is None:
            return
        else:
            print(root.elem, end='	')
            self.preOrder(root.lchild)
            self.preOrder(root.rchild)

    # 中序遍历 左  根  右  7 3 8 1 9 4  0 5 2 6
    def inOrder(self, root):
        if root is None:
            return
        else:
            self.inOrder(root.lchild)
            print(root.elem, end='	')
            self.inOrder(root.rchild)

    # 后序遍历  左  右  根 7 8 3 9 4 1 5 6 2 0
    def lastOrder(self, root):
        if root is None:
            return
        else:
            self.lastOrder(root.lchild)
            self.lastOrder(root.rchild)
            print(root.elem, end='	')


if __name__ == '__main__':
    tree = Tree()
    tree.add(0)
    tree.add(1)
    tree.add(2)
    tree.add(3)
    tree.add(4)
    tree.add(5)
    tree.add(6)
    tree.add(7)
    tree.add(8)
    tree.add(9)
    print('广度优先遍历')
    tree.travel()
    print('先序遍历')
    tree.preOrder(tree.root)
    print()
    print('中序遍历')
    tree.inOrder(tree.root)
    print()
    print('后序遍历')
    tree.lastOrder(tree.root)