数据结构之栈（python）

news2024/11/15 17:35:27

栈（顺序栈与链栈）

  • 1.栈存储结构
    • 1.1栈的基本介绍
    • 1.2进栈和出栈
    • 1.3栈的具体实现
    • 1.4栈的应用
      • 例一
      • 例二
      • 例三
  • 2.顺序栈及基本操作（包含入栈和出栈）
    • 2.1顺序栈的基础介绍
    • 2.2顺序栈元素`入栈`
    • 2.3顺序栈元素`出栈`
    • 2.4顺序栈的表示和实现
  • 3.链栈及基本操作（包含入栈和出栈）
    • 3.1链栈的基本介绍
    • 3.2链栈元素入栈
    • 3.3链栈元素出栈
    • 3.4链栈的表示和实现
  • 4.栈的应用
    • 4.1括号匹配问题
    • 4.2十进制转二进制
    • 4.3十进制转N进制

1.栈存储结构

  • 栈和队列，严格意义上来说，也属于线性表，因为它们也都用于存储逻辑关系为 一对一 的数据。使用栈结构存储数据，讲究“先进后出”，即最先进栈的数据，最后出栈；
  • 使用队列存储数据，讲究 “先进先出”，即最先进队列的数据，也最先出队列。既然栈和队列都属于线性表，根据线性表分为顺序表和链表的特点，栈也可分为顺序栈和链栈，队列也分为顺序队列和链队列

1.1栈的基本介绍

同顺序表和链表一样，栈也是用来存储逻辑关系为 “一对一” 数据的线性存储结构，如图1所示：

在这里插入图片描述

  • 栈只能从表的一端存取数据，另一端是封闭的
  • 在栈中，无论是存数据还是取数据，都必须遵循"先进后出"的原则，即最先进栈的元素最后出栈。
  • 拿图1的栈来说，从图中数据的存储状态可判断出，元素 1 是最先进的栈。因此，当需要从栈中取出元素 1 时，根据"先进后出"的原则，需提前将元素 3 和元素 2 从栈中取出，然后才能成功取出元素 1
  • 我们可以给栈下一个定义，即栈是一种只能从表的一端存取数据且遵循 “先进后出” 原则的线性存储结构
  • 通常，栈的开口端被称为栈顶；相应地，封口端被称为栈底。因此，栈顶元素指的就是距离栈顶最近的元素，拿图2 来说，栈顶元素为元素 4；同理，栈底元素指的是位于栈最底部的元素，图2 中的栈底元素为元素 1

在这里插入图片描述

1.2进栈和出栈

  • 向栈中添加元素，此过程被称为"进栈"（入栈或压栈）
  • 从栈中提取出指定元素，此过程被称为"出栈"（或弹栈）

1.3栈的具体实现

  • 顺序栈：采用顺序存储结构可以模拟栈存储数据的特点，从而实现栈存储结构
  • 链栈：采用链式存储结构实现栈结构

两种实现方式的区别，仅限于数据元素在实际物理空间上存放的相对位置，顺序栈底层采用的是数组，链栈底层采用的是链表

1.4栈的应用

例一

我们经常使用浏览器在各种网站上查找信息。假设先浏览的页面 A，然后关闭了页面 A 跳转到页面 B，随后又关闭页面 B 跳转到了页面 C。而此时，我们如果想重新回到页面 A，有两个选择：

  • 重新搜索找到页面 A；
  • 使用浏览器的"回退"功能。浏览器会先回退到页面 B，而后再回退到页面 A。

浏览器 “回退” 功能的实现，底层使用的就是栈存储结构。当你关闭页面 A 时，浏览器会将页面 A入栈；同样，当你关闭页面 B 时，浏览器也会将 B入栈。因此，当你执行回退操作时，才会首先看到的是页面 B，然后是页面 A，这是栈中数据依次出栈的效果。

例二

不仅如此，栈存储结构还可以帮我们检测代码中的括号匹配问题。多数编程语言都会用到括号（小括号、中括号和大括号），括号的错误使用（通常是丢右括号）会导致程序编译错误，而很多开发工具中都有检测代码是否有编辑错误的功能，其中就包含检测代码中的括号匹配问题，此功能的底层实现使用的就是栈结构。

