数据结构与算法整理1

1.什么是数据结构

• 官方定于：无

• 民间定义：

  • “数据结构是数据对象 ，以及存在于该对象的实例和 组成实例的数据元素之间的各种联系。这些联系可以通过定义相关的函数来给出。” — 《数据结构、算法与应用》

  • “数据结构（data structure）是计算机中存储、组织数据的方式。通常情况下，精心选择的数据结构可以 带来最优效率的算法。” —中文维基百科

  • “数据结构是ADT（抽象数据类型 Abstract Data Type）的物理实现。” — 《数据结构与算法分析》

    什么是抽象数据ADT?

    实际上 python 内置的 list 就可以看成一种抽象数据类型。

    ADT: Abstract Data Type，抽象数据类型，我们在组合已有的数据结构来实现一种新的数据类型， ADT 定义了类型的数据和操作。

2.常见的数据结构

栈、队列、链表、集合、字典、树等

不同的数据结构的不同操作性能是不同的：

• 有的查询性能很快,有的插入速度很快,有的是插入头和尾速度很快
• 有的做范围查找很快,有的允许元素重复,有的不允许重复等等
• 在开发中如何选择,要根据具体的需求来选择

注：数据结构与语言无关

3.什么是算法

算法的定义:

• 一个有限指令集, 每条指令的描述不依赖于语言
• 接受一些输入（有些情况下不需要输入）
• 产生输出
• 一定在有限步骤之后终止

列表

字典

集合

数组

数组是最常用到的一种线性结构，python 内置了一个 array 模块，但是不常使用。

Python 的 array 是内存连续、存储的都是同一数据类型的结构，而且只能存数值和字符。

数组提供了高效的、固定类型的一维数组。相比于列表，array 对象节省了空间且在处理大量同类型数据时速度更快。

栈

栈（stack），它是一种运算受限的线性表,后进先出(LIFO)

• LIFO(last in first out)表示就是后进入的元素, 第一个弹出栈空间. 类似于自动餐托盘, 最后放上的托盘, 往往先把拿出去使用.
• 其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。
• 向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；
• 从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。

栈常见的操作

• push(element): 添加一个新元素到栈顶位置.
• pop()：移除栈顶的元素，同时返回被移除的元素。
• peek()：返回栈顶的元素，不对栈做任何修改（这个方法不会移除栈顶的元素，仅仅返回它）。
• isEmpty()：如果栈里没有任何元素就返回true，否则返回false。
• clear()：移除栈里的所有元素。
• size()：返回栈里的元素个数。这个方法和数组的length属性很类似。

class Stack:
    def __init__(self):
        self.item = []

    def push(self, element):
        self.item.append(element)

    def pop(self):
        return self.item.pop()

    def peek(self):
        return self.item[-1]

    def is_empty(self):
        return len(self.item) == 0

    def clear(self):
        self.item.clear()

    def size(self):
        return len(self.item)


s1 = Stack()
s1.push(1)
s1.push(123)
s1.push("abcd")
print(s1.size())
print(s1.peek())
print(s1.pop())
s1.clear()

队列

队列(Queue)，它是一种运算受限的线性表,先进先出(FIFO First In First Out)

• 队列是一种受限的线性结构
• 受限之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作

队列常见的操作

• enqueue(element)：向队列尾部添加一个（或多个）新的项。
• dequeue()：移除队列的第一（即排在队列最前面的）项，并返回被移除的元素。
• front()：返回当前队列中第一个元素，也将是最先被移除的元素。队列不做任何变动（不移除元素，只返回元素信息——与Stack类的peek方法非常类似）。
• isEmpty()：如果队列中不包含任何元素，返回true，否则返回false。
• size()：返回队列包含的元素个数，与数组的length属性类似.

1.普通队列

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

    def is_empty(self):
        return len(self.item) == 0
        
    def enqueue(self, element):
        self.item.append(element)

    def dequeue(self):
        if self.is_empty():
            return None
        return self.item.pop(0)

    def front(self):
        if self.is_empty():
            return None
        return self.item[0]

    def size(self):
        return len(self.item)


q1 = Queue()
q1.enqueue(123)
q1.enqueue("abc")
q1.enqueue(666)
print(q1.size())
print(q1.front())
print(q1.dequeue())
print(q1.size())

2.优先级队列

