数据结构学习笔记（三） 树形结构之遍历对称序线索二叉树

最新推荐文章于 2023-05-07 22:24:09 发布
最新推荐文章于 2023-05-07 22:24:09 发布
阅读量715 收藏
点赞数 2
分类专栏： 数据结构学习笔记 文章标签： 数据结构 遍历 线索二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Clementina_123/article/details/79139034
版权

以下是前序、对称序以及后序遍历对称序线索二叉树的算法。
用于遍历的二叉树如下图：
这里写图片描述

一、前序遍历对称序线索二叉树。

#include<iostream>
#define MaxSize 10
using namespace std;

//变量定义与声明
typedef char datatype;
typedef struct node
{
    datatype data;
    struct node *lchild,*rchild;
    int ltag,rtag;
}ThrBTnode,*ThrBinTree;
typedef struct
{
    ThrBTnode* S[MaxSize];
    int top;
}SeqStack;
SeqStack ST;
ThrBinTree root;
ThrBTnode* nodes[10];

//置空栈
void ClearStack(SeqStack &ST)
{
    ST.top=-1;
}

//栈的推入
void push(SeqStack &ST,ThrBTnode *p)
{
    if(ST.top>=MaxSize-1)
        cout<<"overflow!"<<endl;
    else
        ST.S[++ST.top]=p;
}

//栈的弹出
ThrBTnode* pop(SeqStack &ST,ThrBTnode *p)
{
    if(ST.top==-1)
        cout<<"underflow!"<<endl;
    else
        p=ST.S[ST.top--];
    return p;
}

//判栈空否
int StackEmpty(SeqStack ST)
{
    if(ST.top==-1)
        return 1;
    else
        return 0;
}

//构建一棵二叉树
ThrBinTree Create(ThrBinTree root)
{
    ThrBTnode *A=new ThrBTnode;
    ThrBTnode *B=new ThrBTnode;
    ThrBTnode *C=new ThrBTnode;
    ThrBTnode *D=new ThrBTnode;
    ThrBTnode *E=new ThrBTnode;
    ThrBTnode *F=new ThrBTnode;
    ThrBTnode *G=new ThrBTnode;
    ThrBTnode *H=new ThrBTnode;
    ThrBTnode *I=new ThrBTnode;
    ThrBTnode *J=new ThrBTnode;

    A->data='A';
    B->data='B';
    C->data='C';
    D->data='D';
    E->data='E';
    F->data='F';
    G->data='G';
    H->data='H';
    I->data='I';
    J->data='J';

    A->lchild=B;
    A->rchild=C;
    A->ltag=A->rtag=0;

    B->lchild=D;
    B->rchild=E;
    B->ltag=B->rtag=0;

    E->lchild=H;
    E->rchild=I;
    E->ltag=E->rtag=0;

    C->lchild=F;
    C->rchild=G;
    C->ltag=C->rtag=0;

    F->lchild=NULL;
    F->rchild=J;
    F->ltag=F->rtag=0;

    D->lchild=D->rchild=NULL;
    D->ltag=D->rtag=0;

    H->lchild=H->rchild=NULL;
    H->ltag=H->rtag=0;

    I->lchild=I->rchild=NULL;
    I->ltag=I->rtag=0;

    J->lchild=J->rchild=NULL;
    J->ltag=J->rtag=0;

    G->lchild=G->rchild=NULL;
    G->ltag=G->rtag=0;

    root=A;

    nodes[0]=A;
    nodes[1]=B;
    nodes[2]=C;
    nodes[3]=D;
    nodes[4]=E;
    nodes[5]=F;
    nodes[6]=G;
    nodes[7]=H;
    nodes[8]=I;
    nodes[9]=J;

    return root;
}

