栈和队列的基本操作

最新推荐文章于 2025-12-29 22:37:36 发布
原创 最新推荐文章于 2025-12-29 22:37:36 发布 · 280 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #数据结构 #算法

栈和队列的基本操作

顺序栈

//顺序栈的基本操作：初始化、入栈、出栈、判断栈空、读栈顶元素、遍历
//2023年4月8日23:00 author:夜航星 
#include<iostream>
#include<iomanip>
#define MaxSize 50 
#define ElemType int 
using namespace std;
//栈的顺序存储类型描述 
typedef struct{
	ElemType data[MaxSize];
	int top; //栈顶指针 
}SqStack;

//初始化操作
void InitStack(SqStack &S)
{
	S.top = -1; //初始化栈顶指针 
}

//判断栈空 
bool StackEmpty(SqStack &S)
{
	if(S.top == -1) 
	{
		return true;
	}else
	{
		return false;
	}
}

//进栈 
bool Push(SqStack &S,ElemType x)
{
	if(S.top==MaxSize-1)
	{
		cout<<"栈满!请先出栈!"<<endl;
		return false;
	}else
	{
		S.data[++S.top] = x; //也就是S.top = S.top+1;S.data[S.top] = x; 
		return true;
	}
}

//出栈 
bool Pop(SqStack &S,ElemType &x)
{
	if(S.top==-1)
	{
		cout<<"栈空！请先入栈！"<<endl;
		return false;
	}else
	{
		S.data[S.top--] = x; //也就是S.data[S.top]=x;S.top = S.top-1; 
		return true;
	}
}

//读栈顶元素 
bool GetTop(SqStack &S,ElemType &x)
{
	if(S.top==-1)
	{
		cout<<"栈空，请先入栈！"<<endl;
		return false;
	}else
	{
		x = S.data[S.top];
		cout<<"栈顶元素为"<<x<<endl;
		return true;
	}
}

//栈内元素
void PrintStack(SqStack &S)
{
	int i ;
	if(StackEmpty(S))
	{
		cout<<"栈空，输出失败，请先入栈！"<<endl;
	}else
	{
		cout<<"栈中元素从栈顶到栈底依次为:";
		for(i= S.top;i>=0;i--)
		{
			cout<<S.data[i]<<" ";
		}	
	}
	
} 

//菜单
void ShowMenu()
{
	cout<<"*********1.初始化*******"<<endl;
	cout<<"*********2.入栈*********"<<endl;
	cout<<"*********3.出栈*********"<<endl;
	cout<<"*********4.读栈顶元素***"<<endl;
	cout<<"*********5.读栈内元素***"<<endl;
	cout<<"*********6.退出*********"<<endl;
} 

int main()
{
	SqStack S;
	ElemType x;
	int s;
	while(true)
	{
		ShowMenu();
		cout<<"请输入选项:";
		cin>>s; 
		switch(s)
		{
			case 1:
			{
				InitStack(S);
				cout<<"初始化成功！"<<endl;
				system("pause");//请按任意键继续 
				system("cls");//清屏操作 
				break;
			}
			case 2:
			{
				cout<<"请输入入栈的数值：";
				cin>>x;
				if(Push(S,x))
				{
					cout<<"入栈成功！"<<endl;
					PrintStack(S);
				}else
				{
					cout<<"入栈失败!"<<endl;
				}
				system("pause");
				system("cls");
				break;
			}
			case 3:
			{
				if(Pop(S,x))
				{
					cout<<"出栈成功！"<<endl;
					PrintStack(S);
				}else
				{
					cout<<"出栈失败！"<<endl;
				}
				system("pause");
				system("cls");
				break;
			}
			case 4:
			{
				if(GetTop(S,x))
				{
					cout<<"读取成功！"<<endl;
				}else
				{
					cout<<"读取失败！"<<endl;
				}
				system("pause");
				system("cls");
				break;
			}
			case 5:
			{
				PrintStack(S);
				system("pause");
				system("cls");
				break;
			}
			case 6:
			{
				cout<<"欢迎下次使用"<<endl;
				return 0;
			}	
		}
	}
}