例三

同时，栈结构还可以实现数值的进制转换功能。例如，编写程序实现从十进制数自动转换成二进制数，就可以使用栈存储结构来实现。

2.顺序栈及基本操作（包含入栈和出栈）

2.1顺序栈的基础介绍

如果你仔细观察顺序表（底层实现是数组）和栈结构就会发现，它们存储数据的方式高度相似，只不过栈对数据的存取过程有特殊的限制，而顺序表没有。

在这里插入图片描述
这里给出使用顺序表模拟栈存储结构常用的实现思路，即在顺序表中设定一个实时指向栈顶元素的变量（一般命名为 top），top 初始值为 -1，表示栈中没有存储任何数据元素，及栈是"空栈"。一旦有数据元素进栈，则 top 就做 +1 操作；反之，如果数据元素出栈，top 就做 -1 操作。

2.2顺序栈元素入栈

模拟栈存储 {1,2,3,4} 的过程。最初，栈是"空栈"，即数组是空的，top 值为初始值 -1，如图 3 所示：

在这里插入图片描述
首先向栈中添加元素 1，我们默认数组下标为 0 一端表示栈底，因此，元素 1 被存储在数组 a[1] 处，同时 top 值 +1，如图 4 所示：

在这里插入图片描述
采用以上的方式，依次存储元素 2、3 和 4，最终，top 值变为 3，如图 5 所示：

在这里插入图片描述

2.3顺序栈元素出栈

其实，top 变量的设置对模拟数据的 “入栈” 操作没有实际的帮助，它是为实现数据的 “出栈” 操作做准备的。

在这里插入图片描述
注意，图 6 数组中元素的消失仅是为了方便初学者学习，其实，这里只需要对 top 值做 -1 操作即可，因为 top 值本身就表示栈的栈顶位置，因此 top - 1 就等同于栈顶元素出栈。并且后期向栈中添加元素时，新元素会存储在类似元素 4 这样的旧元素位置上，将旧元素覆盖。

2.4顺序栈的表示和实现

实现的基本功能：

  • 初始化空栈
  • 判断栈是否为空
  • 返回栈顶元素
  • 返回栈的长度
  • 进栈
  • 出栈
  • 清空栈

代码实现

class sqStack:
    # 初始化栈
    def __init__(self, MAXSIZE):
        self.MAXSIZE = MAXSIZE
        self.data = [None] * self.MAXSIZE
        self.top = -1


    # 判断当前栈是否为空
    def is_empty(self):
        return self.top == -1

    # 返回栈顶元素
    def gettop(self):
        if self.is_empty():
            print("当前顺序栈为空")
            return None
        else:
            return self.data[self.top]



    # 入栈
    def Push(self,item):
        # 判断栈是否满
        if self.top == self.MAXSIZE - 1:
            return "sqStack is full"
        self.data[self.top + 1] = item
        self.top += 1


    # 列表入栈
    def ListPush(self,lst):
        # 判断栈是否满
        if self.top == self.MAXSIZE - 1:
            return "sqStack is full"
        for i in range(len(lst)):
            self.Push(lst[i])


    # 出栈
    def Pop(self):
        # 判断栈是否为空
        if self.is_empty():
            return "sqStack is empty"
        rs = self.data[self.top]
        self.top -= 1
        return rs

    # 计算栈的长度
    def size(self):
        return self.top + 1



    # 输出栈内元素
    def display(self):
        # 判断栈是否为空
        if self.is_empty():
            print("当前顺序栈为空", end=" ")
        else:
            print("当前链表元素为：", end="")
        for i in range(self.top + 1):
            print(self.data[i], end=" ")
        print()


    # 清空栈
    def clear(self):
        self.data = [None] * self.MAXSIZE
        self.top = -1



# 初始化一个长度为20的顺序栈
s = sqStack(20)
print("初始化：", s)
print("----------------------")