//线索化二叉树
void inOrderThreadTree(ThrBinTree root)
{
    ThrBTnode *pre,*p;
    ClearStack(ST);
    p=root;
    pre=NULL;
    while(p!=NULL||!StackEmpty(ST))
    {
        if(p!=NULL)
        {
            push(ST,p);
            p=p->lchild;
        }
        else
        {
            p=pop(ST,p);
            if(p->lchild==NULL)
            {
                p->lchild=pre;
                p->ltag=1;
            }
            if(pre!=NULL&&pre->rchild==NULL)
            {
                pre->rchild=p;
                pre->rtag=1;
            }
            pre=p;
            p=p->rchild;
        }
    }
    if(pre!=NULL)
            pre->rtag=1;
}

//找指定结点的前序后继
ThrBTnode* FindPreSuccessor(ThrBTnode *p)
{
    ThrBTnode *q;
    if(p->ltag==0)
    {
        q=p->lchild;
        return q;
    }else{
        q=p;
    }
    while(q->rtag==1&&q->rchild!=NULL)
        q=q->rchild;
    q=q->rchild;
    return q;
}

//前序遍历对称序线索二叉树
void PreOrderTraThrTree(ThrBinTree root)
{
    ThrBTnode *p=root;
    cout<<p->data<<" ";
    while(p->rchild!=NULL)
    {
        p=FindPreSuccessor(p);
        cout<<p->data<<" ";
    }
    cout<<endl;
}

//测试函数
int main()
{
    root=Create(root);
    inOrderThreadTree(root);
    cout<<"前序遍历对称序线索树结果为："<<endl;
    PreOrderTraThrTree(root);
    return 0;
}

二、对称序遍历对称序线索二叉树。

#include<iostream>
#define MaxSize 10
using namespace std;

//变量定义与声明
typedef char datatype;
typedef struct node
{
    datatype data;
    struct node *lchild,*rchild;
    int ltag,rtag;
}ThrBTnode,*ThrBinTree;
typedef struct
{
    ThrBTnode* S[MaxSize];
    int top;
}SeqStack;
SeqStack ST;
ThrBinTree root;
ThrBTnode* nodes[10];

//置空栈
void ClearStack(SeqStack &ST)
{
    ST.top=-1;
}

//栈的推入
void push(SeqStack &ST,ThrBTnode *p)
{
    if(ST.top>=MaxSize-1)
        cout<<"overflow!"<<endl;
    else
        ST.S[++ST.top]=p;
}

//栈的弹出
ThrBTnode* pop(SeqStack &ST,ThrBTnode *p)
{
    if(ST.top==-1)
        cout<<"underflow!"<<endl;
    else
        p=ST.S[ST.top--];
    return p;
}

//判栈空否
int StackEmpty(SeqStack ST)
{
    if(ST.top==-1)
        return 1;
    else
        return 0;
}

//构建一棵二叉树
ThrBinTree Create(ThrBinTree root)
{
    ThrBTnode *A=new ThrBTnode;
    ThrBTnode *B=new ThrBTnode;
    ThrBTnode *C=new ThrBTnode;
    ThrBTnode *D=new ThrBTnode;
    ThrBTnode *E=new ThrBTnode;
    ThrBTnode *F=new ThrBTnode;
    ThrBTnode *G=new ThrBTnode;
    ThrBTnode *H=new ThrBTnode;
    ThrBTnode *I=new ThrBTnode;
    ThrBTnode *J=new ThrBTnode;

    A->data='A';
    B->data='B';
    C->data='C';
    D->data='D';
    E->data='E';
    F->data='F';
    G->data='G';
    H->data='H';
    I->data='I';
    J->data='J';

    A->lchild=B;
    A->rchild=C;
    A->ltag=A->rtag=0;

    B->lchild=D;
    B->rchild=E;
    B->ltag=B->rtag=0;

    E->lchild=H;
    E->rchild=I;
    E->ltag=E->rtag=0;

    C->lchild=F;
    C->rchild=G;
    C->ltag=C->rtag=0;

    F->lchild=NULL;
    F->rchild=J;
    F->ltag=F->rtag=0;

    D->lchild=D->rchild=NULL;
    D->ltag=D->rtag=0;

    H->lchild=H->rchild=NULL;
    H->ltag=H->rtag=0;

    I->lchild=I->rchild=NULL;
    I->ltag=I->rtag=0;

    J->lchild=J->rchild=NULL;
    J->ltag=J->rtag=0;

    G->lchild=G->rchild=NULL;
    G->ltag=G->rtag=0;

    root=A;

    nodes[0]=A;
    nodes[1]=B;
    nodes[2]=C;
    nodes[3]=D;
    nodes[4]=E;
    nodes[5]=F;
    nodes[6]=G;
    nodes[7]=H;
    nodes[8]=I;
    nodes[9]=J;

    return root;
}