运行结果如下：
顺序栈

链栈

//不带头结点链栈的基本操作
//链栈的初始化，入栈，出栈，读栈顶元素,栈中元素 
//2023年4月9日14:15:12 author：夜航星 
#include<iostream>
#include<iomanip>
#define ElemType int 
using namespace std;

//链栈的存储结构 
typedef struct StackNode{
	ElemType data;
	struct StackNode *next;
}StackNode,*LinkStack;

//初始化链栈
void InitStack(LinkStack &S)
{
	S = NULL;
	cout<<"初始化完毕!"<<endl;
} 

//入栈
void Push(LinkStack &S)
{
	cout<<"请输入入栈的数字:"<<endl;
	ElemType x;
	cin>>x;
	StackNode *p;//创建新结点 
	p = new StackNode;
	p->data = x;
	p->next = S;
	S = p;
	cout<<"入栈成功！"<<endl;
} 

//出栈
void Pop(LinkStack &S)
{
	if(S==NULL)
	{
		cout<<"栈空，请先入栈！"<<endl;
	}else
	{
		cout<<"出栈的数字为："<<S->data<<endl;
		StackNode *p = S;
		S = S->next;
		delete p;
		cout<<"出栈成功！"<<endl;	
	}		
} 

//读栈顶元素
void GetTop(LinkStack &S)
{
	if(S==NULL)
	{
		cout<<"栈空，请先入栈！"<<endl;
	}else
	{
		cout<<"栈顶的数字为："<<S->data<<endl;
	}		
} 

//遍历栈中元素
void Print(LinkStack S)
{
	if(S==NULL)
	{
		cout<<"栈空，请先入栈！"<<endl;
	}else
	{
		StackNode *p = S;
		cout<<"从栈顶到栈底的元素依次为:";
		while(p!=NULL)
		{
			cout<<p->data<<" ";
			p = p->next;
		}
	}
} 


//菜单
void ShowMenu()
{
	cout<<"*********1.初始化*******"<<endl;
	cout<<"*********2.入栈*********"<<endl;
	cout<<"*********3.出栈*********"<<endl;
	cout<<"*********4.读栈顶元素***"<<endl;
	cout<<"*********5.读栈内元素***"<<endl;
	cout<<"*********6.退出*********"<<endl;
} 

int main()
{
	LinkStack S;
	int s;
	while(true)
	{
		ShowMenu();
		cout<<"请输入选项:";
		cin>>s; 
		switch(s)
		{
			case 1:
			{
				InitStack(S);
				system("pause");//请按任意键继续 
				system("cls");//清屏操作 
				break;
			}
			case 2:
			{
				Push(S);
				system("pause");
				system("cls");
				break;
			}
			case 3:
			{
				Pop(S);
				system("pause");
				system("cls");
				break;
			}
			case 4:
			{
				GetTop(S);
				system("pause");
				system("cls");
				break;
			}
			case 5:
			{
				Print(S);
				system("pause");
				system("cls");
				break;
			}
			case 6:
			{
				cout<<"欢迎下次使用"<<endl;
				return 0;
			}
			default:
			{
				cout<<"欢迎下次使用"<<endl;
				return 0;
			}
		}
	}
}

运行结果如下：
链栈

循环队列

//循环队列的初始化、入队、出队、遍历、队长统计的基本操作
//2023年4月9日15:07:14 author:夜航星 
#include<iostream>
#include<iomanip>
#define ElemType int
#define MaxSize 100
using namespace std;

//队列的存储结构
typedef struct SqQueue{
	ElemType data[MaxSize];
	int front,rear;
}SqQueue; 

//队列的初始化
void InitQueue(SqQueue &Q)
{
	Q.front = Q.rear = 0;
	cout<<"队列初始化完成！"<<endl;
}
 
//入队
void EnQueue(SqQueue &Q)
{
	if((Q.rear+1)%MaxSize==Q.front)
	{
		cout<<"队列已满，请先出队！"<<endl;
	}else
	{
		cout<<"请输入入队的数字:";
		ElemType e;
		cin>>e;
		Q.data[Q.rear] = e;
		Q.rear = (Q.rear+1)%MaxSize;
		cout<<"入队成功！"<<endl;
	}
} 