# 判断当前栈是否为空
print("当前栈是否为空：", s.is_empty())
print("----------------------")

# 输出栈的元素
s.display()
print("----------------------")
print("入栈前栈内元素：",end="")
s.display()

# 入栈
s.Push(1)
s.Push(10)
s.Push(100)

# 输出当前栈内的元素
print("入栈后栈内元素：", end="")
s.display()
print("----------------------")
print("当前栈的长度为：", s.size())
print("----------------------")
print("队列入栈前栈内元素：", end="")
s.display()
s.ListPush([1,2,3,4])
print("队列入栈后栈内元素：", end="")
s.display()
print("----------------------")
print("当前栈顶元素为：",s.gettop())
print("----------------------")

# 顶端元素出栈
print("出栈前栈内元素：",end="")
s.display()
print("出栈元素为：", s.Pop())
print("出栈后栈内元素：", end="")
s.display()
print("----------------------")

#输出当前栈内的元素
s.display()
print("----------------------")
s.clear()
s.display()
print("----------------------")

初始化： <__main__.sqStack object at 0x000002A011B38460>
----------------------
当前栈是否为空： True
----------------------
当前顺序栈为空 
----------------------
入栈前栈内元素：当前顺序栈为空 
入栈后栈内元素：当前链表元素为：1 10 100 
----------------------
当前栈的长度为： 3
----------------------
队列入栈前栈内元素：当前链表元素为：1 10 100 
队列入栈后栈内元素：当前链表元素为：1 10 100 1 2 3 4 
----------------------
当前栈顶元素为： 4
----------------------
出栈前栈内元素：当前链表元素为：1 10 100 1 2 3 4 
出栈元素为： 4
出栈后栈内元素：当前链表元素为：1 10 100 1 2 3 
----------------------
当前链表元素为：1 10 100 1 2 3 
----------------------
当前顺序栈为空 
----------------------

3.链栈及基本操作（包含入栈和出栈）

3.1链栈的基本介绍

通常我们将链表的头部作为栈顶，尾部作为栈底

在这里插入图片描述
将链表头部作为栈顶的一端，可以避免在实现数据 “入栈” 和 “出栈” 操作时做大量遍历链表的耗时操作。

  • 链表的头部作为栈顶，意味着：
    • 在实现数据"入栈"操作时，需要将数据从链表的头部插入
    • 在实现数据"出栈"操作时，需要删除链表头部的首元节点

因此，链栈实际上就是一个只能采用头插法插入或删除数据的链表。

3.2链栈元素入栈

例如，将元素 1、2、3、4 依次入栈，等价于将各元素采用头插法依次添加到链表中，每个数据元素的添加过程如图 2 所示：

在这里插入图片描述

3.3链栈元素出栈

例如，图2 所示的链栈中，若要将元素 3 出栈，根据"先进后出"的原则，要先将元素 4 出栈，也就是从链表中摘除，然后元素 3 才能出栈，整个操作过程如图 3 所示：

在这里插入图片描述

3.4链栈的表示和实现

实现基本功能：

  • 初始化空栈
  • 判断栈是否为空
  • 返回栈顶元素
  • 进栈
  • 出栈
  • 清空栈

代码实现

# 定义链栈节点
class Node:
    # 初始化链栈
    def __init__(self, data):
        self.data = data
        self.next = None


class linkstack:
    # 初始化链栈
    def __init__(self):
        self.top = None


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


    # 清空链栈
    def clear(self):
        self.top = None


    # 返回当前栈的长度
    def size(self):
        i = 0
        tempnode = self.top
        while tempnode is not None:   # 从头开始遍历
            tempnode = tempnode.next
            i += 1
        return i


    # 元素入栈
    def push(self, item):
        node = Node(item)
        node.next = self.top
        self.top = node

    # 栈顶元素出栈
    def pop(self):
        x = self.top.data
        self.top = self.top.next
        return x


    # 获取栈顶元素
    def gettop(self):
        return self.top.data


    # 输出当前栈内元素
    def display(self):
        if self.top == None:
            print("当前栈内元素为空", end="")
        else:
            print("当前栈内元素为：", end="")
        tempnode = self.top
        while tempnode is not None:
            print(tempnode.data, end=" ")
            tempnode = tempnode.next
        print()