//线索化二叉树
void inOrderThreadTree(ThrBinTree root)
{
    ThrBTnode *pre,*p;
    ClearStack(ST);
    p=root;
    pre=NULL;
    while(p!=NULL||!StackEmpty(ST))
    {
        if(p!=NULL)
        {
            push(ST,p);
            p=p->lchild;
        }
        else
        {
            p=pop(ST,p);
            if(p->lchild==NULL)
            {
                p->lchild=pre;
                p->ltag=1;
            }
            if(pre!=NULL&&pre->rchild==NULL)
            {
                pre->rchild=p;
                pre->rtag=1;
            }
            pre=p;
            p=p->rchild;
        }
    }
    if(pre!=NULL)
            pre->rtag=1;
}

//对称序遍历对称序线索树
void inOrderTraThrTree(ThrBinTree root)
{
    ThrBTnode *p=root;
    while(p!=NULL)
    {
        while(p->ltag==0)
            p=p->lchild;
        cout<<p->data<<" ";
        while(p->rtag==1&&p->rchild!=NULL)
        {
            p=p->rchild;
            cout<<p->data<<" ";
        }
        p=p->rchild;
    }
}

//逐个结点打印线索关系
void Print(ThrBinTree root)
{
    for(int i=0;i<10;i++)
    {
        cout<<"对于结点"<<nodes[i]->data<<"有："<<endl;
        if((nodes[i]->lchild==NULL)||(nodes[i]->rchild==NULL))
        {
            if(nodes[i]->lchild==NULL&&nodes[i]->rchild==NULL)
            {
                cout<<"lchild为：  NULL"<<endl;
                cout<<"rchild为：  NULL"<<endl;
            }
            else if(nodes[i]->rchild==NULL&&nodes[i]->lchild!=NULL)
            {
                cout<<"lchild为：  "<<nodes[i]->lchild->data<<endl;
                cout<<"rchild为：  NULL"<<endl;
            }
            else if(nodes[i]->lchild==NULL&&nodes[i]->rchild!=NULL)
            {
                cout<<"lchild为：  NULL"<<endl;
                cout<<"rchild为：  "<<nodes[i]->rchild->data<<endl;
            }
            cout<<"ltag为：  "<<nodes[i]->ltag<<endl;
            cout<<"rtag为：  "<<nodes[i]->rtag<<endl;
            continue;
        }
        cout<<"lchild为：  "<<nodes[i]->lchild->data<<endl;
        cout<<"rchild为：  "<<nodes[i]->rchild->data<<endl;
        cout<<"ltag为：  "<<nodes[i]->ltag<<endl;
        cout<<"rtag为：  "<<nodes[i]->rtag<<endl;
    }
}

//测试函数
int main()
{
    root=Create(root);
    cout<<"对称序线索化二叉树结果为："<<endl;
    inOrderThreadTree(root);
    Print(root);
    cout<<"对称序遍历对称序线索树结果为："<<endl;
    inOrderTraThrTree(root);
    return 0;
}

三、后序遍历对称序线索二叉树。

#include<iostream>
#define MaxSize 10
using namespace std;

//变量定义与声明
typedef char datatype;
typedef struct node
{
    datatype data;
    struct node *lchild,*rchild;
    int ltag,rtag;
}ThrBTnode,*ThrBinTree;
typedef struct
{
    ThrBTnode* S[MaxSize];
    int top;
}SeqStack;
SeqStack ST,STPost;
ThrBinTree root;
ThrBTnode* nodes[10];

//置空栈
void ClearStack(SeqStack &ST)
{
    ST.top=-1;
}