//出队
void DeQueue(SqQueue &Q) 
{
	if(Q.front==Q.rear)
	{
		cout<<"队空，请先入队！"<<endl;
	}else
	{
		cout<<"出队的元素为:"<<Q.data[Q.front]<<endl;
		Q.front = (Q.front+1)%MaxSize;
		cout<<"出队成功！"<<endl;
	}
}

//遍历
void Print(SqQueue &Q)
{
	int i ;
	if(Q.front==Q.rear)
	{
		cout<<"队空，请先入队！"<<endl;
	}else
	{
		cout<<"队头到队尾的元素依次为:";
		for(i=Q.front;i!=Q.rear;i = (i+1)%MaxSize)
		{
			cout<<Q.data[i]<<" ";
		}
		cout<<endl;
	}
} 

//队长统计
void QueueLength(SqQueue &Q)
{
	cout<<"队列长度为："<<(Q.rear+MaxSize-Q.front)%MaxSize<<endl;
} 

//菜单
void ShowMenu()
{
	cout<<"*********1.初始化*******"<<endl;
	cout<<"*********2.入队*********"<<endl;
	cout<<"*********3.出队*********"<<endl;
	cout<<"*********4.遍历*********"<<endl;
	cout<<"*********5.队长统计*****"<<endl;
	cout<<"*********6.退出*********"<<endl;
} 


int main()
{
	SqQueue Q;
	int s;
	while(true)
	{
		ShowMenu();
		cout<<"请输入选项:";
		cin>>s; 
		switch(s)
		{
			case 1:
			{
				InitQueue(Q);
				system("pause");//请按任意键继续 
				system("cls");//清屏操作 
				break;
			}
			case 2:
			{
				EnQueue(Q);
				system("pause");
				system("cls");
				break;
			}
			case 3:
			{
				DeQueue(Q);
				system("pause");
				system("cls");
				break;
			}
			case 4:
			{
				Print(Q);
				system("pause");
				system("cls");
				break;
			}
			case 5:
			{
				QueueLength(Q);
				system("pause");
				system("cls");
				break;
			}
			case 6:
			{
				cout<<"欢迎下次使用"<<endl;
				return 0;
			}
			default:
			{
				cout<<"欢迎下次使用"<<endl;
				return 0;
			}
		}
	}
}

运行结果如下：
循环队列

链队

//链队(带头结点)的基本操作：初始化、入队、出队、遍历、队长统计
//注意与链栈区分:
//链栈无头结点，链队有头结点
//链栈入栈出栈操作使用链表的头指针
//链队入队使用尾指针，出队使用头指针 
//2023年4月9日15:53:56 author:夜航星 
#include<iostream>
#include<iomanip>
#define ElemType int
using namespace std;
//链队的存储结构 
//链队的单个结点 
typedef struct QNode{
	ElemType data;
	QNode *next;
}QNode,*QueuePtr;

//链队定义，包含一个头指针和尾指针
typedef struct{
	QueuePtr front;
	QueuePtr rear;
}LinkQueue; 

//链队的初始化
void InitQueue(LinkQueue &Q)
{
	Q.front = Q.rear = new QNode;	//头结点 
	Q.front->next =NULL;	
	cout<<"初始化完毕！"<<endl;
}

//入队
void EnQueue(LinkQueue &Q)
{
	QNode *p;
	p = new QNode;
	cout<<"请输入入队的数字:";
	cin>>p->data;
	p->next = Q.rear->next;
	Q.rear->next = p;
	Q.rear = p;
	cout<<"入队成功！"<<endl;
}

//出队
void DeQueue(LinkQueue &Q)
{
	if(Q.front->next==NULL)
	{
		cout<<"队空，请先入队!"<<endl;
	}else
	{
		QNode *p;
		p = Q.front->next;
		cout<<"出队的数值为:"<<p->data<<endl;
		Q.front->next = p->next;
		if(Q.rear==p)//最后一个元素被删，尾指针指向头结点（即头指针） 
		{
			Q.rear = Q.front;
		}
		delete p;
		cout<<"出队成功！"<<endl;
	}	
}

