数据结构与算法_渡劫6_栈和队列

最新推荐文章于 2022-10-27 20:15:37 发布
最新推荐文章于 2022-10-27 20:15:37 发布
阅读量196 收藏
点赞数
分类专栏： 数据结构与算法 Python笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_37598106/article/details/102692035
版权

文章目录

一、栈

1. 定义

栈（stack）是限定仅在表尾进行插入和删除操作的线性表。

  • 何时选择栈？

当某个数据集合只涉及在一段插入和删除数据，并且满足后进先出、先进后出的特性，首选栈

2. 栈实现

栈的主要操作有两个：

  • 入栈：栈顶插入一个数据

  • 出栈：栈顶删除一个数据

根据实现方式不同，分为：

  • 顺序栈：用数组实现的栈

  • 链式栈：用链表实现的栈

时间复杂度和空间复杂度均是Ｏ(1)

3. 栈的应用

最常见的是函数调用栈


int main() {

   int a = 1; 

   int ret = 0;

   int res = 0;

   ret = add(3, 5);

   res = a + ret;

   printf("%d", res);

   reuturn 0;

}



int add(int x, int y) {

   int sum = 0;

   sum = x + y;

   return sum;

}

4. 递归

  • 递归的秘诀：

将大问题分解为小问题，写出递推公式和终止条件。

  • 警惕：

  1. 不要用人脑去分解递归的每个调用关系，即每一个步骤

  2. 不要栈溢出

  3. 不要重复计算

5. 代码实现栈的操作123

  • 创建空栈

  • push（入栈）

  • pop（出栈）

  • top（取出栈最后压入的元素）

  • 顺序栈，python用表实现，表尾为栈顶：

# coding=utf-8
'''
@ Summary: python中的list可以满足栈的操作，但是多了栈所没有的操作
           缺乏安全性，因此把list作为类的内部，作为实现基础
@ Update:  

@ file:    3-1.栈的顺序表实现.py
@ version: 1.0.0

@ Author:  Lebhoryi@gmail.com
@ Date:    19-10-7 下午6:17
'''

class SStack(object):
    def __init__(self):
        self._elem = []

    def is_empty(self):
        # 是否空栈
        return self._elem == []

    def top(self):
        # 取栈顶元素
        if self.is_empty():
            return None
        return self._elem[-1]

    def push(self, elem):
        # 入栈
        return self._elem.append(elem)

    def pop(self):
        # 出栈
        if self.is_empty():
            return None
        return self._elem.pop()

if __name__ == "__main__":
    st1 = SStack()
    st1.push(3)
    # print(st1.top())
    st1.push(5)
    while not st1.is_empty():
        print(st1.pop())
  • 链接表实现栈，表头为栈顶：

# coding=utf-8
'''
@ Summary: 用链表实现栈的相关操作
@ Update:  

@ file:    3-2.栈的链接表实现.py
@ version: 1.0.0

@ Author:  Lebhoryi@gmail.com
@ Date:    19-10-7 下午6:29
'''

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

    def __repr__(self):
        return str(self.val)

class LStack(object):
    @ staticmethod
    def c_link(vals):
        # create link
        if not vals:
            return None
        head = Node(len(vals))  # head node
        move = head  # move node
        for val in vals:
            tmp = Node(val)
            move.next = tmp
            move = tmp
        return head.next

    @ staticmethod
    def p_link(link):
        # print link
        if not link:
            return None
        while link:
            yield link.val
            link = link.next

    @ staticmethod
    def top(link):
        # 取出栈顶元素
        if not link:
            return None
        return link.val

    @ staticmethod
    def push(link, elem):
        # 入栈
        elem = Node(elem)
        elem.next = link
        return elem

    @ staticmethod
    def pop(link):
        # 出栈
        if not link:
            return None
        p = link
        link = link.next
        return p.val, link


if __name__ == "__main__":
    _list = list(range(1, 7))
    # link = None
    # for i in _list:
    #     link = LStack.push(link, i)
    # for node in LStack.p_link(link):
    #     print(node, end=" ")

    top = LStack.c_link(_list)
    for node in LStack.p_link(top):
        print(node, end=" ")
    print()
    # output: 1 2 3 4 5 6

    top = LStack.push(top, 10)
    for node in LStack.p_link(top):
        print(node, end=" ")
    print()
    # output: 10 1 2 3 4 5 6

    elem, top = LStack.pop(top)
    print(elem)
    for node in LStack.p_link(top):
        print(node, end=" ")
    print()

    elem = LStack.top(top)
    print(elem)
  • 代码练习1：二进制转十进制

