栈的实现（附含经典例题）

news2024/11/24 15:55:12

🍉博客主页：阿博历练记
📖文章专栏：数据结构与算法
🚍代码仓库：阿博编程日记
🍥欢迎关注：欢迎友友们点赞收藏+关注哦🌹

在这里插入图片描述

文章目录

    • 🍀前言
    • 🏄‍♂️数组栈
      • 🔍1.栈的结构框架
      • 🔍2.栈的初始化
      • 📢初始化数组指针为空
      • 📢top不同的初始化
      • 🔍3.栈的释放
      • 🔍4.栈的插入数据
      • 🔍5.栈的删除数据
      • 🔍6.取栈顶元素
      • 🔍7.栈的判空
      • 🔍8.返回栈空间元素的个数
      • 🚣Stack.h代码
      • 🏂Stack.c代码
      • 🏊‍♂️Test.c代码
      • 🧋代码效果展示
      • 🖋题目描述
      • 💡逻辑分析
      • ❌错误案例1
      • ❌错误案例2
      • ✔代码纠正

🍀前言

上期阿博给友友们介绍了双链表,下面阿博再来给友友们介绍一种新的数据结构栈.
栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In FirstOut）的原则。
在这里插入图片描述
在这里插入图片描述
压栈(进栈/入栈)：栈的插入操作。入数据在栈顶.
出栈：栈的删除操作。出数据也在栈顶.
栈的实现一般可以使用数组或者链表实现,相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小.

🏄‍♂️数组栈

🔍1.栈的结构框架

typedef struct  Stack
{
	STDataType* a;
	int top;                    //top指向栈顶的位置
	int capacity;
}ST;

友友们注意，这里top是标识栈顶的位置.

🔍2.栈的初始化

void  STInit(ST* pst)
{
	assert(pst);
	pst->a = NULL;
	pst->top = 0;    //如果我们初始化为0，top就指向栈顶元素的下一个位置，初始化为-1，top就是指向栈顶元素.
	pst->capacity = 0;
}

📢初始化数组指针为空

这里有很多友友们可能会有疑问：我们初始化的时候不应该给它在堆区上动态开辟一块空间吗，为什么初始化为空呢？
在这里插入图片描述

📢top不同的初始化

1.top初始化为0
在这里插入图片描述
2.top初始化为-1
在这里插入图片描述
⭐友友们注意了，对应不同的top值，栈的判空条件也是不一样的

1.top初始化为0，判空方式就是top == 0，这种方式是：top指向栈顶元素的下一个位置.
2.top初始化为-1，判空方式是top == -1,这种方式是：top指向栈顶元素的位置.

🔍3.栈的释放

void  STDestroy(ST* pst)
{
	assert(pst);
	free(pst->a);
	pst->a = NULL;
	pst->capacity = pst->top = 0;
}

🔍4.栈的插入数据