s1 = linkstack()
print("初始化的栈为：", s1)
print("------------------------")
print("入栈前的链栈元素为：", end="")
s1.display()
s1.push(1)
s1.push(2)
s1.push(3)
s1.push(4)
s1.push(5)
s1.push(6)
print("入栈后的链栈元素为：", end="")
s1.display()
print("------------------------")
print("当前栈顶元素为：",s1.gettop())
print("------------------------")
print("当前链栈的长度为：", s1.size())
print("------------------------")
print("出栈前的链栈元素为：", end="")
s1.display()
print("出栈元素为：", s1.pop())
print("出栈后的链栈元素为：", end="")
s1.display()
print("------------------------")
print("清空前的链栈元素为：", end="")
s1.display()
s1.clear()
print("清空后的链栈元素为：", end="")
s1.display()
print("------------------------")
print("当前链栈是否为空：", s1.is_empty())
print("------------------------")

初始化的栈为： <__main__.linkstack object at 0x0000023734D08460>
------------------------
入栈前的链栈元素为：当前栈内元素为空
入栈后的链栈元素为：当前栈内元素为：6 5 4 3 2 1 
------------------------
当前栈顶元素为： 6
------------------------
当前链栈的长度为： 6
------------------------
出栈前的链栈元素为：当前栈内元素为：6 5 4 3 2 1 
出栈元素为： 6
出栈后的链栈元素为：当前栈内元素为：5 4 3 2 1 
------------------------
清空前的链栈元素为：当前栈内元素为：5 4 3 2 1 
清空后的链栈元素为：当前栈内元素为空
------------------------
当前链栈是否为空： True
------------------------

4.栈的应用

4.1括号匹配问题

括号匹配问题：给一个字符串，其中包含小括号、中括号、大括号，求该字符串中的括号是否匹配。

思路：

  • 如果遇到左括号，都进栈；遇到右括号，查看栈顶是否为对应左括号，如果是对应左括号则该对应左括号出栈，如果是空栈则false，如果是不对应左括号则false。等遍历完整个字符串后，查看栈是否为空，如果为空则括号匹配成功，如果不为空则括号匹配失败。
# 定义顺序栈
class sqStack:
    # 初始化栈
    def __init__(self, MAXSIZE):
        self.MAXSIZE = MAXSIZE
        self.data = [None] * self.MAXSIZE
        self.top = -1

    # 判断当前栈是否为空
    def is_empty(self):
        return self.top == -1

    def gettop(self):
        if self.is_empty():
            print("当前顺序栈为空")
            return None
        else:
            return self.data[self.top]

    # 入栈
    def Push(self, item):
        # 判断栈是否已满
        if self.top == self.MAXSIZE - 1:
            return "sqStack is full."
        self.data[self.top + 1] = item
        self.top += 1

    # 列表入栈
    def ListPush(self, x):
        # 判断栈是否已满
        if self.top == self.MAXSIZE - 1:
            return "sqStack is full."
        for i in range((len(x))):
            self.Push(x[i])

    # 出栈
    def Pop(self):
        # 判断栈是否为空
        if self.is_empty():
            return "sqStack is empty"
        rs = self.data[self.top]
        self.top -= 1
        return rs

    # 输出栈的长度
    def size(self):
        return self.top + 1

    # 输出栈内元素
    def display(self):
        # 判断栈是否为空
        if self.is_empty():
            print("当前顺序栈为空", end=" ")
        else:
            print("当前链表元素为：", end="")
        for i in range(self.top + 1):
            print(self.data[i], end=" ")
        print()

    # 清空栈
    def clear(self):
        self.data = [None] * self.MAXSIZE
        self.top = -1