//遍历
void Print(LinkQueue Q)
{
	if(Q.front->next==NULL)
	{
		cout<<"队空，请先入队!"<<endl;
	}else
	{
		QNode *p;
		p = Q.front;
		cout<<"队中的元素为(从队头到队尾):";
		while(p->next!=NULL)
		{
			cout<<p->next->data<<" ";
			p = p->next;
		}
		cout<<"遍历完毕！"<<endl;
	}
}

//队长统计
void QueueLength(LinkQueue Q)
{
	if(Q.front->next==NULL)
	{
		cout<<"队空，请先入队!"<<endl;
	}else
	{
		QNode *p;
		p = Q.front;
		int i =0;
		while(p->next!=NULL)
		{
			p = p->next;
			i++;
		}
		cout<<"队的长度为:"<<i<<endl;
	}
}


//菜单
void ShowMenu()
{
	cout<<"*********1.初始化*******"<<endl;
	cout<<"*********2.入队*********"<<endl;
	cout<<"*********3.出队*********"<<endl;
	cout<<"*********4.遍历*********"<<endl;
	cout<<"*********5.队长统计*****"<<endl;
	cout<<"*********6.退出*********"<<endl;
}  

int main()
{
	LinkQueue Q;
	int s;
	while(true)
	{
		ShowMenu();
		cout<<"请输入选项:";
		cin>>s; 
		switch(s)
		{
			case 1:
			{
				InitQueue(Q);
				system("pause");//请按任意键继续 
				system("cls");//清屏操作 
				break;
			}
			case 2:
			{
				EnQueue(Q);
				system("pause");
				system("cls");
				break;
			}
			case 3:
			{
				DeQueue(Q);
				system("pause");
				system("cls");
				break;
			}
			case 4:
			{
				Print(Q);
				system("pause");
				system("cls");
				break;
			}
			case 5:
			{
				QueueLength(Q);
				system("pause");
				system("cls");
				break;
			}
			case 6:
			{
				cout<<"欢迎下次使用"<<endl;
				return 0;
			}
			default:
			{
				cout<<"欢迎下次使用"<<endl;
				return 0;
			}
		}
	}
}

运行结果如下：
链队