void  STPush(ST* pst, STDataType x)
{
	assert(pst);
	if (pst->top == pst->capacity)
	{
		int newcapacity = pst->capacity==0 ? 4 : pst->capacity * 2 ;
		STDataType* tmp = (STDataType*)realloc(pst->a, newcapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		pst->a = tmp;
		pst->capacity = newcapacity;
	} 
	pst->a[pst->top] = x;
	pst->top++;
}

友友们这里一定要注意当我们扩容成功之后，要把新地址传给我们的pst->a指针，如果忘记，那么它还是指向空的，因为我们的top就是指向栈顶元素的下一个位置，所以当我们插入数据的时候，直接就可以把数据放在下标为pst->top的位置上.

🔍5.栈的删除数据

void  STPop(ST* pst)
{
	assert(pst);
	assert(!STEmpty(pst));
	pst->top--;
}

这里要注意我们的栈为空之后，即top为0，就不要在减减top了

🔍6.取栈顶元素

STDataType  STTop(ST* pst)
{
	assert(pst);
	assert(!STEmpty(pst));
	return pst->a[pst->top - 1];
}

这里要注意的是我们的top是指向栈顶元素的下一个位置，所以当我们要取栈顶元素的时候，我们要让top减1，如果栈为空，就不要再取了，因为如果空栈，pst->top-1就变成-1了，就会出现越界访问.一定要注意越界在不同的编译器上它们的处理是不一样的，因为它们的版本可能不一样.在这里插入图片描述

🔍7.栈的判空

bool  STEmpty(ST* pst)
{
	assert(pst);
	return  pst->top == 0;
}

⛳⛳友友们注意这里不能写成return pst->top，这里我们要理解栈空的概念就是pst->top等于0为真，所以这里我们用一个判断式，如果我们那样写的话，pst->top等于0的话，0就是假，我们就需要反一下，return ！pst->top,就是当pst->top为0的时候，取非就为真，但是这样代码的可读性就不是很高了.

🔍8.返回栈空间元素的个数

int   STSize(ST* pst)
{
	assert(pst);
	return   pst->top;
}

如果我们把top初始化为-1，那么这里的size就是top+1.

🚣Stack.h代码

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>

typedef  int  STDataType;
typedef struct  Stack
{
	STDataType* a;
	int top;                    //top指向栈顶的位置
	int capacity;
}ST;

void  STInit(ST* pst);
void  STDestroy(ST* pst);
void  STPush(ST* pst,STDataType x);
STDataType  STTop(ST* pst);
void  STPop(ST* pst);
bool  STEmpty(ST* pst);
int   STSize(ST* pst);

🏂Stack.c代码

#define  _CRT_SECURE_NO_WARNINGS 1
#include"Stack.h"

void  STInit(ST* pst)
{
	assert(pst);
	pst->a = NULL;
	pst->top = 0;    //如果我们初始化为0，top就指向栈顶元素的下一个位置，初始化为-1，top就是指向栈顶元素.
	pst->capacity = 0;
}
void  STDestroy(ST* pst)
{
	assert(pst);
	free(pst->a);
	pst->a = NULL;
	pst->capacity = pst->top = 0;
}
void  STPush(ST* pst, STDataType x)
{
	assert(pst);
	if (pst->top == pst->capacity)
	{
		int newcapacity= pst->capacity==0 ? 4 : pst->capacity * 2 ;
		STDataType* tmp = (STDataType*)realloc(pst->a,newcapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		pst->a = tmp;
		pst->capacity = newcapacity;
	} 
	pst->a[pst->top] = x;
	pst->top++;
}
STDataType  STTop(ST* pst)
{
	assert(pst);
	assert(!STEmpty(pst));
	return pst->a[pst->top - 1];
}
bool  STEmpty(ST* pst)
{
	assert(pst);
	return  pst->top == 0;
}
void  STPop(ST* pst)
{
	assert(pst);
	assert(!STEmpty(pst));
	pst->top--;
}
int   STSize(ST* pst)
{
	assert(pst);
	return   pst->top;
}

🏊‍♂️Test.c代码

#define  _CRT_SECURE_NO_WARNINGS 1
#include"Stack.h"
void  TestStack1()
{
	ST st;
	STInit(&st);
	STPush(&st, 1);
	STPush(&st, 2);
	STPush(&st, 3);
	STPush(&st, 4);   
	while (!STEmpty(&st))     //因为栈是后进先出，所以我们不能随便访问
	{
		printf("%d ", STTop(&st));
		STPop(&st);
	}
	STDestroy(&st);
}                          

int main()
{
	TestStack1();
	return  0;
}

⭐⭐⭐友友们，这里注意一下

因为栈具有后入先出的特性，所以我们在访问的时候，不能随机访问.

🧋代码效果展示

在这里插入图片描述

🖋题目描述

在这里插入图片描述

💡逻辑分析

因为题目要保证左括号必须以正确的顺序闭合和每个右括号都有一个相同类型的左括号
在这里插入图片描述

❌错误案例1

typedef  int  STDataType;
typedef struct  Stack
{
	STDataType* a;
	int top;                    //top指向栈顶的位置
	int capacity;
}ST;

void  STInit(ST* pst);
void  STDestroy(ST* pst);
void  STPush(ST* pst,STDataType x);
STDataType  STTop(ST* pst);
void  STPop(ST* pst);
bool  STEmpty(ST* pst);
int   STSize(ST* pst);
void  STInit(ST* pst)
{
	assert(pst);
	pst->a = NULL;
	pst->top = 0;    //如果我们初始化为0，top就指向栈顶元素的下一个位置，初始化为-1，top就是指向栈顶元素.
	pst->capacity = 0;
}
void  STDestroy(ST* pst)
{
	assert(pst);
	free(pst->a);
	pst->a = NULL;
	pst->capacity = pst->top = 0;
}
void  STPush(ST* pst, STDataType x)
{
	assert(pst);
	if (pst->top == pst->capacity)
	{
		int newcapacity = pst->capacity==0 ? 4 : pst->capacity * 2 ;
		STDataType* tmp = (STDataType*)realloc(pst->a, newcapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		pst->a = tmp;
		pst->capacity = newcapacity;
	} 
	pst->a[pst->top] = x;
	pst->top++;
}
STDataType  STTop(ST* pst)
{
	assert(pst);
	assert(!STEmpty(pst));
	return pst->a[pst->top - 1];
}
bool  STEmpty(ST* pst)
{
	assert(pst);
	return  pst->top == 0;
}
void  STPop(ST* pst)
{
	assert(pst);
	assert(!STEmpty(pst));
	pst->top--;
}
int   STSize(ST* pst)
{
	assert(pst);
	return   pst->top;
}

bool isValid(char * s){
      ST q;
      STInit(&q);
      while(*s)
      {
      if(*s=='('||*s=='['||*s=='{')
      {
          STPush(&q,*s);
      }
      else
      {
          if(STTop(&q)=='('&&*s!=')'||STTop(&q)=='['&&*s!=']'||STTop(&q)=='{'&&*s!='}')
          {
              return  false;
          }
          else
          {
             STPop(&q);
          }
      }
      s++;
      }
      return  true;
}

友友们如果我们这里只输入了’[’，它入栈之后，s++走到\0的位置退出while循环，然后我们直接返回true了，这就会导致结果的错误，所以我们在退出while循环之后，我们需要判断一下栈是否为空，如果不为空，也返回false.

❌错误案例2

typedef  int  STDataType;
typedef struct  Stack
{
	STDataType* a;
	int top;                    //top指向栈顶的位置
	int capacity;
}ST;

void  STInit(ST* pst);
void  STDestroy(ST* pst);
void  STPush(ST* pst,STDataType x);
STDataType  STTop(ST* pst);
void  STPop(ST* pst);
bool  STEmpty(ST* pst);
int   STSize(ST* pst);
void  STInit(ST* pst)
{
	assert(pst);
	pst->a = NULL;
	pst->top = 0;    //如果我们初始化为0，top就指向栈顶元素的下一个位置，初始化为-1，top就是指向栈顶元素.
	pst->capacity = 0;
}
void  STDestroy(ST* pst)
{
	assert(pst);
	free(pst->a);
	pst->a = NULL;
	pst->capacity = pst->top = 0;
}
void  STPush(ST* pst, STDataType x)
{
	assert(pst);
	if (pst->top == pst->capacity)
	{
		int newcapacity = pst->capacity==0 ? 4 : pst->capacity * 2 ;
		STDataType* tmp = (STDataType*)realloc(pst->a, newcapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		pst->a = tmp;
		pst->capacity = newcapacity;
	} 
	pst->a[pst->top] = x;
	pst->top++;
}
STDataType  STTop(ST* pst)
{
	assert(pst);
	assert(!STEmpty(pst));
	return pst->a[pst->top - 1];
}
bool  STEmpty(ST* pst)
{
	assert(pst);
	return  pst->top == 0;
}
void  STPop(ST* pst)
{
	assert(pst);
	assert(!STEmpty(pst));
	pst->top--;
}
int   STSize(ST* pst)
{
	assert(pst);
	return   pst->top;
}

bool isValid(char * s){
      ST q;
      STInit(&q);
      while(*s)
      {
      if(*s=='('||*s=='['||*s=='{')
      {
          STPush(&q,*s);
      }
      else
      {
          if(STTop(&q)=='('&&*s!=')'||STTop(&q)=='['&&*s!=']'||STTop(&q)=='{'&&*s!='}')
          {
              return  false;
          }
          else
          {
             STPop(&q);
          }
      }
      s++;
      }
      if(!STEmpty(&q))
      return  false;
      return  true;
}

友友们，如果我们这里只输入了一个‘]’,它既没有入栈，然后它还调用了这个STTop函数，空栈就不能再用这个函数了，所以我们可以判断一下，如果栈为空，第一个肯定是右括号，这样它就不会有对应的左括号与它进行匹配，我们就直接返回false.栈不为空，我们才会进行后续的比较.

✔代码纠正

typedef  int  STDataType;
typedef struct  Stack
{
	STDataType* a;
	int top;                    //top指向栈顶的位置
	int capacity;
}ST;

void  STInit(ST* pst);
void  STDestroy(ST* pst);
void  STPush(ST* pst,STDataType x);
STDataType  STTop(ST* pst);
void  STPop(ST* pst);
bool  STEmpty(ST* pst);
int   STSize(ST* pst);
void  STInit(ST* pst)
{
	assert(pst);
	pst->a = NULL;
	pst->top = 0;    //如果我们初始化为0，top就指向栈顶元素的下一个位置，初始化为-1，top就是指向栈顶元素.
	pst->capacity = 0;
}
void  STDestroy(ST* pst)
{
	assert(pst);
	free(pst->a);
	pst->a = NULL;
	pst->capacity = pst->top = 0;
}
void  STPush(ST* pst, STDataType x)
{
	assert(pst);
	if (pst->top == pst->capacity)
	{
		int newcapacity = pst->capacity==0 ? 4 : pst->capacity * 2 ;
		STDataType* tmp = (STDataType*)realloc(pst->a, newcapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		pst->a = tmp;
		pst->capacity = newcapacity;
	} 
	pst->a[pst->top] = x;
	pst->top++;
}
STDataType  STTop(ST* pst)
{
	assert(pst);
	assert(!STEmpty(pst));
	return pst->a[pst->top - 1];
}
bool  STEmpty(ST* pst)
{
	assert(pst);
	return  pst->top == 0;
}
void  STPop(ST* pst)
{
	assert(pst);
	assert(!STEmpty(pst));
	pst->top--;
}
int   STSize(ST* pst)
{
	assert(pst);
	return   pst->top;
}

bool isValid(char * s){
      ST q;
      STInit(&q);
      while(*s)
      {
      if(*s=='('||*s=='['||*s=='{')
      {
          STPush(&q,*s);
      }
      else
      {
          if(STEmpty(&q))
          {
              return  false;
          }
          if(STTop(&q)=='('&&*s!=')'||STTop(&q)=='['&&*s!=']'||STTop(&q)=='{'&&*s!='}')
          {
              return  false;
          }
          else
          {
             STPop(&q);
          }
      }
      s++;
      }
      if(!STEmpty(&q))
      return  false;
      return  true;
}

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

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

相关文章

Redis系列--哨兵模式

Redis系列--哨兵模式

一、什么是哨兵 Redis Sentinel&#xff08;哨兵&#xff09;是一个分布式系统,你可以在一个架构中运行多个哨兵(sentinel) 进程, 这些进程使用 gossip协议(基于流行病传播方式的节点或者进程之间信息交换的协议&#xff0c;在分布式系统中被广泛使用) 来接收关于Master是否下线…
阅读更多...
MySQL5.0完全卸载教程

MySQL5.0完全卸载教程

一、停止MySQL服务 在系统服务中找到mysql服务并停止即可。 二、卸载mysql应用程序 在控制面板中卸载mysql应用程序 三、删除mysql文件夹 找到mysql一开始安装路径的文件夹&#xff0c;然后删除掉该整个文件夹。 四、删除注册表 &#xff08;1&#xff09;按winR键&#xff0c;…
阅读更多...
架构师日记-从代码到设计的性能优化指南 | 京东云技术团队

架构师日记-从代码到设计的性能优化指南 | 京东云技术团队

一 前言 服务性能是指服务在特定条件下的响应速度、吞吐量和资源利用率等方面的表现。据统计&#xff0c;性能优化方面的精力投入&#xff0c;通常占软件开发周期的10%到25%左右&#xff0c;当然这和应用的性质和规模有关。性能对提高用户体验&#xff0c;保证系统可靠性&…
阅读更多...
Java经典笔试题—day10

Java经典笔试题—day10

Java经典笔试题—day10 &#x1f50e;选择题&#x1f50e;编程题&#x1f95d;井字棋&#x1f95d;密码强度等级 &#x1f50e;结尾 &#x1f50e;选择题 (1)下列运算符合法的是&#xff08; &#xff09; A.&& B.<> C.if D.: A B. 泛型的标志, 例如 <T>…
阅读更多...
【iOS】—— AFNetworking源码学习

【iOS】—— AFNetworking源码学习

AFNetworking 文章目录 AFNetworkingAFHTTPSessionManager *sessionManager [AFHTTPSessionManager manager];请求过程1、调用请求序列化类中的requestWithMethod方法进行序列化处理2、调用dataTaskWithRequest来生成一个datatask任务 AFURLSessionMangerAFHTTPSessionManagerU…
阅读更多...
Linux服务器--基线检查

Linux服务器--基线检查

Linux服务器--基线检查 一、前言二、口令策略2.1 检查项—密码策略2.2 检查项—密码生存期2.3 检查项—检查密码生存期是否作用于每个用户 三、账号管理3.1 检查项—禁止存在UID相同的用户3.1 检查项—禁止存在空密码的帐户 四、认证授权4.1 检查项—登陆失败处理 五、文件权限…
阅读更多...
Pytroch 模型权重初始化

Pytroch 模型权重初始化

目录 1 概念 2 权值初始化方法 2.1 常数初始化 2.2 均匀分布初始化 2.3 正态分布初始化 2.4 Xavier 均匀分布 2.5 Xavier 正态分布 2.6 kaiming 均匀分布 2.7 kaiming 正态分布 2.8 单位矩阵初始化 2.9 正交初始化 2.10 稀疏初始化 2.11 狄拉克δ函数初始化 3 py…
阅读更多...
STC15通过内部BandGap电压值测量ADC外部输入电压

STC15通过内部BandGap电压值测量ADC外部输入电压

STC15通过内部BandGap参考电压值测量ADC通道外部输入电压 📜内部 BandGap参考电压值获取方式： 🎬通过VOFA图形化显示ADC值 🔧vofa+工具下载地址：https://www.vofa.plus/🌿验证对象：IAP15F2K61S2🌿时钟频率：11.0592MHz🌿波特率：115200🔖在通过STC-ISP烧录程序…
阅读更多...
XSS攻击以及java应对措施

XSS攻击以及java应对措施

文章目录 一. XSS攻击介绍1. 前端安全2. xss攻击简介3. xss的攻击方式 二. java应对xss攻击的解决方案1. 强制修改html敏感标签内容2. 利用过滤器过滤非法html标签 一. XSS攻击介绍 1. 前端安全 随着互联网的高速发展&#xff0c;信息安全问题已经成为企业最为关注的焦点之一…
阅读更多...
大脑的故事

大脑的故事

婴⼉的神经元是相互独⽴的、未连接的。在⼈⽣的头两年&#xff0c; 随着⼤脑细胞接收感觉信息&#xff0c;它们异常迅速地连接起来。 每⼀秒就有多达 200万个新连接&#xff08;突触&#xff09;在婴⼉的⼤脑⾥形成。两岁时&#xff0c;⼩孩⼦拥有超过 100万亿个突触&#xff…
阅读更多...
版本发布 | 科东软件Intewell-Win V2.1.0 release版本正式发布

版本发布 | 科东软件Intewell-Win V2.1.0 release版本正式发布

Intewell是由科东软件自主研发的工业嵌入式实时操作系统&#xff0c;具有高实时&#xff0c;确定性、高安全、高可靠、虚拟化等特点。Intewell系统源自于1990年诞生的“道”操作系统&#xff0c;至今已有30多年历史&#xff0c;已在多种严苛环境下运行检验&#xff0c;广泛商用…
阅读更多...
springboot+java超市收银管理系统idea

springboot+java超市收银管理系统idea

考虑到实际生活中在超市 POS 收银管理方面的需要以及对该系统认真的分析&#xff0c;将系统权限按管理员和员工这两类涉及用户划分。 Spring Boot 是 Spring 家族中的一个全新的框架&#xff0c;它用来简化Spring应用程序的创建和开发过程。也可以说 Spring Boot 能简化我们之…
阅读更多...
mmFormer:用于脑肿瘤分割的不完全多模态学习的多模态医学Transformer

mmFormer:用于脑肿瘤分割的不完全多模态学习的多模态医学Transformer

文章目录 mmFormer: Multimodal Medical Transformer for Incomplete Multimodal Learning of Brain Tumor Segmentation摘要本文方法Hybrid Modality-Specific EncoderModality-Correlated EncoderConvolutional DecoderAuxiliary Regularizer 实验结果 mmFormer: Multimodal …
阅读更多...
Kali-linux使用假冒令牌

Kali-linux使用假冒令牌

使用假冒令牌可以假冒一个网络中的另一个用户进行各种操作&#xff0c;如提升用户权限、创建用户和组等。令牌包括登录会话的安全信息&#xff0c;如用户身份识别、用户组和用户权限。当一个用户登录Windows系统时&#xff0c;它被给定一个访问令牌作为它认证会话的一部分。例如…
阅读更多...
师从英国两院院士|生物医学科研人员获CSC资助赴剑桥大学访学

师从英国两院院士|生物医学科研人员获CSC资助赴剑桥大学访学

L老师拟申报CSC公派访问学者项目&#xff0c;希望到欧洲TOP学校&#xff0c;师从知名教授&#xff0c;在自己的研究基础上取得进一步的进展和突破。最终我们获得世界名校剑桥大学的邀请函&#xff0c;导师是英国皇家科学学会及英国医学科学院两院院士&#xff0c;凭借这份硬气十…
阅读更多...
【SAP Abap】X-DOC：SE18/19 - SAP第四代增强概念理解

【SAP Abap】X-DOC：SE18/19 - SAP第四代增强概念理解

【SAP Abap】X-DOC&#xff1a;SE18/19 - SAP第四代增强概念理解 1、Tcode2、概念3、增强选项类型4、增强实现类型5、增强操作方式6、增强选项与增强实现关系7、增强实施建议 1、Tcode SE18&#xff1a;Business Add-Ins: Definitions&#xff08;增强点定义/查看&#xff09;…
阅读更多...
云平台电子班牌系统源码

云平台电子班牌系统源码

越来越多的教育单位加入了数字化校园和智慧校园建设行列。在不断探究、建设和实施的过程中&#xff0c;建立强大的、高扩展性的智慧教育管理平台被众多学校和教育单位所认同。智慧班牌是电子班牌信息发布系统的数据呈现端&#xff0c;也是智慧平台数据的采集工具之一。通过智慧…
阅读更多...
EtherCAT运动控制器在数控加工手轮随动中的应用之C++

EtherCAT运动控制器在数控加工手轮随动中的应用之C++

本文以正运动技术具备专用手轮接口的运动控制器ZMC408CE为例&#xff0c;介绍手轮、手轮的作用及原理、控制器手轮接口接线以及手轮程序配置。 上节讲解了使用正运动basic语言进行手轮应用配置&#xff0c;本节主要讲解C调用API函数库接口实现手轮配置。 01 手轮作用及原理 …
阅读更多...
第一个gin程序

第一个gin程序

一、下载并安装gin go get -u github.com/gin-gonic/gin二、第一个gin程序 package mainimport "github.com/gin-gonic/gin"func sayHello(c *gin.Context) {// 返回给客户端一个JSON格式的数据&#xff0c;其中HTTP状态码为200&#xff0c;表示处理成功c.JSON(200…
阅读更多...
成功的产品经理，应该了解一定的开发知识

成功的产品经理，应该了解一定的开发知识

产品经理在互联网产品开发中扮演着协调和推动的重要角色。然而&#xff0c;由于产品经理没有直接的实际权力&#xff0c;与开发团队合作时可能会遇到各种挑战。当你给开发人员分配任务时&#xff0c;他们可能会找各种借口推脱工作。 在项目开发中&#xff0c;所有成员必须共同…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023