def matching(strings):  # 输入是一串字符
    bktStack = sqStack(60)  # 创建类实例
    flag = 1
    opens = "{[("
    closes = "}])"
    # 对于每个输入字符
    for i in strings:
        # 遇到左括号，就将其压栈
        if i in opens:
            bktStack.Push(i)
        # 遇到右括号
        elif i in closes:
            # 若已没左括号与之匹配
            if bktStack.is_empty():
                # 不匹配，结束
                return False
            # 左括号按什么顺序入，右括号应按相反顺序消掉。
            # 如果匹配，右括号消的始终是栈顶括号。
            # 弹栈bktStack.pop()，判断栈顶左括号与当前右括号是否匹配
            if closes.index(i) != opens.index(bktStack.Pop()):
                # 不匹配，结束
                return False
    # 若一直没有return而是遍历了一遍，且没有多余左括号留在栈中，则说明匹配。反之不匹配。
    return bktStack.is_empty()


# 判断返回的是True还是False
def check(strings):
    if matching(strings):
        print("%s 匹配正确!" % strings)
    else:
        print("%s 匹配错误！" % strings)

if __name__ == "__main__":
    # 测试函数
    for i in range(4):
        stringa = input()
        check(stringa)

{{([][])}()}
{{([][])}()} 匹配正确!
[[{{(())}}]]
[[{{(())}}]] 匹配正确!
[[(()(()))])]{}
[[(()(()))])]{} 匹配错误！

4.2十进制转二进制

当将一个十进制整数M转换为二进制数时，在计算过程中，把M与2求余得到的二进制数的各位依次进栈，计算完毕后将栈中的二进制数依次出栈输出，输出结果就是待求得的二进制数。

测试案例：
[200, 254, 153, 29, 108, 631, 892]

运行结果

在这里插入图片描述
代码实现：

class sqStack:
    # 初始化栈
    def __init__(self, MAXSIZE):
        self.MAXSIZE = MAXSIZE
        self.data = [None] * MAXSIZE
        self.top = -1


    # 判断当前栈是否为空
    def is_empty(self):
        return self.top == -1


    # 返回栈顶元素
    def gettop(self):
        if self.is_empty():
            print("当前顺序栈为空")
            return None
        else:
            return self.data[self.top]


    # 入栈
    def Push(self, item):
        # 判断栈是否已满
        if self.top == self.MAXSIZE - 1:
            return "sqStack is full"
        self.data[self.top + 1] = item
        self.top += 1

    # 列表入栈
    def ListPush(self, x):
        # 判断栈是否已满
        if self.top == self.MAXSIZE - 1:
            return "sqStack is full"
        for i in range(len(x)):
            self.Push(x[i])


    # 出栈
    def Pop(self):
        # 判断栈是否为空
        if self.is_empty():
            return "sqStack is empty"
        rs = self.data[self.top]
        self.top -= 1
        return rs


    # 输出栈的长度
    def size(self):
        return self.top + 1


    # 输出栈内元素
    def display(self):
        # 判断栈是否为空
        if self.is_empty():
            print("当前顺序栈为空", end=" ")
        else:
            print("当前链表元素为：", end="")
        for i in range(self.top + 1):
            print(self.data[i], end=" ")
        print()


    # 清空栈
    def clear(self):
        self.data = [None] * self.MAXSIZE
        self.top = -1



s = sqStack(20)
data = int(input("请输入十进制数："))
while data != 0:
    ys = data % 2
    s.Push(ys)
    data = data // 2

while s.top != -1:
    print(s.Pop(), end="")

请输入十进制数：200
11001000

请输入十进制数：254
11111110

请输入十进制数：153
10011001

请输入十进制数：29
11101

请输入十进制数：108
1101100

请输入十进制数：631
1001110111

请输入十进制数：892
1101111100

4.3十进制转N进制

当将一个十进制整数M转换为N进制数时，在计算过程中，把M与N求余得到的N进制数的各位依次进栈，计算完毕后将栈中的N进制数依次出栈输出，输出结果就是待求得的N进制数。

测试案例：

  • 测试数：[200, 254, 153, 29, 108, 631, 892]
  • 进制：[4, 8, 16]

自由搭配即可，这里我主要使用了random.choice()来对测试数要转换的进制随机取数