实验二 栈和队列基本操作的实现
陈的博客
12-06 1951
实验二 栈和队列基本操作的实现 实验目的 1.掌握栈、队列的思想及其存储实现 2.掌握栈、队列基本操作的实现 实验内容 1.编写函数，采用链式存储实现栈的初始化、入栈、出栈操作。 2.编写函数，采用顺序存储实现栈的初始化、入栈、出栈操作。 3.编写函数，采用链式存储实现队列的初始化、入队、出队操作。 4.编写函数，采用顺序存储实现队列的初始化、入队、出队操作。 5.编写一个主函数，在主函数中设计一个简单的菜单，分别调用上述函数。 #include<cstdio> #include<c
实验三 栈和队列的操作
Stonesaul的博客
10-11 2373
1．验证性实验2．（1）编程实现栈的以下基本操作：建栈，取栈顶元素，入栈，出栈。（2）编程实现队列的以下基本操作：建队列，取队头元素，入队，出队。3．（1）掌握栈的顺序存储结构、链式存储结构及其基本操作；（2）掌握队列的顺序存储结构、链式存储结构及其基本操作。
栈和队列基本操作
夏日漱石的博客
03-15 742
栈和队列基本操作
顺序栈和队列基本操作的实现
嵌入式阿齐Archie
05-07 1514
1．顺序栈的建立、取栈顶元素、入栈、出栈 #include <iostream> #include <stdlib.h> using namespace std; #define MAXSIZE 100 //顺序栈初始化时分配的存储空间长度 typedef struct{ //请把下面存储结构定义补充完整 char *base; //栈底指针,栈中元素为字符 char *top; //栈顶指针 int stacks...
栈和队列的基本实现
2303_80645930的博客
10-24 1027
栈和队列的底层基础和实现
栈与队列基本操作
m0_60777643的博客
01-30 4141
一.栈 1.顺序栈操作： 注：栈是一种只在头部进行操作的数据结构，不需要用到中间插入和删除，因此一般日常生活中用顺序表的形式来表示栈，操作可能会更方便。 ① 顺序栈的创建（初始化）： ...
栈和队列--基本操作
weixin_62580505的博客
02-07 1772
本节目标 学习栈的原理及基本实现 学习队列的原理及基本实现 栈： 一种特殊的线性表，其只允许在固定一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵循后进先出 LIFO （Last In First Out) 的原则。 压栈：栈的插入操作叫做进栈，压栈，入栈，入数据在栈顶。 出栈：栈的删除操作叫做出栈。 出数据在栈顶。 实现 1.利用顺序表实现，即使用尾插 + 尾删的方式实现 2.利用链表实现，即头尾皆可 但相对来说，顺序表的实.
数据结构：栈和队列(Stack & Queue)【详解】
热门推荐
UniqueUnit的博客
02-19 30万+
栈和队列知识框架 栈 一、栈的基本概念 1、栈的定义 栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。 栈顶（Top）：线性表允许进行插入删除的那一端。 栈底（Bottom）：固定的，不允许进行插入和删除的另一端。 空栈：不含任何元素的空表。 栈又称为先进先出（Last In First Out）的线性表，简称LIFO结构 2、栈的基本操作 InitStack(&S)：初始化一个空栈S。 StackEmpty(S)：
数据结构实验报告：栈和队列的基本操作及应用
2码8改
01-30 1万+
                                          Rails（***） 一、实验目的 1、掌握栈和队列的顺序存储结构和链式存储结构，以便在实际中灵活应用。 2、掌握栈和队列的特点，即后进先出和先进先出的原则。 3、掌握栈和队列的基本运算，如：入栈与出栈，入队与出队等运算在顺序存储结构和链式存储结构上的实现。 二、实验题目（已选题目四） 本次实验提供4个...