# coding=utf-8
'''
@ Summary: 二进制转十进制,用栈实现
@ Update:  

@ file:    3-3.二进制转十进制.py
@ version: 1.0.0

@ Author:  Lebhoryi@gmail.com
@ Date:    19-10-7 下午7:16
'''

class SStack(object):
    def __init__(self):
        self._elem = []

    def is_empty(self):
        # 是否空栈
        return self._elem == []

    def push(self, elem):
        # 入栈
        return self._elem.append(elem)

    def pop(self):
        # 出栈
        if self.is_empty():
            return None
        return self._elem.pop()

if __name__ == "__main__":
    _input = 1010110
    _list = list(map(int, str(_input)))

    st1 = SStack()
    for i in _list:
        st1.push(i)
    print(st1._elem)

    sum = count = 0
    while not st1.is_empty():
        # print(st1.pop(), end=" ")
        _pop = st1.pop()
        sum = sum + _pop * 2**count
        count += 1
    print(sum)
  • 代码练习2：二进制转八进制

# coding=utf-8
'''
@ Summary: 用栈实现二进制转八进制
@ Update:  

@ file:    3-3.二进制转八进制.py
@ version: 1.0.0

@ Author:  Lebhoryi@gmail.com
@ Date:    19-10-7 下午10:05
'''

class SStack(object):
    def __init__(self):
        self._elem = []

    def is_empty(self):
        # 是否空栈
        return self._elem == []

    def push(self, elem):
        # 入栈
        return self._elem.append(elem)

    def pop(self):
        # 出栈
        if self.is_empty():
            return None
        return self._elem.pop()

if __name__ == "__main__":
    _input = 11001001  # 初始值
    _list = list(map(int, str(_input)))  # int to list
    while len(_list) % 3 != 0:  # 三的倍数，不够补0
        _list.insert(0, 0)

    _list.insert(0, 0)  # 为了后面的while 循环到栈底的时候继续运行，增加一个0
    st1 = SStack()  # 二进制的栈
    st2 = SStack()  # 八进制的栈
    for i in _list:  # 二进制digui入栈
        st1.push(i)
    print(st1._elem)

    # 二进制 三个弹出，计算，压入八进制栈
    tmp = []  # 储存三个二进制数
    count = 1  # 计数
    while not st1.is_empty():
        if count < 4:
            # 找到三个二进制数
            tmp.append(str(st1.pop()))
            count += 1
        else:
            num = "".join(tmp)
            # 二进制转八进制
            num = int(num[2]) * 2**2 + int(num[1]) * 2**1 + \
                  int(num[0]) * 2**0
            st2.push(num)  # 入栈
            count = 1
            tmp = []

    print(st2._elem)
  • 代码练习3：逆波兰表达式

# coding=utf-8
'''
@ Summary: 逆波兰表达式,又称后缀表达式
@ Update:  

@ file:    3-4.逆波兰表达式.py
@ version: 1.0.0

@ Author:  Lebhoryi@gmail.com
@ Date:    19-10-8 下午3:29
'''

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

    def __repr__(self):
        return str(self.val)

class LStack(object):
    def __init__(self):
        self.top = None

    def push(self, elem):
        # 入栈
        elem = Node(elem)
        elem.next = self.top
        self.top = elem

    def pop(self):
        # 出栈
        if not self.top:
            return None
        p = self.top
        self.top = self.top.next
        return p.val

    def p_link(self):
        if not self.top:
            return None
        while self.top:
            print(self.top.val, end=" ")
            self.top = self.top.next


def RPN(_list):
    # _int = [str(i) for i in range(20)]
    operators = "+-*/"

    st1 = LStack()
    for item in _list:
        try:
            item = int(item)
            st1.push(item)
        except ValueError:
            if item in operators:
                x2 = st1.pop()
                x1 = st1.pop()
                if item == "+":
                    st1.push(x1 + x2)
                elif item == "-":
                    st1.push(x1 - x2)
                elif item == "*":
                    st1.push(x1 * x2)
                elif item == "/":
                    st1.push(x1 / x2)

    return st1.top