代码实现：

class sqStack:
    # 初始化栈
    def __init__(self, MAXSIZE):
        self.MAXSIZE = MAXSIZE
        self.data = [None] * MAXSIZE
        self.top = -1


    # 判断当前栈是否为空
    def is_empty(self):
        return self.top == -1


    # 返回栈顶元素
    def gettop(self):
        if self.is_empty():
            print("当前顺序栈为空")
            return None
        else:
            return self.data[self.top]


    # 入栈
    def Push(self, item):
        # 判断栈是否已满
        if self.top == self.MAXSIZE - 1:
            return "sqStack is full"
        self.data[self.top + 1] = item
        self.top += 1

    # 列表入栈
    def ListPush(self, x):
        # 判断栈是否已满
        if self.top == self.MAXSIZE - 1:
            return "sqStack is full"
        for i in range(len(x)):
            self.Push(x[i])


    # 出栈
    def Pop(self):
        # 判断栈是否为空
        if self.is_empty():
            return "sqStack is empty"
        rs = self.data[self.top]
        self.top -= 1
        return rs


    # 输出栈的长度
    def size(self):
        return self.top + 1


    # 输出栈内元素
    def display(self):
        # 判断栈是否为空
        if self.is_empty():
            print("当前顺序栈为空", end=" ")
        else:
            print("当前链表元素为：", end="")
        for i in range(self.top + 1):
            print(self.data[i], end=" ")
        print()


    # 清空栈
    def clear(self):
        self.data = [None] * self.MAXSIZE
        self.top = -1



def divideByN(number, base):
    digits = "0123456789ABCDEF"
    remstack = sqStack(100)
    while number > 0:
        rem = number % base
        remstack.Push(rem)
        number = number // base
    newString = ""
    while not remstack.is_empty():
        newString = newString + digits[remstack.Pop()]
    return newString


import random
numbers = [200,254,153,29,108,631,892]
bases = [4,8,16]
for number in numbers:
    base = random.choice(bases)
    print(f"{number} 的 {base}进制数为：{divideByN(number, base)}")

200 的 16进制数为：C8
254 的 4进制数为：3332
153 的 4进制数为：2121
29 的 4进制数为：131
108 的 16进制数为：6C
631 的 8进制数为：1167
892 的 8进制数为：1574

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2155253.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

IDEA去除掉虚线，波浪线，和下划线实线的方法

IDEA去除掉虚线，波浪线，和下划线实线的方法

初次安装使用IDEA&#xff0c;总是能看到导入代码后&#xff0c;出现很多的波浪线&#xff0c;下划线和虚线&#xff0c;这是IDEA给我们的一些提示和警告&#xff0c;但是有时候我们并不需要&#xff0c;反而会让人看着很不爽&#xff0c;这里简单记录一下自己的调整方法&#…
阅读更多...
Linux：权限管理

Linux：权限管理

基本权限和归属 权限和归属 基本权限与归属 • 访问权限 – 读取&#xff1a;允许查看内容-read – 写入&#xff1a;允许修改内容-write – 可执行&#xff1a;允许运行和切换-excute对于文本文件&#xff1a;r读取权限&#xff1a;cat、less、grep、head、tailw写入权限&am…
阅读更多...
linux下共享内存的3种使用方式

linux下共享内存的3种使用方式

进程是资源封装的单位&#xff0c;内存就是进程所封装的资源的一种。一般情况下&#xff0c;进程间的内存是相互隔离的&#xff0c;也就是说一个进程不能访问另一个进程的内存。如果一个进程想要访问另一个进程的内存&#xff0c;那么必须要进过内核这个桥梁&#xff0c;这就是…
阅读更多...
中国雕塑—孙溟㠭凿刻印《自然贼》

中国雕塑—孙溟㠭凿刻印《自然贼》

中国雕塑孙溟㠭凿刻作品《自然贼》 孙溟㠭凿刻印《自然贼》 遵循自然之法谓之道&#xff0c;脱离自然之道谓之贼&#xff0c;道法自然。丙申秋月溟展刊。 孙溟㠭凿刻印《自然贼》 这方《自然贼》&#xff0c;红木章料&#xff0c;半尺见方&#xff0c;自然古朴&#xff0c;浑…
阅读更多...
摆脱困境并在iPhone手机上取回删除照片的所有解决方案