优先级队列的特点:

• 我们知道, 普通的队列插入一个元素, 数据会被放在后端. 并且需要前面所有的元素都处理完成后才会处理前面的数据.
• 但是优先级队列, 在插入一个元素的时候会考虑该数据的优先级.(和其他数据优先级进行比较)
• 比较完成后, 可以得出这个元素正确的队列中的位置. 其他处理方式, 和队列的处理方式一样.
• 也就是说, 如果我们要实现优先级队列, 最主要是要修改添加方法. (当然, 还需要以某种方式来保存元素的优先级)

实现优先级队列相对队列主要有两方面需要考虑:

• 1. 封装元素和优先级放在一起(可以封装一个新的类)
• 1. 添加元素时, 将当前的优先级和队列中已经存在的元素优先级进行比较, 以获得自己正确的位置.

class Pqueue:
    class Element:
        def __init__(self, el, rank):
            self.el = el
            self.rank = rank

    def __init__(self):
        self.item = []

    def is_empty(self):
        return len(self.item) == 0

    def enqueue(self, el, rank):
        en_element = self.Element(el, rank)

        if self.is_empty():
            self.item.append(en_element)
        else:
            flag = True
            for i in range(len(self.item)):
                if en_element.rank < self.item[i].rank:
                    self.item.insert(i, en_element)
                    flag = False
                    break
            if flag:
                self.item.append(en_element)

    def dequeue(self):
        if self.is_empty():
            return None
        return self.item.pop(0)

    def front(self):
        if self.is_empty():
            return None
        return self.item[0]

    def size(self):
        return len(self.item)


q1 = Pqueue()
q1.enqueue(123, 2)
q1.enqueue("abc", 1)
q1.enqueue(666, 3)
q1.enqueue(987, 4)
print(q1.size())
print(q1.front().el)
print(q1.dequeue().el)

链表

链表是链式的存储多个元素.

• 但不同于列表, 链表中的元素在内存中不必是连续的空间
• 链表的每个元素由一个存储元素本身的节点和一个指向下一个元素的引用(有些语言称为指针或者链接)组成
• 链表访问任何一个位置的元素时, 都需要从头开始访问.(无法跳过第一个元素访问任何一个元素)

链表常见的操作

• append(element)：向列表尾部添加一个新的项

• insert(position, element)：向列表的特定位置插入一个新的项。

• remove(element)：从列表中移除一项。

• indexOf(element)：返回元素在链表中的索引。如果列表中没有该元素则返回-1。

• removeAt(position)：从列表的特定位置移除一项。

• isEmpty()：如果链表中不包含任何元素，返回true，如果链表长度大于0则返回false。

• size()：返回链表包含的元素个数。与数组的length属性类似。

1.单链表

class Node:
    def __init__(self, el):
        self.el = el
        self.next = None


class Linklist:
    def __init__(self):
        self.head = None
        self.length = 0

    def is_empty(self):
        return self.length == 0

    def append(self, element):
        node = Node(element)
        if self.is_empty():
            self.head = node
        else:
            node_next = self.head
            while node_next.next is not None:
                node_next = node_next.next
            node_next.next = node
        self.length += 1

    def index_of(self, element):
        node_next = self.head
        for i in range(self.length):
            if node_next.el == element:
                return i
            node_next = node_next.next
        print("未找到该元素！")

    def insert(self, position, element):
        if position < 0 or position > self.length:
            return False
        node = Node(element)
        node_next = self.head
        previous = None
        if position == 0:
            node.next = node_next
            self.head = node
        else:
            for i in range(position + 1):
                previous = node_next
                node_next = node_next.next
            previous.next = node
            node.next = node_next
        self.length += 1
        return True

    def remove_at(self, position):
        if position < 0 or position > self.length:
            return False
        node_next = self.head
        previous = None
        if position == 0:
            self.head = node_next.next
        else:
            for i in range(position):
                previous = node_next
                node_next = node_next.next
            previous.next = node_next.next
        self.length -= 1
        return node_next.el

    def remove(self, el):
        index = self.index_of(el)
        return self.remove_at(index)

    def size(self):
        return self.length


list1 = Linklist()
for i in range(6):
    list1.append(i)
print(list1.index_of("hello"))
print(list1.index_of(4))
print(list1.remove(4))
print(list1.size())