苏州程序大白用2万字解析数据结构和八大排序算法☀️《❤️记得收藏❤️》
Posted 苏州程序大白
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了苏州程序大白用2万字解析数据结构和八大排序算法☀️《❤️记得收藏❤️》相关的知识，希望对你有一定的参考价值。
【苏州程序大白用2万字】解析数据结构和八大排序算法☀️《❤️记得收藏❤️》
-
🏳️🌈开讲啦！！！！🏳️🌈苏州程序大白🏳️🌈 - 🍇1、算法的时间复杂度
- 🍈2、栈
- 🍓3、队列
- 🍒4、链表和顺序表
- 🍭5、顺序查找
- 🍊6、二叉树
- 🍉7、八大排序算法实现与讲解
- 🌟8、作者相关的文章、资源分享🌟
- 🏳️🌈关注苏州程序大白，持续更新技术分享。谢谢大家支持🏳️🌈
| 🏳️🌈开讲啦！！！！🏳️🌈苏州程序大白🏳️🌈 |
🍇1、算法的时间复杂度
🍇1.2、评判程序优劣的方法
-
消耗计算机资源和执行效率
-
计算算法执行的耗时
-
时间复杂度（推荐）
🍇1.3、时间复杂度
-
评判标准：量化算法执行的操作/执行步骤的数量
-
最重要的项：时间复杂度表达式最有意义的项
-
大O记法对时间复杂度进行表示：O(量化表达式中最有意义的项)
def sumofN(n):
theSum = 0
for i in range(1, n+1):
theSum = thSum + i
return theSum
print(sumofN(10))
# 1 + n + 1 =====> n + 2 =====> O(n)
a = 5
b = 6
c = 10
for i in range(n):
for j in range(n):
x = i * i
y = j * j
z = i * j
for k in range(n):
w = a * k + 45
v = b * b
d = 33
# 3 + 3n**2 + 2n + 1 ====> 3n**2 + 2n ====> 3n**2 ====> n**2 ====> O(n**2)
🍇1.4、常见的时间复杂度
O(1) < O(logn) < O(n) < O(nlogn) < O(n^2) < O(n^3) < O(2^n) < O(n!) < O(n^n)
🍈2、栈
-
特性：先进先出
-
应用：每个 web 浏览器都有一个返回按钮。当你浏览网页时，这些网页被放置在一个栈中（实际是网页的网址）。你现在查看的网页在顶部，你第一个查看的网页在底部。如果按‘返回’按钮，将按相反的顺序浏览刚才的页面。
🍈2.1、用python实现一个简单的栈
需要实现的方法
- Stack() //创建一个空的新栈。 它不需要参数，并返回一个空栈。
- push(item) //将一个新项添加到栈的顶部。它需要 item 做参数并不返回任何内容。
- pop() //从栈中删除顶部项。它不需要参数并返回 item 。栈被修改。
- peek() //从栈返回顶部项，但不会删除它。不需要参数。 不修改栈。
- isEmpty() //测试栈是否为空。不需要参数，并返回布尔值。
- size() //返回栈中的 item 数量。不需要参数，并返回一个整数。
class Stark():
def __init__(self):
self.items = []
def push(self, item):
self.items.append(item)
def pop(self):
return self.items.pop()
def peek(self):
return len(self.items) - 1
def isEmpty(self):
return self,items == []
def size(self):
return len(self.items)
🍓3、队列
-
特性：先进先出
-
应用场景：
我们的计算机实验室有 30 台计算机与一台打印机联网。当学生想要打印时，他们的打印任务与正在等待的所有其他打印任务“一致”。第一个进入的任务是先完成。如果你是最后一个，你必须等待你前面的所有其他任务打印。
🍓3.1、实现一个简单的队列
- Queue() //创建一个空的新队列。 它不需要参数，并返回一个空队列。
- enqueue(item) //将新项添加到队尾。 它需要 item 作为参数，并不返回任何内容。
- dequeue() //从队首移除项。它不需要参数并返回 item。 队列被修改。
- isEmpty() //查看队列是否为空。它不需要参数，并返回布尔值。
- size() //返回队列中的项数。它不需要参数，并返回一个整数。
class Queue():
def __init__(self):
self.items = []
def enqueue(self, item):
self.items.insert(0, item)
def dequeue(self):
return self.items.pop()
def isEmpty(self):
return self.items == []
def size(self):
return len(self.items)
🍓3.2、应用（烫手的山芋）
//案例：烫手的山芋
// 烫手山芋游戏介绍：6个孩子围城一个圈，排列顺序孩子们自己指定。第一个孩子手里有一个烫手的山芋，需要在计时器计时1秒后将山芋传递给下一个孩子，依次类推。规则是，在计时器每计时7秒时，手里有山芋的孩子退出游戏。该游戏直到剩下一个孩子时结束，最后剩下的孩子获胜。请使用队列实现该游戏策略，排在第几个位置最终会获胜。
// 准则：队头孩子的手里永远要有山芋。
queue = Queue()
kids = ['A','B','C','D','E','F']
for kid in kids:
queue.enqueue(kid)
while queue.size() > 1:
for i in range(6):
kid = queue.dequeue()
queue.enqueue(kid)
queue.dequeue()
print('获胜者为：', queue.dequeue())
🍓3.3、双端队列
同队列相比，有两个头部和尾部。可以在双端进行数据的插入和删除，提供了单数据结构中栈和队列的特性
- Deque() //创建一个空的新 deque。它不需要参数，并返回空的 deque。
- addFront(item) //将一个新项添加到 deque 的首部。它需要 item 参数 并不返回任何内容。
- addRear(item) //将一个新项添加到 deque 的尾部。它需要 item 参数并不返回任何内容。
- removeFront() //从 deque 中删除首项。它不需要参数并返回 item。deque 被修改。
- removeRear() //从 deque 中删除尾项。它不需要参数并返回 item。deque 被修改。
- isEmpty() //测试 deque 是否为空。它不需要参数，并返回布尔值。
- size() //返回 deque 中的项数。它不需要参数，并返回一个整数。
class Dequeue():
def __init__(self):
self.items = []
def isEmpty(self):
return self.items == []
def size(self):
return len(self.items)
def addFront(self, item):
self.items.append(item)
def addRear(self, item):
self.items.insert(0, item)
def removeFront(self):
return self.items.pop()
def removeRear(self):
return self.items.pop(0)
案例：回文检查
回文是一个字符串，读取首尾相同的字符，例如，radar toot madam
def isHuiWen(s):
ex = True
q = Dequeue()
for ch in s:
q.addFront(ch)
for i in range(len(s)//2):
font = q.removeFront()
rear = q.removeRear()
if font != rear:
ex = False
break
return ex
print(isHuiWen('addan'))
🍒4、链表和顺序表
🍒4.1、顺序表
-
集合中存储的元素是有顺序的，顺序表的结构可以分为两种形式：单数据类型和多数据类型。
-
python中的列表和元组就属于多数据类型的顺序表。
-
顺序表的弊端：顺序表的结构需要预先知道数据大小来申请连续的存储空间，而在进行扩充时又需要进行数据的搬迁。
🍒4.2、链表
-
相对于顺序表，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理且进行扩充时不需要进行数据搬迁。
-
链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是不像顺序表一样连续存储数据，而是每一个结点（数据存储单元）里存放下一个结点的信息（即地址）。
🍒4.3、构造链表
is_empty()：//链表是否为空
length()：//链表长度
travel()：//遍历整个链表
add(item)：//链表头部添加元素
append(item)：//链表尾部添加元素
insert(pos, item)：//指定位置添加元素
remove(item)：//删除节点
search(item)：//查找节点是否存在
节点
class Node():
def __init__(self,item):
self.item = item
self.next = None
链表
class Link():
# 构建一个空链表
def __init__(self):
self._head = None // 永远指向链表中的头节点
# 向链表的头部插入节点
def add(self, item):
node = Node(item)
node.next = self._head
self._head = node
def travel(self):
cur = self._head
# 链表为空则输出“链表为空”
if self._head = None:
print("链表为空")
while cur:
print(cur.item)
cur = cur.next
def isEmpty(self):
return self._head == None
def length(self):
cur = self._head
count = 0
while cur:
count += 1
cur = cur.next
return count
def search(self, item):
cur = self._head
find = False
while cur:
if cur.item == item:
find = True
break
cur = cur.next
return find
def append(self, item):
node = Node(item)
if self._head == None:
self._head = node
return
cur = self._head
pre = None
while cur:
pre = cur
cur = cur.next
pre.next = node
def insert(self, pos, item):
node = Node(item)
if pos < 0 or pos > self.length():
print("重新给pos赋值")
cur = self._head
pre = None
for i in range(pos):
pre = cur
cur = cur.next
pre.next = node
node.next = cur
def remove(self, item):
cur = self._head
pre = None
if self._head == None:
print("链表为空，没有可删除的节点")
return
# 删除的是第一个节点的情况
if self._head.item == item:
self._head = self._head.next
return
# 删除的不是第一个节点的情况
while cur:
pre = cur
cur = cur.next
if cur.item == item:
pre.next = cur.next
return
🍭5、顺序查找
- 当数据存储在诸如列表的集合中时，我们说这些数据具有线性或顺序关系。 每个数据元素都存储在相对于其他数据元素的位置。 由于这些索引值是有序的，我们可以按顺序访问它们。 这个过程产实现的搜索即为顺序查找。
顺序查找原理剖析：
-
从列表中的第一个元素开始，我们按照基本的顺序排序，简单地从一个元素移动到另一个元素，直到找到我们正在寻找的元素或遍历完整个列表。如果我们遍历完整个列表，则说明正在搜索的元素不存在。
-
代码实现：该函数需要一个列表和我们正在寻找的元素作为参数，并返回一个是否存在的布尔值。found 布尔变量初始化为 False，如果我们发现列表中的元素，则赋值为 True。
-
有序列表：之前我们列表中的元素是随机放置的，因此在元素之间没有相对顺序。如果元素以某种方式排序，顺序查找会发生什么？我们能够在搜索技术中取得更好的效率吗？
二分查找：一定是只可以被应用在有序列表中
- 有序列表对于我们的实现搜索是很有用的。在顺序查找中，当我们与第一个元素进行比较时，如果第一个元素不是我们要查找的，则最多还有 n-1 个元素需要进行比较。 二分查找则是从中间元素开始，而不是按顺序查找列表。 如果该元素是我们正在寻找的元素，我们就完成了查找。 如果它不是，我们可以使用列表的有序性质来消除剩余元素的一半。如果我们正在查找的元素大于中间元素，就可以消除中间元素以及比中间元素小的一半元素。如果该元素在列表中，肯定在大的那半部分。然后我们可以用大的半部分重复该过程，继续从中间元素开始，将其与我们正在寻找的内容进行比较。
🍭5.1、二分查找实现
def sort(alist, item): // item就是我们要找的元素
low = 0 //进行二分查找操作的列表中的第一个元素的下标
high = len(alist)
find = False
while low <= high:
mid = (low+high) // 2 # 中间元素的下标
if item > alist[mid]: // 我们要找的数比中间的数大，则意味着我们要找的数在中间元素的右侧
low = mid + 1
elif item < alist[mid]: // 我们要找的数比中间的数小，则我们要找的数在中间数的左侧
high = mid - 1
else:
find = True
break
return find
- test
alist = [1,2,3,4,5,6,7]
print(sort(alist, 51))
output: False
🍊6、二叉树
-
根节点
-
左叶子节点
-
右叶子节点
-
子树
-
高度
🍊6.1、二叉树的遍历
-
广度遍历：逐层遍历
-
深度遍历
-
前序：根左右
-
中序：左根右
-
后序：左右根
🍊6.2、构造普通二叉树
class Node():
def __init__(self, item):
self.item = item
self.left = None
self.right = None
class Tree():
# 构造出一颗空的二叉树
def __init__(self, item): // root指向第一个节点的地址，如果root指向了None，则意味着该二叉树为空
self.root = None
# 向二叉树中插入节点
def addNode(self, item):
node = Node(item)
if self.root == None:
# addNode如果第一次被调用则意味着：向空树中插入第一个节点，该节点一定是该树的根节点
self.root = node
return
# 如果上面的if不执行则树为非空，下面就执行向一个非空的树中插入节点的操作
cur = self.root
queue = [cur]
while queue:
n = queue.pop(0)
if n.left != None:
queue.append(n.left)
else:
n.left = node
break
if n.right != None:
queue.append(n.right)
else:
n.right = node
break
def travel(self):
# 如果为空
if self.root == None:
print("树为空！")
return
cur = self.root
queue = [cur]
while queue:
n = queue.pop(0)
print(n.item)
if n.left != None:
queue.append(n.left)
if n.right != None:
queue.append(n.right)
# 前序遍历
def forward(self, root):
if root == None:
return
print(root.item)
self.forward(root.left)
self.forward(root.right)
# 中序遍历
def middle(self, root):
if root == None:
return
self.middle(root.left)
print(root.item)
self.middle(root.right)
# 后序遍历
def back(self, root):
if root == None:
return
self.back(root.left)
self.back(root.right)
print(root.item)
🍊6.3、构造排序二叉树
class Node():
def __init__(self, item):
self.item = item
self.left = None
self.right = None
class SortTree():
def __init__(self):
self.root = None
def insertNode(self, item):
node = Node(item)
# 向空树插入第一个节点
if self.root == None:
self.root = node
return
# 树为非空的情况
cur = self.root
while True:
if node.item > cur.item: // 往右插
if cur.right == None:
cur.right = node
break
以上是关于苏州程序大白用2万字解析数据结构和八大排序算法☀️《❤️记得收藏❤️》的主要内容，如果未能解决你的问题，请参考以下文章
☀️苏州程序大白一文解析Java多线程☀️《❤️记得收藏❤️》
☀️苏州程序大白解析Linux 中的虚拟网络接口☀️《❤️记得收藏❤️》
☀️苏州程序大白解析Linux 中的虚拟网络接口☀️《❤️记得收藏❤️》
☀️苏州程序大白一文让你学会Java Servlet基础☀️《❤️记得收藏❤️》