摆脱困境并在iPhone手机上取回删除照片的所有解决方案

您是否无意中从 iPhone 中删除了照片&#xff1f;您&#xff0c;无需惊慌&#xff0c;因为您可以使用以下方法恢复所有照片。 如果您长时间使用 iPhone&#xff0c;您应该知道 iOS 提供了许多 Android 不提供的备份功能。例如&#xff0c;您的所有照片都会自动备份到 iCloud 存…
阅读更多...
【机器学习(七)】分类和回归任务-K-近邻 (KNN)算法-Sentosa_DSML社区版

【机器学习(七)】分类和回归任务-K-近邻 (KNN)算法-Sentosa_DSML社区版

文章目录 一、算法概念二、算法原理&#xff08;一&#xff09;K值选择&#xff08;二&#xff09;距离度量1、欧式距离2、曼哈顿距离3、闵可夫斯基距离 &#xff08;三&#xff09;决策规则1、分类决策规则2、回归决策规则 三、算法优缺点优点缺点 四、KNN分类任务实现对比&am…
阅读更多...
音视频生态下Unity3D和虚幻引擎（Unreal Engine）的区别

音视频生态下Unity3D和虚幻引擎（Unreal Engine）的区别

技术背景 好多开发者跟我们做技术交流的时候&#xff0c;会问我们&#xff0c;为什么有Unity3D的RTMP|RTSP播放模块&#xff0c;还有RTMP推送和轻量级RTSP服务模块&#xff0c;为什么不去支持虚幻引擎&#xff1f;二者区别在哪里&#xff1f;本文就Unity3D和虚幻引擎之间的差异…
阅读更多...
idea上传jar包到nexus

idea上传jar包到nexus

注意&#xff1a;确保idea中项目为maven项目&#xff0c;并且在nexus中已经创建了maven私服。 1、配置pom.xml中推送代码配置 <distributionManagement> <repository> <id>releases</id> <url>http://127.0.0.1:8001/repository/myRelease/<…
阅读更多...
鼻咽癌中三级淋巴结构的单细胞与空间转录组分析｜文献精析·24-09-22

鼻咽癌中三级淋巴结构的单细胞与空间转录组分析｜文献精析·24-09-22

小罗碎碎念 研究团队通过单细胞和空间转录组分析&#xff0c;揭示了与鼻咽癌进展和免疫治疗反应相关的三级淋巴结构。 作者角色作者姓名单位&#xff08;中文&#xff09;第一作者Yang Liu/通讯作者Jin-Xin Bei国家癌症中心南方肿瘤学重点实验室&#xff0c;鼻咽癌诊断治疗广东…
阅读更多...
机器学习04-逻辑回归（python）-02原理与损失函数

机器学习04-逻辑回归（python）-02原理与损失函数

​​​​​​​ 1. 逻辑回归概念 逻辑回归&#xff08;Logistic Regression&#xff09; 是一种 分类模型&#xff0c;主要用于解决 二分类问题&#xff08;即分成两类&#xff0c;如是否通过、是否患病等&#xff09;。逻辑回归的目标是根据输入的特征预测一个 概率&#xff0…
阅读更多...
C++——关联式容器（4）：set和map

C++——关联式容器（4）：set和map

在接触了诸如二叉搜索树、AVL树、红黑树的树形结构之后&#xff0c;我们对树的结构有了大致的了解&#xff0c;现在引入真正的关联式容器。 首先&#xff0c;先明确了关联式容器的概念。我们之前所接触到的如vector、list等容器&#xff0c;我们知道他们实际上都是线性的数据结…
阅读更多...
C++门迷宫

C++门迷宫