精选资源
实验二栈和队列基本操作.doc
10-08
实验二栈和队列基本操作 栈的基本操作 栈是一种线性表，遵循“先进后出”的原则，即最后进入栈的元素最先被删除。栈的基本操作包括入栈、出栈、取栈顶元素、遍历栈和清空栈等。 栈的顺序存储构造 栈的顺序存储...
武汉理工数据结构实验2栈和队列基本操作和应用[归类].pdf
10-28
武汉理工数据结构实验2栈和队列基本操作和应用 本实验旨在让学生熟练掌握顺序栈和队列的基本操作，并学习它们的应用。实验内容包括顺序栈和队列的基本操作演示程序的设计与实现，以及顺序栈和队列在不同进制之间的...
栈和队列基本操作及练习
08-05
在编程中，许多语言提供了内置的栈和队列数据结构，如Python的`collections.deque`可以作为双端队列，支持栈和队列操作，Java的`java.util.Stack`和`java.util.LinkedList`分别实现了栈和队列。此外，还可以自定义...
【读书笔记】Effective C++ 条款3：尽可能使用const
最新发布
m0_68617924的博客
12-29 695
同时，对于缓存，我们可能需要微小改动里面的值，即使改变了也依旧认为是const。的重载，const函数和非const函数绝大多数代码都是一样的，因此能否复用呢？在上面的代码中，const仅仅为保证str1指向的字符不被改变，但是我们可以将str1指向的内容改变。（注意：由于书本是比较老的，现在即便是c++98编译也会报错，但是由于是书中的例子，就讲究看一下吧）在这过程中，将const作为让编译器维护常量的口令，将编译器当作你的朋友。理论可以，但是调用非const就意味着需要冒着被改变的风险。
MS-F155_C（CAN 转光纤点对点模块）特点与功能介绍
2401_89785827的博客
12-26 1007
MS-F155_C 是工业级 CAN 总线转光纤传输模块，核心功能是实现 CAN 总线电信号与光纤光信号的双向透明转换，解决 CAN 总线远距离传输衰减、电磁干扰等问题。设备采用点对点通信模式，无需复杂配置，即插即用，支持 CAN1.0/CAN2.0 协议，符合 ISO/DIS 11898 规范，可将 CAN 总线通信距离延长至多模 2000 米、单模 20~40 公里，适配工业现场 CAN 设备远距离组网、数据采集与控制场景，尤其适用于恶劣工矿环境。
Android C++ 学习笔记 2
zhuguanlin121的博客
12-28 766
template.cpp template2.cpp exception.cpp exception2.cpp exception3.cpp exception4.cpp exception5.cpp exception6.cpp exception7.cpp exception8.cpp 19th_smartpointer person.cpp person2.cpp person3.cpp person4.cpp person5.cpp person6.cpp person7.cpp person8.c
【C++转GO】文件操作+协程和管道
saber_andlibert的博客
12-28 1040
协程比线程更加轻量级，因为协程只运行在用户态，表现上只是不同的函数相互转换，不是线程来回转换。另外，C++20也更新了协程，不同的是C++20的协程是无栈协程，相比GO的有栈协程更快。如果使用闭包，协程获取i不通过传参，而是通过捕获，那么当协程执行的时候，i的值可能已经是5了，所以打印结果与预期不符。Go协程是Go语言中的轻量级线程，由Go运行时管理。与传统线程相比，协程更加轻量，创建和销毁的开销更小。我们要知道，切换线程需要更换寄存器的内容，需要进行现场保护和CPU调度，需要由用户态到内核态的转换。
c++ 语言教程——17面向对象设计模式（六）
mwl0223的博客
12-25 877
本文介绍了三种行为型设计模式：访问者模式、中介者模式和解释器模式。访问者模式通过分离数据结构与操作，支持在不修改元素类的情况下添加新操作，适用于操作频繁变化的场景，但会破坏封装性。中介者模式通过引入中介对象来协调多个对象间的交互，降低耦合度，适用于需要集中管理复杂交互的系统。文章通过C++代码示例分别展示了访问者模式在商品计价场景的应用，以及中介者模式在聊天室系统中的实现，分析了各自的优缺点和适用场景。
栈和队列基本操作代码c++
01-02
### C++ 中栈和队列的基本操作代码示例 #### 栈的基本操作 在C++中，`std::stack` 提供了一系列用于管理栈内元素的方法。下面是一个简单的程序展示如何创建并操作一个栈： ```cpp #include <iostream> #include <stack> using namespace std; int main() { stack<int> stk; // 元素压入栈 stk.push(1); stk.push(2); stk.push(3); cout << "栈顶元素：" << stk.top() << endl; // 输出栈顶元素 // 移除栈顶元素 stk.pop(); cout << "移除后的栈顶元素：" << stk.top() << endl; // 获取栈的大小 cout << "当前栈的大小：" << stk.size() << endl; // 判断栈是否为空 if (!stk.empty()) { cout << "栈不是空的" << endl; } else { cout << "栈是空的" << endl; } return 0; } ``` 这段代码展示了向栈中添加新项(`push`)、访问顶部项目而不删除它(`top`)、弹出最上面的一项(`pop`)以及查询栈的状态（如其尺寸或是否为空）等功能[^1]。 #### 队列的基本操作 对于队列而言，在C++中有 `std::queue` 可以利用。这里有一个例子说明怎样初始化队列并对之实施常见的动作： ```cpp #include <iostream> #include <queue> using namespace std; int main(){ queue<string> q; // 插入到队尾 q.push("hello"); q.push("world"); // 访问队首元素 cout << "队首元素为：" << q.front() << endl; // 删除队首元素 q.pop(); // 查看新的队首元素 cout << "现在的队首元素为：" << q.front() << endl; // 检查队列是否为空 if(q.empty()){ cout << "队列已清空"; } else{ cout << "\n剩余元素数量:" << q.size(); } return 0; } ``` 此段代码演示了往队列里加入成员(`push`)、获取最先放入的那个成员而不会将其移走(`front`)、实际取出最早进入者(`pop`)还有检验队伍长度或是确认是否有任何待处理条目存在等行为[^2]。
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值