if __name__ == "__main__":
    # _input = "1 2 - 4 5 + *"  # -9
    # _input = "5 6 7 + 8 * - 9 4 / +"  # -96.75
    _input = "3 5 - 6 17 4 * + * 3 /"
    _list = _input.split(" ")  # str to list

    print(RPN(_list))

---



- 代码练习4： 中缀表达式转后缀表达式

```python

# coding=utf-8
'''
@ Summary: 中缀表达式转换为后缀表达式
@ Update:  

@ file:    3-6.逆波兰进阶.py
@ version: 1.0.0

@ Author:  Lebhoryi@gmail.com
@ Date:    19-10-8 下午4:43
'''
class Node(object):
    def __init__(self, val):
        self.val = val
        self.next = None

    def __repr__(self):
        return str(self.val)

class LStack(object):
    def __init__(self):
        # 初始化 top node
        self._top = None

    def push(self, elem):
        # 入栈 self._top 始终指向first node
        elem = Node(elem)
        elem.next = self._top
        self._top = elem

    def pop(self):
        # 出栈 self._pop指向第二个节点, 返回第一个节点的值
        if not self._top:
            return None
        p = self._top
        self._top = self._top.next
        return p.val


def mid_2_after(l):
    # 中缀转后缀

    # 优先级
    ops_relu = {"+":1, "-":1,
                "*":2, "/":2,
                "(":1, ")":1}

    stack = LStack()  # 储存运算符和"（）"的栈
    lt = []  # 输出列表

    for item in l:
        # 遇到数字添加进列表中，非数字进行栈的相关操作
        try:
            item = int(item)
            lt.append(item)
        except ValueError:
            if item != ")":
                # 优先级顺序，栈顶的优先级高则弹出栈中所有元素
                if stack._top and ops_relu[item] < ops_relu[stack._top.val]:
                    while stack._top:
                        lt.append(stack.pop())
                stack.push(item)  # 入栈
            else:
                # 遇到")", 弹出栈中的元素, 直到"("为止
                while stack._top.val != "(":
                    lt.append(stack.pop())
                stack.pop()  # delete "("

    # 弹出栈中所有元素
    while stack._top:
        lt.append(stack.pop())

    return lt


if __name__ == "__main__":
    _input = "1 + ( 2 - 3 ) * 4 + 10 / 5"  # "1 2 3 - 4 * + 10 5 / +"
    _list = _input.split(" ")  # str to list
    print("The origin list is: {}.".format(_list))

    print(mid_2_after(_list))
  • 代码练习4：斐波那契

最常见的栈：函数调用


# coding=utf-8
'''
@ Summary: 斐波那契
@ Update:  

@ file:    3-7.斐波那契.py
@ version: 1.0.0

@ Author:  Lebhoryi@gmail.com
@ Date:    19-10-8 下午10:18
'''

def fib(n):
    # 递归
    if n < 2:
        return n
    return fib(n-1) + fib(n-2)

def fib2(n):
    # 生成器
    if n < 0:
        return None
    a, b = 0, 1
    for _ in range(n):
        yield b
        a, b = b, b + a


if __name__ == "__main__":
    for i in fib2(5):
        print(i)
  • 代码练习5：字符串反转

# coding=utf-8
'''
@ Summary: 递归实现字符串翻转
@ Update:  

@ file:    3-8.字符串翻转.py
@ version: 1.0.0

@ Author:  Lebhoryi@gmail.com
@ Date:    19-10-9 上午9:05
'''

def reverse(s):
    if len(s) <= 1:
        return s
    elif len(s) == 2:
        return s[1] + s[0]
    return s[-1] + reverse(s[:-1])

if __name__ == "__main__":
    s = "ABC"
    print(reverse(s))
  • 代码练习6：汉诺塔

# coding=utf-8
'''
@ Summary: 递归实现汉诺塔
@ Update:  

@ file:    3-9.汉诺塔.py
@ version: 1.0.0

@ Author:  Lebhoryi@gmail.com
@ Date:    19-10-9 上午9:19
'''
def hanoi(n, x, y, z):
    if n == 1:
        print(x + " --> " + z)
    else:
        # 将n-1个从X移动到Y上，借助Z
        hanoi(n-1, x, z, y)
        # 将第n个从X移动到Z上
        print(x + " --> " + z)
        # 将n-1个从Y移动到Z上，借助X
        hanoi(n-1, y, x, z)

if __name__ == "__main__":
    hanoi(4, "X", "Y", "Z")
  • 代码练习7：八皇后问题
  • 代码练习8：括号匹配



# coding=utf-8
'''
@ Summary: 
@ Update:  

@ file:    括号匹配.py
@ version: 1.0.0

@ Author:  Lebhoryi@gmail.com
@ Date:    10/15/19 9:55 PM
'''

def is_valid(s):
    if not s:
        return None
    parent = "()[]{}"
    opposite = {")":"(", "]":"[", "}":"{"}
    st = []  # 栈
      for item in s:
        if item in parent:
            st.append(item)
        if item in opposite:
            del_elem = st.pop()
            if not st or opposite[del_elem] != st.pop():
                return False
    return not st

if __name__ == "__main__":
    s = "9(){}"
    if is_valid(s):
        print("{} is OK.".format(s))
    else:
        print("{} is not OK.".format(s))

二、队列

1. 定义

先进先出，比如排队买票

2. 入队、出队

  • 链式队列（链表表头为队头，表尾为队尾）

# coding=utf-8
'''
@ Summary: 链表实现队列，任意输入一串字符 # 结束
@ Update:  
@ file:    队列.py
@ version: 1.0.0
@ Author:  Lebhoryi@gmail.com
@ Date:    10/17/19 4:21 PM
'''
class Node(object):
    def __init__(self, val):
        self.val = val

        self.next = None


    def __repr__(self):
        return str(self.val)


class LQueue(object):
    def __init__(self):
        self.front = Node(0)
        self.rear = Node(0)


    def is_empty(self):
        # 判断是否为空
        return self.front.val == self.rear.val


    def enqueue(self, elem):
        # 入队
        elem = Node(elem)
        if self.is_empty():
            self.front.next = elem
        self.rear.next = elem
        self.rear = elem


    def dequeue(self):
        # 出队
        if self.is_empty():
            return None
        del_node = self.front.next.val
        if self.front.next == self.rear:
            # 当只有一个元素的时候
            self.front = self.rear
        else:
            self.front.next = self.front.next.next
        return del_node


    def get_head(self):
        # 查看队头元素
        if self.is_empty():
            return None
        return self.front.next


    def p_queue(self):
        # print queuep
        if self.is_empty():
            return None
        tmp = self.front.next
        while tmp:
            print(tmp, end=" ")
            tmp = tmp.next


if __name__ == "__main__":
    # 创建队列
    lq = LQueue()
    data = input("请输入（#结束）：")
    while data != "#":
        lq.enqueue(data)
        data = input("请输入（#结束）：")
    lq.p_queue()  # 最初的链式列表
  • 顺序队列的出队和入队

# coding=utf-8
'''
@ Summary: 顺序队列
@ Update:  
@ file:    队列2.py
@ version: 1.0.0
@ Author:  Lebhoryi@gmail.com
@ Date:    10/18/19 12:19 AM
'''
class SQueue(object):
    def __init__(self):
        self._queue = []


    def is_empty(self):
        return self._queue == []


    def en_queue(self, elem):
        self._queue.insert(0, elem)
        # self._queue.append(elem)


    def de_queue(self):
        if self.is_empty():
            return None
        del_node = self._queue.pop()
        # del_node = self._queue.pop(0)
        return del_node


    def p_queue(self):
        if self.is_empty():
            return None
        return self._queue


if __name__ == "__main__":
    sq = SQueue()
    data = input("请输入（输入# 结束）:")
    while data != "#":
        sq.en_queue(data)
        data = input("请输入（输入# 结束）:")
    print(sq.p_queue())
    sq.de_queue()
    print(sq.p_queue())

队列跟栈一样，也是一种操作受限的线性表数据结构。

3. 循环队列


# coding=utf-8
'''
@ Summary: 顺序表实现循环队列
@ Update:  
@ file:    循环队列.py
@ version: 1.0.0
@ Author:  Lebhoryi@gmail.com
@ Date:    10/18/19 10:24 AM
'''

class SQueue(object):
    def __init__(self, maxsize):
        self.maxsize = maxsize  # 自定义队列长度
        self._queue = [None] * maxsize
        self.front = 0  # 指向队头
        self.rear = 0  # 指向队尾元素的下一个位置


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


    def q_length(self):
        # 当前队列长度计算 (rear-front+maxsize)%maxsize
        return (self.rear - self.front + self.maxsize) % self.maxsize


    def enqueue(self, elem):
        # 队尾入队 elem push
        if (self.rear + 1) % self.maxsize == self.front:
        # 判断队列是否填满 (rear+1)%maxsize == front
            print("The queue is full!")
        self._queue[self.rear] = elem
        self.rear = (self.rear + 1) % self.maxsize


    def dequeue(self):
        # 队头出队 elem pull
        if self.is_empty():
            return None
        del_elem = self._queue[self.front]
        self._queue[self.front] = None
        self.front = (self.front + 1) % self.maxsize
        return del_elem


    def p_queue(self):
        # print queue
        if self.is_empty():
            return None
        for i in range(self.maxsize):
            print(self._queue[i], end=" ")
        print()



if __name__ == "__main__":
    s = "abcdde"
    sq = SQueue(15)  # 循环队列
    for item in range(10):
        # 入队
        sq.enqueue(item)
    sq.p_queue()  # 原始队列
    for i in range(5):  # 删除队头的5个元素：0~4
        sq.dequeue()
    sq.p_queue()
    for i in range(8):  # 从队尾增加8个元素：0~7
        sq.enqueue(i)
    sq.p_queue()

4.代码练习：

  • 用两个栈实现队列 （剑指offer和力扣）

# coding=utf-8
'''
@ Summary: 剑指Offer-用两个栈来实现一个队列，完成队列的Push和Pop操作
@ Update:  (先进先出)

@ file:    3-15.2栈实现队列.py
@ version: 1.0.0

@ Author:  Lebhoryi@gmail.com
@ Date:    19-10-21 下午10:00
'''
import pysnooper

class SStack(object):

    def __init__(self):
        self.stackA = []
        self.stackB = []

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

    def push(self, elem):
        # stackA入栈
        self.stackA.append(elem)

    @pysnooper.snoop(watch=("self.stackA", "self.stackB"))
    def s_pop(self):
        # stackA 出栈 stackB 入栈
        if self.stackB:
            return self.stackB.pop()
        while self.stackA:
            self.stackB.append(self.stackA.pop())
        return self.stackB.pop()


if __name__ == "__main__":
    ss = SStack()
    for i in range(7):
        ss.push(i)
    print(ss.s_pop())
    ss.push(8)
    print(ss.s_pop())
  • 用两个队列实现栈（力扣）

# coding=utf-8
'''
@ Summary: 进栈：元素入队列A(后进先出)
           出栈：判断如果队列A只有一个元素，则直接出队。否则，把队A中的元素出队并入队B，
           直到队A中只有一个元素，再直接出队。为了下一次继续操作，互换队A和队B。
@ Update:

@ file:    3-16.2队列实现栈.py
@ version: 1.0.0

@ Author:  Lebhoryi@gmail.com
@ Date:    19-10-22 下午7:12
'''
class SQueue(object):
    def __init__(self):
        self.queueA = []
        self.queueB = []

    def is_empty(self):
        return self.queueA == [] and self.queueB == []

    def enqueue(self, elem):
        # 入队
        self.queueA.append(elem)

    def dequeue(self):
        #出队
        if self.is_empty():
            return None
        # if len(self.queueA) == 1:
        #     return self.queueA.pop()
        while len(self.queueA) > 1:
            self.queueB.append(self.queueA.pop(0))
        self.queueA, self.queueB = self.queueB, self.queueA
        return self.queueB.pop()


if __name__ == "__main__":
    sq = SQueue()
    for i in range(1, 7):
        sq.enqueue(i)
    print(sq.dequeue())
    sq.enqueue(3)
    print(sq.dequeue())
    print(sq.dequeue())
Lebhoryi
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构与算法分析--C语言描述_数据结构与算法_
10-01
数据结构与算法是计算机科学的基础，对于理解和设计高效的软件至关重要。C语言因其高效、底层特性，常被用于实现数据结构和算法，使得程序更接近硬件，性能更优。本资源"数据结构与算法分析--C语言描述"是针对数据...
数据结构与算法 25 狄杰斯特拉算法 dijkstra
shake_shark_pp
06-24 431
迪杰斯特拉算法 Dijkstra算法：用于计算一个节点到其它节点的最短路径，主要特点是以起始点为中心向外层层扩展（广度优先搜索思想），知道扩展到终点为止 应用：最短路径问题 七个村庄（A,B,C,D,E,F,G）现在有六个邮差，从G点出发，需要分别把邮件分别送到A,B,C,D,E,F六个村庄，计算G村庄到其它各个村庄的最短距离 dijkstra算法过程 设置出发点为v，顶点集合V{v1,v2,vi…}，v到V中各顶点的距离构成距离集合Dis，Dis{d1,d2,di…}，Dis集合记录着v到图中各顶点的距
图解迪杰斯特拉（Dijkstra）最短路径算法
ZER00000001的博客
06-22 7万+
【干货满满！】在介绍最短路径之前我们首先要明白两个概念：什么是源点，什么是终点？在一条路径中，起始的第一个节点叫做源点；终点：在一条路径中，最后一个的节点叫做终点；注意！源点和终点都只是相对于一条路径而言，每一条路径都会有相同或者不相同的源点和终点。而最短路径这个词不用过多解释，就是其字面意思：在图中，对于非带权无向图而言，从源点到终点边最少的路径（也就是BFS广度优先的方法）；而对于带权图而言，从源点到终点权值之和最少的路径叫最短路径；最短路径应用：道路规划；我们最关心的就是去实现寻找最短路径，通过实现.
算法之迪杰斯特拉算法
weixin_49561445的博客
06-01 4924
迪杰斯特拉(Dijkstra)算法是典型求单源（一个顶点到一个顶点）最短路径算法，用于计算一个结点到其他结点的最短路径。 它的主要特点是以起始点为中心向外层层扩展(广度优先搜索思想)，直到扩展到终点为止。 迪杰斯特拉算法思想 设G=(V,E)为一个带全有向图，把图中顶点集合V分成两组。第一组为已求出最短路径的顶点集合（用S表示，初始时S中只有一个源点，以后每求得一条最短路径 , 就将所到达最短路径的顶点加入到集合S中，直到全部顶点都加入到S中）。第二组为其余未确定最短路径的顶点集合（用U表示，U=V-S，U
Dijkstra算法（迪杰斯特拉算法）
持之以恒2016
06-24 4万+
对比算法好坏需要考虑的因素 执行算法所耗费的时间 执行算法所耗费的存储空间 Dijkstra算法（迪杰斯特拉算法） 迪杰斯特拉算法是由荷兰计算机科学家狄克斯特拉于1959年提出的，是从一个顶点到其余各顶点的最短路径算法，解决的是有权图中最短路径问题。 迪杰斯特拉算法的主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。 迪杰斯特拉算法的成功率是最高的，因为它每次必能搜索到最优路径。但迪杰...
迪杰斯特拉（Dijkstra)算法最通俗易懂的讲解
goodxin_ie的博客
03-21 18万+
一、问题定义 求解单元点的最短路径问题：给定带权有向图G和源点v，求v到G中其他顶点的最短路径 限制条件：图G中不存在负权值的边 二、思想 划重点，迪杰斯特拉最最朴素的思想就是按长度递增的次序产生最短路径。即每次对所有可见点的路径长度进行排序后，选择一条最短的路径，这条路径就是对应顶点到源点的最短路径。 Tips：可见点就是从源点开始按广度优先算法遍历顶点的过程中，搜索到的...
数据结构与算法——栈和队列
小田是个程序员的博客欢迎你的到来呀~
06-25 2万+
栈和队列是两种重要的线性结构，本篇文章详细总结了数据结构与算法中栈和队列的终点知识，并且结合代码片段实现其基本操作，干货满满，每一句话都是重点，希望能给更多的小伙伴在学习数据结构与算法时带来一定帮助...
数据结构：栈和队列(Stack & Queue)【详解】
热门推荐
UniqueUnit的博客
02-19 22万+
栈和队列知识框架 栈 一、栈的基本概念 1、栈的定义 栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。 栈顶（Top）：线性表允许进行插入删除的那一端。 栈底（Bottom）：固定的，不允许进行插入和删除的另一端。 空栈：不含任何元素的空表。 栈又称为先进先出（Last In First Out）的线性表，简称LIFO结构 2、栈的基本操作 InitStack(&S)：初始化一个空栈S。 StackEmpty(S)：
数据结构与算法----栈和队列(Stack & Queue）
小鱼干儿的博客
10-24 4742
本篇博客讲解了实际编程中常见的两种数据结构栈与队列，这两种数据结构也是竞赛考试中常见的两种数据结构，有多种题目的变形，另外说一下数据结构只是逻辑上的结构，实现的方式可以有很多种。我们学习主要是学习这个逻辑上的结构和思想。
数据结构与算法——栈和队列定义和特点
最新发布
weixin_68773927的博客
10-27 3734
栈（stack）是一个特殊的线性表是限定仅在一端（通常是尾部）运行插入和删除操作的线性表又称为先进先出的线性表简称 LIFO 结构 9（Last In First out）
DataAndAlgorithm_C#数据结构与算法_栈和队列_
09-29
本资源"DataAndAlgorithm_C#数据结构与算法_栈和队列_"专注于这两种基础但关键的数据组织方式：栈和队列，以及它们在C#语言中的实现。 栈是一种后进先出（LIFO，Last In First Out）的数据结构，常被比喻为“堆叠的...
数据结构_栈_队列_prim算法_
10-04
综上所述，这些代码示例涵盖了数据结构的基本操作和算法应用，对于学习和理解栈、队列、Prim算法以及链表和二叉树的处理技巧具有很高的价值。掌握这些基础知识对于提升编程能力和解决实际问题至关重要。
JiSuanQi.rar_jisuanqi_栈和队列_计算器 数据结构
09-20
在IT领域，数据结构是计算机科学中的核心概念之一，它涉及到如何有效地组织和存储数据，以便于算法的高效执行。本话题将详细讨论基于栈和队列数据结构的计算器实现，以及如何使用Visual C++ 6.0进行编程。 首先，栈...
数据结构与算法资料_数据结构与算法_
09-29
数据结构与算法是计算机科学的基础，对于理解和设计高效的软件至关重要。在Java编程中，掌握数据结构和算法能够帮助开发者编写出性能优越、可维护性高的代码。以下将详细阐述相关知识点。 1. **数据结构**: 数据...
urllib.request.Request的用法
lebhoryi
06-03 4万+
我们可以利用urlopen()方法可以实现最基本请求的发起，但这几个简单的参数并不足以 构建一个完整的请求，如果请求中需要加入headers（请求头）等信息，我们就可以利用 更强大的Request类来构建一个请求。也许这就是一下两个方式的区别吧：respponse = urllib.request.urlopen(url)req = urllib.request.Request(url) res
最基础的urllib.request.urlopen()基本使用
lebhoryi
06-02 2万+
'简单的用python3访问python官网' import urllib.requesturl = 'https://www.python.org'#req = urllib.request.Request(url) #response = urllib.request.urlopen(req) response = urllib.request.urlopen(url) #暂时还不知晓两者有何区
python的测试框架 - pytest 进阶项目版
lebhoryi
03-10 2379
被测函数：download_from_gitlab() def download_from_gitlab(url, cwd): """Download two SConscript files :param url: download file url (gitlab), str :param down_file: download file name, str :param cwd: current path, str :return: """ .
rgb888 转 rgb565，并验证转换是否成功（python）
lebhoryi
05-12 2243
在 k210 上做 AI 开发，遇到了一个显示图片的问题。（摄像头采集的图片有两种格式，自带rgb565，我用的不是摄像头，用的是图片数组验证模型推理结果，所以遇到了这个问题） 模型推理成功后，怎么才能在 LCD 上显示出来？ 小学弟提醒说：LCD 显示的是 RGB565 格式的图片，而正常的图片保存格式是 RGB888，那么解决方法有两个： 在项目工程中将图片转为 RGB565，（c 语言） 在电脑中将图片转为 RGB565 （python 语言） c: unsigned short int rgb
源码python打包成deb
lebhoryi
10-28 1179
@ Author: lebhoryi@gmail.com @ Date: 2021/10/28 文章目录0x01 背景故事0x02 要解决的问题0x03 将源码打包成 deb0x04 其他 0x01 背景故事 Ubuntu 20.04 系统，默认存在 Python38. 需要在系统中安装另一个版本的 Python：Python35。 已经存在 Python3 的情况下，安装另外一个 Python3.x 需要通过源码安装，（官方建议） 下载链接：https://www.python.org/downloads
算法与数据结构课件PPT第三章
07-16
算法与数据结构课件PPT第三章

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值