数据结构与算法----栈和队列(Stack Queue）

news2024/11/20 0:49:46

文章目录

  • 栈
    • 栈的操作
      • 栈的初始化
      • 入栈
      • 出栈
      • 取栈顶的元素
      • 判断栈是否为空
      • 求栈中数据元素的个数
      • 遍历栈中的所有元素
      • 清空栈
    • 栈的存储结构
      • 顺序存储
      • 链式存储
    • 顺序栈和链栈的区别
    • 栈的实战题目
  • 队列
    • 队列的操作
      • 入队
      • 出队
      • 遍历队列
      • 清空队列
    • 队列的存储结构
      • 顺序存储
      • 循环队列
      • 链式存储
    • 队列实战题目
    • 总结

  • ❤️ 作者简介：大家好我是小鱼干儿♛是一个热爱编程、热爱算法的大三学生，蓝桥杯国赛二等奖获得者
  • 🐟 个人主页 ：https://blog.csdn.net/qq_52007481
  • ⭐ 个人社区：【小鱼干爱编程】
  • 🔥 算法专栏：算法竞赛进阶指南
  • 💯 刷题网站：虽然市面上有很多的刷题网站，但是里面的题又多又杂，不适合系统性的提高算法能力，这里推荐一款我常用的刷题网站 👉点击跳转

写在前面：在学习栈和队列前我先强调一下，栈和队列都是一种编程思想，实现方式有很多种，我们只需要满足栈和队列各自的条件就可以，不必拘泥写一个类

栈

栈是限定仅在表尾进行插入和删除的线性表，允许插入、删除的一端是栈顶，另一端成为栈低，不含任何数据元素的栈称为空栈。

假设S = [x1,x2,x3,x4,x5....xn],x1为栈底元素，xn为栈顶元素，插入和删除只能从xn端操作，进栈只能是按x1,x2,x3,x4,x5....xn的顺序进栈，出栈只能从栈顶出栈，也就是说，先进的数据元素后出去，后进的数据元素先出去。后进先出(LIFO last in fist out)
在这里插入图片描述

栈的操作

这里我们先创建一个栈的类，这里我们只是将基础的框架搭建了起来，并没有写具体的函数内容，后面再讲解的时候会具体说明。

# 第一个讲解我们使用的是顺序栈，具体的情况后面会有详细的介绍。
class SequenceStack:
    """顺序栈"""

    def __init__(self):
        """初始化"""
        self.stack_arr = []  # 栈空间，用列表
        self.top = 0         # 指针，指向栈顶
        self.maxsize = 10    # 设置栈的最大长度

    def push(self):
        """入栈"""
        pass

    def pop(self):
        """出栈"""
        pass

    def gethead(self):
        """得到栈顶的元素"""
        pass

    def isempty(self):
        """判断栈是否为空"""
        pass

    def size(self):
        """栈中的元素"""
        pass

    def next(self):
        """从栈顶遍历到栈底"""
        pass

    def clear(self):
        """清空栈"""
        pass

栈的初始化

栈的初始化就是创建一个空的栈，在本文章中栈的初始化就是创建sequencestack对象

stack = SequenceStack()

入栈

将新的元素添加到栈顶的位置，top指针向上移1
在这里插入图片描述
代码实现

    def push(self,arg):
        """入栈"""
        if self.top + 1 >= self.maxsize:
            print("栈已满，请重新选择操作")
            return 
        self.stack_arr.append(arg)
        self.top+=1

出栈

删除栈顶的数据元素
在这里插入图片描述
代码实现

    def pop(self):
        """出栈"""
        if self.top < 0:
            print("栈以空无法出栈")
            return
        self.top -= 1
        return self.stack_arr.pop()

取栈顶的元素

取栈顶的数据元素，但是不会影响栈的内容
在这里插入图片描述
代码实现

    def gethead(self):
        """得到栈顶的元素"""
        if self.top < 0:
            print("栈以空")
            return
        return self.stack_arr[self.top]

判断栈是否为空

判断栈是否为空
在这里插入图片描述

代码实现

    def isempty(self):
        """判断栈是否为空"""
        if len(self.stack_arr) == 0:
            return True
        else:
            return False

求栈中数据元素的个数

返回栈中的数据元素的个数
在这里插入图片描述
代码是实现

    def size(self):
        """栈中的元素"""
        return len(self.stack_arr)

遍历栈中的所有元素

依次访问栈中的元素
在这里插入图片描述
代码实现

    def next(self):
        """从栈顶遍历到栈底"""
        for i in self.stack_arr:
            print(i)

清空栈

清空栈中的所有内容
在这里插入图片描述

代码实现

    def clear(self):
        """清空栈"""
        self.stack_arr.clear()
        self.top = -1

栈的存储结构

顺序存储

顺序栈：利用一组地址连续的的存储单元依次存放自栈底到栈顶的所有数据元素，利用了数组实现，我们将数组索引为0的一端作为栈底，另一端作为栈顶。

代码实现

class SequenceStack:
    """顺序栈"""

    def __init__(self):
        """初始化"""
        self.stack_arr = []
        self.top = -1
        self.maxsize = 10  # 设置栈的最大长度

    def push(self, arg):
        """入栈"""
        if self.top + 1 >= self.maxsize:
            print("栈已满，请重新选择操作")
            return
        self.stack_arr.append(arg)
        self.top += 1

    def pop(self):
        """出栈"""
        if self.top < 0:
            print("栈以空无法出栈")
            return
        self.top -= 1
        return self.stack_arr.pop()

    def gethead(self):
        """得到栈顶的元素"""
        if self.top < 0:
            print("栈以空")
            return
        return self.stack_arr[self.top]

    def isempty(self):
        """判断栈是否为空"""
        if len(self.stack_arr) == 0:
            return True
        else:
            return False

    def size(self):
        """栈中的元素"""
        return len(self.stack_arr)

    def next(self):
        """从栈顶遍历到栈底"""
        for i in self.stack_arr:
            print(i)

    def clear(self):
        """清空栈"""
        self.stack_arr.clear()
        self.top = -1

链式存储

栈的链式存储结构称为链栈，利用的链表实现，链表中的每个元素由两个部分组成，一部分是存储本身的数据信息，一部分存储其直接后继的内存地址，分别叫做为数据域，地址域

链表和顺序表的功能都一样，我就不分开介绍了。因为存储结构的不同，导致代码内部的实现方法不同，大家仔细看一下代码实现的区别就行了。
链栈的基本结构
在这里插入图片描述
入栈出栈
在这里插入图片描述

代码实现

class LinkStack:
    def __init__(self):
        self.length = 0
        self.top = None

    def push(self, arg):
        """入栈"""
        self.top = Node(data=arg, next=self.top)
        self.length += 1

    def pop(self):
        """出栈"""
        if self.top == None:
            print("栈已空，无法删除元素")
            return
        x = self.top.data
        self.top = self.top.next
        self.length -= 1
        return x

    def gethead(self):
        """获取栈顶的元素"""
        if self.top == None:
            print("栈已空，无法删除元素")
            return
        return self.top.data

    def size(self):
        """求出栈中数据元素的个数"""
        return self.length

    def isEmpty(self):
        """判断栈是否为空"""
        return self.top == None

    def next(self):
        """遍历"""
        p = self.top
        while p != None:
            print(p.data)
            p = p.next

    def clear(self):
        """清空栈"""
        self.top = None
        self.length = 0

顺序栈和链栈的区别

顺序存储：存储空间预先分配，可能会出现空间闲置或溢出的现象，元素个数不能自由扩充。
链式存储：动态分配，不会出现闲置或者栈溢出的现象，数据元素可以自由扩充。

栈的实战题目

实战的题目这里选择的就是牛客网中系列题 👉传送门
在这里插入图片描述
由于篇章的限制，这里我就写一个比较经典的算法有效括号匹配，其余的题目我会出新的文章
有效括号序列

class SequenceStack:
	# 这个类可以选择上面的任意一个类，这里就不再进行重复了，主要说算法的实现方式
	pass

def brace_match(s):
    """验证括号是否合法"""
    if len(s) == 0:
        """当长度为0的时候直接返回"""
        return False
    match = {'}': '{', ']': '[', ')': '('}  # 右括号和左括号的键值队，用于后面的判断
    stack = SequenceStack()  # 创建栈
    for ch in s:
        if ch in {'{', '[', '('}:  # 只让左括号进栈
            stack.push(ch)
        else:
            if stack.isEmpty():
                return False
            elif stack.gethead() == match[ch]:
                # 当元素为右括号的时候，如果和栈顶的元素是一对括号的时候，栈顶的元素出栈
                stack.pop()  # stack_top() != match(ch)
            else:
                return False
    # 最后判断栈是否为空，如果栈为空则代表该序列是有效的括号序列
    # 如果栈非空则代表栈不为空
    if stack.isEmpty():
        return True
    else:
        return False

队列

队列是一种运算受限的线性表，元素的添加操作在表的一端进行，而另一端的删除在另一端进行，允许插入的一端称为队尾，允许删除的一端称为队头。

假设队列 q = [x1,x2,x3,,,,,xn] x1是队头，x2是队尾，队列中的数据的入队序列是x1,x2,x3,,,xn,队列也只能按这个顺序进行出队，队列的特点是先进入队列的先出来，后进队的必须等前面的数据出队完成以后才可以出队，所以队列也成为先进先出表(First in First out)
在这里插入图片描述

队列的操作

队列由由多种实现方式，这里就选三个比较有代表性的实现方式讲解’基础队列,循环队列，链队列，代码放在后面，在讲解的途中就在分别展示了

说明：循环队列也是用数组来实现的，只不过通过，一些算法实现了数组空间的复用，而且不用频繁的移动数组中的元素。

初始化队列
在这里插入图片描述

入队

在这里插入图片描述

出队

原队列
在这里插入图片描述

出队
顺序队列：就是将第一个元素返回出去，其余的元素向前移动一单位
循环队列：就是将队头的指针向后移动一个单位，里面的元素变为无效数据，等待覆盖
链队列：就是链表的删除，将头部指针front，指向队头的的指针移动到，指向队头后一个元素

在这里插入图片描述

遍历队列

顺序队列：将数组中的中的数据从开头一直遍历到最后
循环队列：创建一个临时的指针tmp该指针的位置和front指针一样,根据这个临时指针tmp的移动一次访问元素，直至临时指针和rear指针指向同一个位置的时候停止。
链队列：从头部直接遍历，循环调用next方法，直至到next==null的时候停止遍历

清空队列

清空队列就是将队列中的所有元素清空，让队列回归最初的状态

顺序队列：清空列表中的元素，并将rear指针回归到最初的位置
循环队列：清空列表中的元素，并将指针回归到最初的位置
链队列：将头部指针指向为null

队列的存储结构

顺序存储

基础队列的队头始终在数组的头部，每删除一个元素，整个队列就会向前移动一个单位，保证队列头始终在数组的第一个元素。这样我门就可以发现每执行删除操作(出队)，队列就要移动一次，这样会造成系统的额外开销。

class BaseQueue:
    def __init__(self):
        self.data = []
        self.front = 0
        self.rear = 0  # 记录队尾
        self.maxlength = 10  # 设置队列的最大长度

    def enqueue(self, arg):
        """入队"""
        if self.rear >= self.maxlength:
            print("队列已满")
            return
        self.rear += 1
        self.data.append(arg)

    def dequeue(self):
        """出队"""
        if self.rear == 0:
            print("队列已空")
            return
        self.rear -= 1
        return self.data.pop(0)

    def gethead(self):
        """获取队头"""
        if self.rear == 0:
            print("队列已空")
            return
        return self.data[0]

    def size(self):
        """返回队列的长度"""
        return self.rear

    def isEmpty(self):
        """判断队列是否为空"""
        return self.rear == 0

    def next(self):
        """遍历并输出"""
        p = self.rear
        for i in range(0, p):
            print(self.data[i])

    def clear(self):
        """清空队列"""
        self.data.clear()
        self.rear = 0

循环队列

循环队列，本质上还是使用数组进行实现，只是在逻辑上将首部、尾部连接起来，形成一个环状的循环队列，循环队列存储的元素个数比数组的长度少一，用来区分队满还是对待队空。

class LoopQueue:
    def __init__(self):
        self.maxsize = 10
        self.data = [0 for i in range(self.maxsize)]
        self.front = 0
        self.rear = 0

    def enqueue(self, arg):
        """入队"""
        if (self.rear + 1) % self.maxsize == self.front:
            print("队列已满，无法入队")
            return
        self.data[self.rear] = arg
        self.rear = (self.rear + 1) % self.maxsize

    def dequeue(self):
        """出队"""
        if self.isEmpty():
            print("队列已空，无法读取元素")
            return
        tmp = self.data[self.front]
        self.front = self.front + 1 % self.maxsize
        return tmp

    def gethead(self):
        """获取队头"""
        if self.isEmpty():
            print("队列已空，无法读取元素")
            return
        tmp = self.data[self.front]
        return tmp

    def size(self):
        """返回队列的长度"""
        if self.front <= self.rear:
            return self.rear - self.front
        else:
            return self.maxsize - (self.front - self.rear)

    def isEmpty(self):
        """判断队列是否为空"""
        return self.front == self.rear

    def next(self):
        """遍历并输出"""
        tmp = self.front
        while tmp < self.rear:
            print(self.data[tmp])
            tmp += 1

    def clear(self):
        """清空队列"""
        self.front = 0
        self.rear = 0

链式存储

队列的链存储结构称为链队列，它是限制在表头删除和表尾插入的单链表，由于需要在表尾进行插入操作，所以为操作方便除头指针外有必要再增加一个指向尾节点的指针
这个部分用到的链表的知识比较多，如果有不理解的可以去补补链表的知识

class Node(object):
    """节点类"""

    def __init__(self, data=None):
        self.data = data
        self.next = None


class LinkQueue:
    def __init__(self):
        self.length = 0
        self.front = None  # 头节点
        self.rear = None  # 尾节点

    def enqueue(self, arg):
        """入队"""
        node = Node(data=arg)
        if self.isEmpty():
            self.front = self.rear = node
            self.length += 1
        else:
            self.rear.next = node
            self.rear = node
            self.length += 1

    def dequeue(self):
        """出队"""
        if self.isEmpty():
            print("队列为空")
        else:
            resulst = self.front.data
            self.front = self.front.next
            self.length-=1
            return resulst

    def gethead(self):
        """获取队头"""
        if not self.isEmpty():
            return self.front.data
        else:
            print("队列为空")

    def size(self):
        """返回队列的长度"""
        return self.length

    def isEmpty(self):
        """判断队列是否为空"""
        if self.length == 0:
            return True
        else:
            return False

    def next(self):
        """遍历并输出"""
        tmp = self.front
        while tmp:
            print(tmp.data)
            tmp = tmp.next

    def clear(self):
        """清空队列"""
        self.front = None
        self.rear = None

队列实战题目

这两个题目我们再刚开始讲解的时候已经写过了
在这里插入图片描述

总结

  • 栈是限定再表尾进行插入或删除的线性表，又称后进先出的线性表，栈有两种存储表示，顺序栈，链式栈，链的主要操作是进栈和出栈，对于出栈和进栈操作判断栈满还是栈空
  • 队列是一种先进先出的线性表，它只允许在表的一端进行插入，而在另一端进行删除，队列也有两种存储结构，顺序存储，链式存储，队列的主要操作是进队和出队，对于顺序表需要注意队满和队空的情况
  • 栈和队列是在程序设计中被广泛使用的两种数据结构，其具体的应用场景都是与其展示方法和运算规则相互关联的。

写在最后 博主的能力有限，欢迎大家进行指正
如果大家想巩固自己的所学，希望大家多做一些实际的题目，结合实际能够有更好的理解。推荐大家去牛客网刷题 👉传送门

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

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

相关文章

快速发布windows上的web项目【免费内网穿透】

快速发布windows上的web项目【免费内网穿透】

快速发布windows上的web项目【免费内网穿透】 文章目录快速发布windows上的web项目【免费内网穿透】什么是cpolar内网穿透&#xff1f;概述1. 搭建一个静态Web站点1.1 下载演示站点1.2 本地运行演示站点1.3 本地浏览测试站点是否正常2. 注册并安装cpolar内网穿透3. 本地web站点…
阅读更多...
玩转 CSS 的艺术之美

玩转 CSS 的艺术之美

你将获得 深刻理解各种CSS原理 解构不为人知的CSS技巧 概念、技巧、场景三合一&#xff0c;实现“神奇”效果 强化吸收CSS知识体系&#xff0c;玩转各种神操作骚技巧 作者介绍 JowayYoung&#xff0c;资深前端工程师&#xff0c;目前就职于网易互动娱乐事业群&#xff0c…
阅读更多...
前端面试之道

前端面试之道

小册介绍 如果需要用一句话来介绍这本小册的话&#xff0c;「一年磨一剑」应该是最好的答案了。 为什么这样说呢&#xff1f;在出小册之前&#xff0c;我收集了大量的一线大厂面试题&#xff0c;通过大数据统计出了近百个常考知识点&#xff0c;然后根据这些知识点写成了这本…
阅读更多...
《深度学习》：CANN训练营_昇腾AI入门课学习笔记（第二章 TensorFlow模型迁移训练）

《深度学习》：CANN训练营_昇腾AI入门课学习笔记（第二章 TensorFlow模型迁移训练）

文章目录第二章 TensorFlow模型迁移&训练本章学习目标AI模型开发基础知识入门Python水平要求了解深度学习和神经网络了解TensorFlow AI框架了解基于CANN的模型开发流程&#xff08;重点&#xff09;TensorFlow AI模型迁移详解为什么要做模型迁移TensorFlow AI模型自动迁移详…
阅读更多...
【Python数据科学快速入门系列 | 10】Matplotlib数据分布图表应用总结

【Python数据科学快速入门系列 | 10】Matplotlib数据分布图表应用总结

这是机器未来的第59篇文章 原文首发地址&#xff1a;https://robotsfutures.blog.csdn.net/article/details/127484292 《Python数据科学快速入门系列》快速导航&#xff1a; 【Python数据科学快速入门系列 | 01】Numpy初窥——基础概念【Python数据科学快速入门系列 | 02】创…
阅读更多...
安卓讲课笔记3.3 相对布局

安卓讲课笔记3.3 相对布局

文章目录零、学习目标一、导入新课二、新课讲解&#xff08;一&#xff09;相对布局概述1、布局特点2、继承关系图3、常用属性&#xff08;1&#xff09;相对于父容器居中&#xff08;2&#xff09;相对于父容器对齐&#xff08;3&#xff09;相对于其它控件位置&#xff08;4&…
阅读更多...
牛客网经典Java面试常见题

牛客网经典Java面试常见题

个人主页&#xff1a;熬夜磕代码丶 作品专栏: 数据结构与算法 我变秃了&#xff0c;也变强了 给大家介绍一款程序员必备刷题平台——牛客网 点击注册一起刷题收获大厂offer吧 文章目录一、二叉搜索树与双向链表二、从尾到头打印链表三、调整数组奇数位于偶数前面四、删除链表…
阅读更多...
大数据毕业设计可视化大屏前后端项目分享

大数据毕业设计可视化大屏前后端项目分享

1、前言 很久没有分享过可视化大屏的项目了&#xff0c;距离上次分享基于Echarts的数据可视化大屏系统设计分享这篇可视化系统已经过去了整整一年有余。当时分享这篇博客没想到会收获这么多的阅读量&#xff0c;并且在刚发布的时候&#xff0c;还上了CSDN的博客热搜2&#xff…
阅读更多...
gcc环境下演示C语言变长数组

gcc环境下演示C语言变长数组

前言 &#x1f47b;作者&#xff1a;龟龟不断向前 &#x1f47b;简介&#xff1a;宁愿做一只不停跑的慢乌龟&#xff0c;也不想当一只三分钟热度的兔子。 &#x1f47b;专栏&#xff1a;C初阶知识点 &#x1f47b;工具分享&#xff1a; 刷题&#xff1a; 牛客网 leetcode笔记软…
阅读更多...
安全帽佩戴识别算法

安全帽佩戴识别算法

安全帽佩戴识别算法采用SuiJi-AI人工智能深度学习技术计算机智能视觉识别算法&#xff0c;且通过规模化的安全帽数据识别训练。安全帽佩戴识别算法借助现场已有的监控摄像头对监控画面中人员着装行为进行实时分析识别。假如检测人员不戴安全帽&#xff0c;SuiJiAi将立即记录和警…
阅读更多...
致敬第一个1024（第一次Java代码编程）

致敬第一个1024（第一次Java代码编程）

昨日&#xff0c;笔者刚刚下载好IDEA&#xff0c;今日&#xff0c;笔者将会实现第一次的Java代码&#xff01;&#xff01;信心满满&#xff01;&#xff01;下面请看笔者的代码吧&#xff01;&#xff01;骄傲的小心&#xff0c;已经澎湃&#xff01; 因此&#xff0c;本篇文…
阅读更多...
如何实现一个SQL解析器

如何实现一个SQL解析器

作者&#xff1a;vivo 互联网搜索团队- Deng Jie 一、背景 随着技术的不断的发展&#xff0c;在大数据领域出现了越来越多的技术框架。而为了降低大数据的学习成本和难度&#xff0c;越来越多的大数据技术和应用开始支持SQL进行数据查询。SQL作为一个学习成本很低的语言&#…
阅读更多...
【正点原子I.MX6U-MINI应用篇】5、嵌入式Linux在LCD上显示BMP、JPG、PNG图片

【正点原子I.MX6U-MINI应用篇】5、嵌入式Linux在LCD上显示BMP、JPG、PNG图片

一、BMP图像介绍与显示 我们常用的图片格式有很多&#xff0c;一般最常用的有三种&#xff1a;JPEG(或 JPG)、PNG、BMP和GIF。其中 JPEG(或JPG)、PNG以及 BMP 都是静态图片&#xff0c;而 GIF 则可以实现动态图片。 BMP(全称 Bitmap)是Window操作系统中的标准图像文件格式&am…
阅读更多...
计算机学院第五次ACM周赛题解

计算机学院第五次ACM周赛题解

目录 HF的智能小车车 Do you like Van game&#xff1f; 好姐姐的三角形 帮帮小陈 卷点 签个到就下班 现在是摸鱼时间 现在是摸鱼时间 PLUS HF的智能小车车 签到题目&#xff0c; #include<iostream>using namespace std;int main() {string arr;cin>>ar…
阅读更多...
学生会信息管理系统

学生会信息管理系统

1、项目介绍 学生会信息管理系统拥有两种角色&#xff1a;学生和管理员 学生&#xff1a;查看活动和新闻信息、发布活动、登录注册 管理员&#xff1a;公共新闻管理、用户管理、活动审核等 2、项目技术 后端框架&#xff1a; Servlet、mvc模式 前端技术&#xff1a;jsp、c…
阅读更多...
Linux(centos)安装Jenkins

Linux(centos)安装Jenkins

Jenkins 是一个开源的, 基于Java的自动服务器&#xff0c;提供了一种建立持续集成和持续交付(CI/CD)流水线的简单方法 。 持续集成 (CI)是DevOps实践中&#xff0c;团队成员定期将他们的代码更改提交到版本仓库, 然后运行自动化的构建和测试. 持续交付(CD)是自动构建、测试和部…
阅读更多...
【附源码】计算机毕业设计SSM物业管理系统设计

【附源码】计算机毕业设计SSM物业管理系统设计

项目运行 环境配置&#xff1a; Jdk1.8 Tomcat7.0 Mysql HBuilderX&#xff08;Webstorm也行&#xff09; Eclispe&#xff08;IntelliJ IDEA,Eclispe,MyEclispe,Sts都支持&#xff09;。 项目技术&#xff1a; SSM mybatis Maven Vue 等等组成&#xff0c;B/S模式 M…
阅读更多...
第九章 Ambari二次开发之自定义Flink服务 -- 自定义quiklinks链接

第九章 Ambari二次开发之自定义Flink服务 -- 自定义quiklinks链接

1、自定义quiklink链接功能概述 主要功能&#xff1a;用来配置第三方服务界面链接&#xff0c;如Yarn的管理界面。 服务可以通过在metainfo中加入一串quicklink的引用&#xff08;一串预定义的JSON字符串&#xff09;即可。ambari server能解析json文件并将其提供给UI&#xff…
阅读更多...
CSS 2 CSS 选择器 - 2 2.5 属性选择器

CSS 2 CSS 选择器 - 2 2.5 属性选择器

CSS 文章目录CSS2 CSS 选择器 - 22.5 属性选择器2.5.1 CSS [attribute] 选择器2.5.2 CSS [attribute"value"] 选择器2.5.3 CSS [attribute~"value"] 选择器2.5.4 CSS [attribute|"value"] 选择器2.5.5 CSS [attribute^"value"] 选择器…
阅读更多...
渠道数字化有什么好处？如何实现渠道数字化营销？

渠道数字化有什么好处？如何实现渠道数字化营销？

数字化转型是企业如今谋求商业升维的一种主要方式&#xff0c;即利用数字化技术和能力来赋能企业经营思维数字化、商业模式创新化&#xff0c;达到业务重构升级、实现业务的转型、创新&#xff0c;增长的目的。对于企业而言&#xff0c;数字化其实正是升维企业业务、企业流程及…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023