//栈的推入
void push(SeqStack &ST,ThrBTnode *p)
{
    if(ST.top>=MaxSize-1)
        cout<<"overflow!"<<endl;
    else
        ST.S[++ST.top]=p;
}

//栈的弹出
ThrBTnode* pop(SeqStack &ST,ThrBTnode *p)
{
    if(ST.top==-1)
        cout<<"underflow!"<<endl;
    else
        p=ST.S[ST.top--];
    return p;
}

//判栈空否
int StackEmpty(SeqStack ST)
{
    if(ST.top==-1)
        return 1;
    else
        return 0;
}

//构建一棵二叉树
ThrBinTree Create(ThrBinTree root)
{
    ThrBTnode *A=new ThrBTnode;
    ThrBTnode *B=new ThrBTnode;
    ThrBTnode *C=new ThrBTnode;
    ThrBTnode *D=new ThrBTnode;
    ThrBTnode *E=new ThrBTnode;
    ThrBTnode *F=new ThrBTnode;
    ThrBTnode *G=new ThrBTnode;
    ThrBTnode *H=new ThrBTnode;
    ThrBTnode *I=new ThrBTnode;
    ThrBTnode *J=new ThrBTnode;

    A->data='A';
    B->data='B';
    C->data='C';
    D->data='D';
    E->data='E';
    F->data='F';
    G->data='G';
    H->data='H';
    I->data='I';
    J->data='J';

    A->lchild=B;
    A->rchild=C;
    A->ltag=A->rtag=0;

    B->lchild=D;
    B->rchild=E;
    B->ltag=B->rtag=0;

    E->lchild=H;
    E->rchild=I;
    E->ltag=E->rtag=0;

    C->lchild=F;
    C->rchild=G;
    C->ltag=C->rtag=0;

    F->lchild=NULL;
    F->rchild=J;
    F->ltag=F->rtag=0;

    D->lchild=D->rchild=NULL;
    D->ltag=D->rtag=0;

    H->lchild=H->rchild=NULL;
    H->ltag=H->rtag=0;

    I->lchild=I->rchild=NULL;
    I->ltag=I->rtag=0;

    J->lchild=J->rchild=NULL;
    J->ltag=J->rtag=0;

    G->lchild=G->rchild=NULL;
    G->ltag=G->rtag=0;

    root=A;

    nodes[0]=A;
    nodes[1]=B;
    nodes[2]=C;
    nodes[3]=D;
    nodes[4]=E;
    nodes[5]=F;
    nodes[6]=G;
    nodes[7]=H;
    nodes[8]=I;
    nodes[9]=J;

    return root;
}

//线索化二叉树
void inOrderThreadTree(ThrBinTree root)
{
    ThrBTnode *pre,*p;
    ClearStack(ST);
    p=root;
    pre=NULL;
    while(p!=NULL||!StackEmpty(ST))
    {
        if(p!=NULL)
        {
            push(ST,p);
            p=p->lchild;
        }
        else
        {
            p=pop(ST,p);
            if(p->lchild==NULL)
            {
                p->lchild=pre;
                p->ltag=1;
            }
            if(pre!=NULL&&pre->rchild==NULL)
            {
                pre->rchild=p;
                pre->rtag=1;
            }
            pre=p;
            p=p->rchild;
        }
    }
    if(pre!=NULL)
            pre->rtag=1;
}

//找指定结点的后序前驱
ThrBTnode* FindPostPrecursor(ThrBTnode *p)
{
    ThrBTnode *q;
    if(p->rtag==0)
    {
        q=p->rchild;
        return q;
    }else{
        q=p;
    }
    while(q->ltag==1&&q->lchild!=NULL)
        q=q->lchild;
    q=q->lchild;
    return q;
}

//后序遍历对称序线索二叉树
void PostOrderTraThrTree(ThrBinTree root)
{
    ClearStack(STPost);
    ThrBTnode *p=root;
    push(STPost,p);
    while(p->lchild!=NULL)
    {
        p=FindPostPrecursor(p);
        push(STPost,p);
    }
    while(!StackEmpty(STPost))
        cout<<pop(STPost,p)->data<<" ";
    cout<<endl;
}