目录 开头程序程序的流程图程序游玩的效果下一篇博客要说的东西 开头 大家好&#xff0c;我叫这是我58。 程序 #include <iostream> using namespace std; void printmaze(const char strmaze[11][11]) {int i 0;int ia 0;for (; i < 11; i) {for (ia 0; ia <…
阅读更多...
部署林风社交论坛/社交论坛linfeng-community遇到问题集合

部署林风社交论坛/社交论坛linfeng-community遇到问题集合

部署开源版本遇到的问题 1.管理端前端部署 npm install报错 “ERR! gyp verb ensuring that file exists: C:\Python27\python.exe” “ERR! gyp ERR! node -v v20.10.0” “ ERR! gyp ERR! node-gyp -v v3.8.0” 原因:node版本和node-gyp版本不匹配 解决方法: 1&…
阅读更多...
航拍房屋检测系统源码分享

航拍房屋检测系统源码分享

航拍房屋检测检测系统源码分享 [一条龙教学YOLOV8标注好的数据集一键训练_70全套改进创新点发刊_Web前端展示] 1.研究背景与意义 项目参考AAAI Association for the Advancement of Artificial Intelligence 项目来源AACV Association for the Advancement of Computer Vis…
阅读更多...
基于stm32物联网身体健康检测系统

基于stm32物联网身体健康检测系统

在当今社会&#xff0c;由于经济的发展带来了人们生活水平不断提高&#xff0c;但是人们的健康问题却越来越突出了&#xff0c;各种各样的亚健康随处可在&#xff0c;失眠、抑郁、焦虑症&#xff0c;高血压、高血糖等等侵袭着人们的健康&#xff0c;人们对健康的关注达到了一个…
阅读更多...
职业发展如何进入人工智能领域

职业发展如何进入人工智能领域

基础知识和技能 进入人工智能领域需要学习一系列的基础知识和技能&#xff0c;以下是一些关键的步骤和领域&#xff1a; 基础数学知识&#xff1a;人工智能领域涉及到大量的数学概念&#xff0c;包括线性代数、概率论、统计学和微积分。这些数学工具对于理解和设计算法至关重要…
阅读更多...
Java流程控制语句——跳转语句详解：break 与 continue 有什么区别？

Java流程控制语句——跳转语句详解：break 与 continue 有什么区别？

&#x1f310;在Java编程中&#xff0c;break和continue是两个重要的控制流语句&#xff0c;它们允许开发者根据特定条件改变程序的执行流程。虽然两者都用于中断当前的行为&#xff0c;但它们的作用方式不同。本文将通过生动的例子来详细解释这两个语句&#xff0c;并使用流程…
阅读更多...
[Redis][Set]详细讲解

[Redis][Set]详细讲解

目录 0.前言1.常用命令1.SADD2.SMEMBERS3.SISMEMBER4.SCARD5.SPOP6.SMOVE7.SREM 2.集合间操作0.是什么&#xff1f;1.SINTER2.SINTERSTORE3.SUNION4.SUNIONSTORE5.SDIFF6.SDIFFSTORE 3.内部编码1.intset(整数集合)2.hashtable(哈希表) 4.使用场景 0.前言 集合类型也是保存多个字…
阅读更多...
SpringBoot 整合 Caffeine 实现本地缓存

SpringBoot 整合 Caffeine 实现本地缓存

目录 1、Caffeine 简介1.1、Caffeine 简介1.2、对比 Guava cache 的性能主要优化项1.3、常见的缓存淘汰算法1.4、SpringBoot 集成 Caffeine 两种方式 2、SpringBoot 集成 Caffeine 方式一2.1、缓存加载策略2.1.1、手动加载2.1.2、自动加载【Loading Cache】2.1.3、异步加载【As…
阅读更多...
智能AC管理系统信息泄露漏洞

智能AC管理系统信息泄露漏洞

文章目录 免责声明漏洞描述搜索语法漏洞复现yaml修复建议 免责声明 本文章仅供学习与交流&#xff0c;请勿用于非法用途&#xff0c;均由使用者本人负责&#xff0c;文章作者不为此承担任何责任 漏洞描述 智能AC管理系统是一个控制管理系统因存在未授权访问导致信息泄露 搜…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023