//测试函数
int main()
{
    root=Create(root);
    inOrderThreadTree(root);
    cout<<"后序遍历对称序线索树结果为："<<endl;
    PostOrderTraThrTree(root);
    return 0;
}
沫沫就沫沫好了
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C/C++数据结构实现二叉树的遍历与线索二叉树
12-26
使用C/C++实现二叉树的构造、先序遍历、中序遍历、后序遍历、中序线索化、线索化后的中序遍历等基本树操作。
数据结构课件：第6章 树和二叉树2遍历二叉树和线索二叉树.pptx
05-31
数据结构课件：第6章 树和二叉树2遍历二叉树和线索二叉树.pptx
C语言数据结构之线索二叉树及其遍历
08-29
主要介绍了C语言数据结构之线索二叉树及其遍历的相关资料,为了加快查找节点的前驱和后继。对二叉树的线索化就是对二叉树进行一次遍历，在遍历的过程中检测节点的左右指针是否为空，如果是空，则将他们改为指向前驱和后继节点的线索，需要的朋友可以参考下
数据结构树和二叉树遍历二叉树和线索二叉树PPT学习教案.pptx
10-05
数据结构树和二叉树遍历二叉树和线索二叉树PPT学习教案.pptx
剑指28：对称的二叉树——递归+使用先序遍历和对称先序遍历
turry的博客
04-08 544
题目描述请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。Tips:先序遍历(根左右)  对称先序遍历(根右左) 依次对比 完成对称比较/* struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; TreeNode(...
对称的二叉树【树的遍历】
小学生蒟蒻
07-04 189
题 思路：dfs遍历n个节点，判断是否对称：
python数据结构——二叉树（一）遍历方法
野猫炫的博客
11-03 2443
对称序遍历得到“a - b x c / d + e”，基本上是相应数学表达式的中缀表示，只是缺少表示计算顺序的括号(未能表达正确的计算顺序)。若二叉树中最多只有最下面两层的节点的度数可以小于2，并且最下面一层的叶节点都依次排列在该层最左边的位置上，则这样的二叉树称为。后根序遍历得到的序列是“ a b - c d / e + x”，正是该表达式的后缀表示形式(即其波兰表示法的形式)。在一棵二叉树中,如果所有分支节点都有左孩子节点和右孩子节点，并且叶节点都集中在二叉树的最下一层，这样的二叉树称为。
Leetcode 对称二叉树 二叉树的层次遍历 翻转二叉树
JIE25的博客
03-23 186
对称二叉树 什么是对称二叉树？ 如上图所示 判断一个二叉树是否为对称二叉树？ 判断步骤：1.头节点的左子树节点是否等于右子树节点； 2.左子树节点的左子树节点是否等于右子树节点的右子树节点； 3.左子树节点的右子树节点是否等于右子树节点的左子树节点； 是否等于的情况可以分为四种类型： 1.left == null && right == null; true 2.left != null &am...
详解二叉树的层序遍历以及各种翻转方式，对称二叉树判断的Python实现（包含源代码）
hanyu1209的博客
05-07 257
层序遍历一个二叉树。就是从左到右一层一层的去遍历二叉树。这种遍历的方式和我们之前讲过的都不太一样。需要借用一个辅助数据结构即队列来实现，队列先进先出，符合一层一层遍历的逻辑，而用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。而这种层序遍历方式就是图论中的广度优先遍历，只不过我们应用在二叉树上。使用队列实现二叉树广度优先遍历，动画如下：##Python代码。
面试题28-对称的二叉树
weixin_42127177的博客
02-18 553
题目 请实现一个函数，用来判断一棵二叉树是不是对称的。如果一棵二叉树和它的镜像一样，那么它是对称的。 解题思路 我们定义一种对称的遍历算法，即先遍历父节点，再遍历它的右子节点，最后遍历它的左子节点。 通过比较二叉树的前序遍历序列和对称前序遍历序列来判断二叉树是不是对称的。如果两个序列是一样的，那么二叉树就是对称的。 class Solution { public: bool isSymmetric(TreeNode* root) { return isSymmetric(root,
C语言数据结构之二叉树的非递归后序遍历算法
08-29
主要介绍了C语言数据结构之二叉树的非递归后序遍历算法的相关资料,希望通过本文能帮助到大家，让大家实现这样的功能，需要的朋友可以参考下
数据结构实验报告6-树-二叉树的遍历算法-实验内容及要求.docx
07-06
编写程序，用先序递归遍历法建立二叉树的二叉链表存储结构，然后输出其先序、中序、后序以及层次遍历结点访问次序。其中层次遍历的实现需使用循环队列。二叉树结点数据类型建议选用字符类型
数据结构二叉树的遍历 二叉树的深度 二叉树的某结点层次 二叉树结点数
08-27
数据结构二叉树的遍历 二叉树的深度 二叉树的某结点层次 二叉树结点数
哈工大数据结构实验二_树形结构及其应用
03-26
实验题目：二叉树存储结构的建立、遍历和应用 实验内容： 树型结构的遍历是树型结构算法的基础，本实验要求编写程序演示二叉树 的存储结构的建立方法、遍历过程以及应用。 实验要求： 1．至少采用两种方法，编写建立...
JavaScript数据结构之二叉树的遍历算法示例
10-20
主要介绍了JavaScript数据结构之二叉树的遍历算法,简单介绍了javascript实现数据结构中二叉树的中序遍历、先序遍历及后序遍历方法与相关使用技巧,需要的朋友可以参考下
数据结构课程设计报告-二叉树的遍历.docx
03-07
数据结构课程设计报告-二叉树的遍历.docx
数据结构二叉树：从先序和中序遍历结果恢复二叉树
05-25
题目：从先序和中序遍历结果恢复二叉树。 分析：输入先序序列和中序序列，从而得到一个完整的二叉树。 步骤：1.找到root，前序遍历的第一节点G就是root。 2.继续观察前序遍历GDAFEMHZ，除了知道G是root，剩下的节点...
山东建筑大学计算机学院数据结构实验二：二叉树的遍历
03-31
4、实现输出以上二叉树先序、中序和后序遍历序列中第k个数据元素的操作； 5、判断二叉树是否是完全二叉树； //先序遍历递归算法 public void preRootTraverse(BiTreeNode T){ if(T != null){ System.out.print(T...
erchashu.rar_二叉树_二叉树遍历_完全遍历_树型结构_树结构
09-22
树型结构是一类重要的非线性数据结构，而二叉树是最为重要，最为常用的类型。树结构在客观世界中广泛存在，如人类社会的族谱和各种社会组织机构都可以用树来形象表示。树在计算机领域中也得到广泛应用，如在编译程序...
中序遍历线索二叉树数据结构
最新发布
12-19
中序遍历线索二叉树是一种对二叉树进行线索化的方法，使得每个节点都有前驱和后继节点。在中序遍历线索二叉树中，节点的前驱是其在中序遍历序列中的前一个节点，后继是其在中序遍历序列中的后一个节点。 下面是中序遍历线索二叉树的数据结构定义： ```c struct ThreadNode { int data; // 节点数据 struct ThreadNode *leftChild; // 左子节点指针 struct ThreadNode *rightChild; // 右子节点指针 int leftTag; // 左标志，0表示左子节点指向左孩子，1表示左子节点指向前驱节点 int rightTag; // 右标志，0表示右子节点指向右孩子，1表示右子节点指向后继节点 }; ``` 在中序遍历线索二叉树中，节点的左子节点指针和右子节点指针有两种情况： - 如果节点的左子节点存在，则左子节点指针指向左孩子； - 如果节点的左子节点不存在，则左子节点指针指向该节点在中序遍历序列中的前驱节点。 同样，节点的右子节点指针也有两种情况： - 如果节点的右子节点存在，则右子节点指针指向右孩子； - 如果节点的右子节点不存在，则右子节点指针指向该节点在中序遍历序列中的后继节点。 这样，通过线索化操作，我们可以在不使用递归或栈的情况下，按照中序遍历的顺序访问二叉树的节点。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值