哈工大数据结构作业2-线性结构及其应用

最新推荐文章于 2024-05-31 15:46:36 发布
最新推荐文章于 2024-05-31 15:46:36 发布
阅读量739 收藏 9
点赞数 1
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_45853731/article/details/118672739
版权
本文介绍了使用栈结构实现中缀表达式到后缀表达式的转换，并对后缀表达式进行求值的过程。作者分享了C++代码实现，包括辅助函数和主要算法，涉及括号匹配、运算符优先级处理等。代码读取文本文件中的中缀表达式，转换后缀表达式并计算结果，同时展示了栈的状态变化。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

  本文是笔者2020年秋哈工大数据结构作业2自己的代码，由于本人能力有限，可能存在一些错误，欢迎指出。

  本文仅供参考，严禁抄袭！

  2020年秋的作业2是二选一，笔者选的是算术表达式求值。由于撰写该篇博文时距编写该作业源代码已有半年多的时间，因此再看这些代码，发现写的又臭又长，思路早已不清晰。这里只将代码放上，恕难详细描述思路，希望有心的读者耐心阅读源码，若有不通之处可评论或私聊。

源代码完整版资源链接：https://download.youkuaiyun.com/download/qq_45853731/20213114?spm=1001.2014.3001.5503

文章目录

作业题目：算术表达式求值

  表达式求值是实现程序设计语言的基本问题之一，也是栈的应用的一个典型例子。一个算术表达式是由操作数(operand)、运算符(operator)和界限符(delimiter)组成的。假设操作数是正整数，运算符只含加减乘除等四种二元运算符，界限符有左右括号和表达式起始、结束符“#”，如：#（7+15）*（23-28/4）#。引入表达式起始、结束符是为了方便。设计一个程序，演示用算符优先法对算术表达式求值的过程。

基本数据结构

#define Maxlength 100
#define Charlen 100

typedef char Elementtype;
struct STACK {
    int top;
    Elementtype elements[Maxlength];
};
struct STACKNUM {
    int top;
    double elements[Maxlength];
};
char sufExpression[Charlen];

辅助函数

//将栈置空
void MakeNull(STACK& S)
{
    S.top = Maxlength;
}
//判断栈是否为空
bool Empty(STACK S)
{
    if (S.top > Maxlength - 1)
        return true;
    else
        return false;
}
//判断栈是否为空
bool EmptyNum(STACKNUM Sres)
{
    if (Sres.top > Maxlength - 1)
        return true;
    else
        return false;
}
//返回栈顶元素
Elementtype Top(STACK S)
{
    if (Empty(S))
    {
        return '0';
    }
    else
    {
        return S.elements[S.top];
    }
}
//打印栈信息
void PrintStack(STACK S)
{
    cout << "现在栈中，从栈顶到栈底依次为：";
    for (int i = S.top; i < Maxlength; i++)
    {
        cout << S.elements[i] << ' ';
    }
    cout << endl;
}
//打印栈信息
void PrintNumStack(STACKNUM Sres)
{
    cout << "现在栈中，从栈顶到栈底依次为：";
    for (int i = Sres.top; i < Maxlength; i++)
    {
        cout << Sres.elements[i] << ' ';
    }
    cout << endl;
}
//将栈顶元素弹出
void Pop(STACK& S)
{
    if (Empty(S))
        cout << "stack is empty" << endl;
    else
    {
        cout << "令" << S.elements[S.top] << "出栈，";
        S.top = S.top + 1;
        PrintStack(S);
    }
}
//将栈顶元素弹出
void PopNum(STACKNUM& Sres)
{
    if (EmptyNum(Sres))
        cout << "stack is empty" << endl;
    else
    {
        cout << "令" << Sres.elements[Sres.top] << "出栈，";
        Sres.top = Sres.top + 1;
        PrintNumStack(Sres);
    }
}
//压栈
void Push(Elementtype x, STACK& S)
{
    if (S.top == 0)
        cout << "stack is full" << endl;
    else
    {
        cout << "将" << x << "入栈，";
        S.top -= 1;
        S.elements[S.top] = x;
        PrintStack(S);
    }
}
//压栈
void PushNum(double x, STACKNUM& Sres)
{
    if (Sres.top == 0)
        cout << "stack is full" << endl;
    else
    {
        cout << "将" << x << "入栈，";
        Sres.top -= 1;
        Sres.elements[Sres.top] = x;
        PrintNumStack(Sres);
    }
}

从文本文件输入任意一个语法正确的（中缀）表达式，显示并保存该表达式

ifstream in("result.txt");
    in >> c;
    in >> c;
    while (c != '#')
    {
        cout << c;
        in >> c;
    }
    in.close();

文本中保存的表达式格式如下：

#(12.1*2.2^2+3.4)*(4-12/6)#

注：这里只是将文件中的表达式读取到了控制台上，并未保存，真正的保存操作在下一节void Trans函数中。
 

利用栈结构，把上述（中缀）表达式转换成后缀表达式，并显示栈的状态变化过程和所得到的后缀表达式

void Trans(STACK& S)//中缀转后缀
{
    char c, prec;
    int i = 0;
    ifstream in("result.txt");
    in >> c;
    in >> c;
    prec = c;
    while (c != '#')
    {
        if (c == '(')
        {
            Push(c, S);
        }
        else if (c == ')')
        {
            while (Empty(S) == false)
            {
                if (S.elements[S.top] != '(')
                {
                    sufExpression[i] = S.elements[S.top];
                    i++;
                    sufExpression[i] = ' ';
                    i++;
                }
                if (S.elements[S.top] == '(')
                {
                    Pop(S);
                    break;
                }
                Pop(S);
            }
        }
        else if (c == '*')
        {
            while (S.elements[S.top] == '^'||S.elements[S.top] == '/')
            {
                sufExpression[i] = S.elements[S.top];
                i++;
                sufExpression[i] = ' ';
                i++;
                Pop(S);
            }
            Push(c, S);
        }
        else if (c == '/')
        {
            while (S.elements[S.top] == '^' || S.elements[S.top] == '*')
            {
                sufExpression[i] = S.elements[S.top];
                i++;
                sufExpression[i] = ' ';
                i++;
                Pop(S);
            }
            Push(c, S);
        }
        else if (c == '^')
        {
            Push(c, S);
        }
        else if (c == '+')
        {
            while (S.elements[S.top] == '*' || S.elements[S.top] == '/' || S.elements[S.top] == '^'||S.elements[S.top]=='-')
            {
                sufExpression[i] = S.elements[S.top];
                i++;
                sufExpression[i] = ' ';
                i++;
                Pop(S);
            }
            Push(c, S);
        }
        else if (c == '-')
        {
            while (S.elements[S.top] == '*' || S.elements[S.top] == '/' || S.elements[S.top] == '^' || S.elements[S.top] == '+')
            {
                sufExpression[i] = S.elements[S.top];
                i++;
                sufExpression[i] = ' ';
                i++;
                Pop(S);
            }
            Push(c, S);
        }
        else if (c <= '9' && c >= '0' || c == '.')
        {
            sufExpression[i] = c;
            i++;
        }
        prec = c;
        in >> c;
        if ((prec <= '9' && prec >= '0') && (c == '+' || c == '-' || c == '*' || c == '/' || c == ')' || c == '^'))
        {
            sufExpression[i] = ' ';
            i++;
        }
    }
    while (Empty(S) == false)
    {
        if (S.elements[S.top] != '(')
        {
            sufExpression[i] = ' ';
            i++;
            sufExpression[i] = S.elements[S.top];
            i++;
            sufExpression[i] = ' ';
            i++;
        }
        Pop(S);
    }
    sufExpression[i] = '\0';
    in.close();
}

 

利用栈结构，对后缀表达式进行求值，并显示栈的状态变化过程和最终结果

void Calcu(STACKNUM& Sres)//计算结果
{
    double result;
    int i = 0, weight = 0, decimal = 0, flag = 0;
    while (sufExpression[i] != '\0')
    {
        if (sufExpression[i] >= '0' && sufExpression[i] <= '9')
        {
            int j = i;
            while (sufExpression[j] != ' ')
            {
                if (sufExpression[j] == '.')
                {
                    flag = 1;
                    break;
                }
                weight++;
                j++;
            }
            if (flag == 1)
            {
                j++;
                while (sufExpression[j] != ' ')
                {
                    decimal++;
                    j++;
                }
            }
            flag = 0;
            result = 0;
            while (sufExpression[i] != ' ')
            {
                if (sufExpression[i] == '.')
                {
                    flag = 1;
                    break;
                }
                result += pow(10, weight - 1) * int(sufExpression[i] - '0');
                weight--;
                i++;
            }
            if (flag == 1)
            {
                i++;
                for (int k = 1; k <= decimal; k++)
                {
                    result += pow(10, -decimal) * int(sufExpression[i] - '0');
                    i++;
                }
            }
            decimal = 0;
            PushNum(result, Sres);
        }
        else if (sufExpression[i] == '+')
        {
            result = Sres.elements[Sres.top] + Sres.elements[Sres.top + 1];
            PopNum(Sres);
            PopNum(Sres);
            PushNum(result, Sres);
        }
        else if (sufExpression[i] == '-')
        {
            result = Sres.elements[Sres.top + 1] - Sres.elements[Sres.top];
            PopNum(Sres);
            PopNum(Sres);
            PushNum(result, Sres);
        }
        else if (sufExpression[i] == '*')
        {
            result = Sres.elements[Sres.top + 1] * Sres.elements[Sres.top];
            PopNum(Sres);
            PopNum(Sres);
            PushNum(result, Sres);
        }
        else if (sufExpression[i] == '/')
        {
            if (Sres.elements[Sres.top] == 0)
            {
                cout << "除数不能为0" << endl;
            }
            else
            {
                result = Sres.elements[Sres.top + 1] / Sres.elements[Sres.top];
                PopNum(Sres);
                PopNum(Sres);
                PushNum(result, Sres);
            }
        }
        else if (sufExpression[i] == '^')
        {
            result = pow(Sres.elements[Sres.top + 1], Sres.elements[Sres.top]);
            PopNum(Sres);
            PopNum(Sres);
            PushNum(result, Sres);
        }
        i++;
    }
    cout << endl << "计算结果为：";
    cout << Sres.elements[Sres.top] << endl << endl;
    cout << "下面是结合2、3的算符优先法的过程：" << endl << endl;
}

 

将操作数类型扩充到实数、扩充运算符集合，并引入变量操作数，来完成表达式求值

  该要求已经在前两节中扩充。
 

设计和实现结合 3 和 4 的算符优先法

void Merge(STACK& S, STACKNUM& Sres)//结合2、3的算符优先法
{
    char c, prec;
    int i = 0, j = 0;
    int weight = 0;
    double decimal = 1, result = 0;
    ifstream in("result.txt");
    in >> c;
    in >> c;
    prec = c;
    while (c != '#')
    {
        prec = c;
        if (c == '(')
        {
            Push(c, S);
            in >> c;
        }
        else if (c == ')')
        {
            while (Empty(S) == false)
            {
                if (S.elements[S.top] != '(')
                {
                    sufExpression[i] = S.elements[S.top];
                    i++;
                    sufExpression[i] = ' ';
                    i++;
                }
                if (S.elements[S.top] == '+')
                {
                    result = Sres.elements[Sres.top] + Sres.elements[Sres.top + 1];
                    PopNum(Sres);
                    PopNum(Sres);
                    PushNum(result, Sres);
                    result = 0;
                }
                else if (S.elements[S.top] == '-')
                {
                    result = Sres.elements[Sres.top + 1] - Sres.elements[Sres.top];
                    PopNum(Sres);
                    PopNum(Sres);
                    PushNum(result, Sres);
                    result = 0;
                }
                else if (S.elements[S.top] == '*')
                {
                    result = Sres.elements[Sres.top + 1] * Sres.elements[Sres.top];
                    PopNum(Sres);
                    PopNum(Sres);
                    PushNum(result, Sres);
                    result = 0;
                }
                else if (S.elements[S.top] == '/')
                {
                    if (Sres.elements[Sres.top] == 0)
                    {
                        cout << "除数不能为0" << endl;
                    }
                    else
                    {
                        result = Sres.elements[Sres.top + 1] / Sres.elements[Sres.top];
                        PopNum(Sres);
                        PopNum(Sres);
                        PushNum(result, Sres);
                        result = 0;
                    }
                }
                else if (S.elements[S.top] == '^')
                {
                    result = pow(Sres.elements[Sres.top + 1], Sres.elements[Sres.top]);
                    PopNum(Sres);
                    PopNum(Sres);
                    PushNum(result, Sres);
                    result = 0;
                }
                if (S.elements[S.top] == '(')
                {
                    Pop(S);
                    break;
                }
                Pop(S);
            }
            in >> c;
        }
        else if (c == '*')
        {
            while (S.elements[S.top] == '^'|| S.elements[S.top] == '/')
            {
                sufExpression[i] = S.elements[S.top];
                i++;
                sufExpression[i] = ' ';
                i++;
                if (S.elements[S.top] == '^')
                {
                    result = pow(Sres.elements[Sres.top + 1], Sres.elements[Sres.top]);
                    PopNum(Sres);
                    PopNum(Sres);
                    PushNum(result, Sres);
                    result = 0;
                }
                else if (S.elements[S.top] == '/')
                {
                    if (Sres.elements[Sres.top] == 0)
                    {
                        cout << "除数不能为0" << endl;
                    }
                    else
                    {
                        result = Sres.elements[Sres.top + 1] / Sres.elements[Sres.top];
                        PopNum(Sres);
                        PopNum(Sres);
                        PushNum(result, Sres);
                        result = 0;
                    }
                }
                Pop(S);
            }
            Push(c, S);
            in >> c;
        }
        else if (c == '/')
        {
            while (S.elements[S.top] == '^' || S.elements[S.top] == '*')
            {
                sufExpression[i] = S.elements[S.top];
                i++;
                sufExpression[i] = ' ';
                i++;
                if (S.elements[S.top] == '^')
                {
                    result = pow(Sres.elements[Sres.top + 1], Sres.elements[Sres.top]);
                    PopNum(Sres);
                    PopNum(Sres);
                    PushNum(result, Sres);
                    result = 0;
                }
                else if (S.elements[S.top] == '*')
                {
                    result = Sres.elements[Sres.top + 1] * Sres.elements[Sres.top];
                    PopNum(Sres);
                    PopNum(Sres);
                    PushNum(result, Sres);
                    result = 0;
                }
                Pop(S);
            }
            Push(c, S);
            in >> c;
        }
        else if (c == '^')
        {
            Push(c, S);
            in >> c;
        }
        else if (c == '+')
        {
            while (S.elements[S.top] == '*' || S.elements[S.top] == '/' || S.elements[S.top] == '^'|| S.elements[S.top] == '-')
            {
                sufExpression[i] = S.elements[S.top];
                i++;
                sufExpression[i] = ' ';
                i++;
                if (S.elements[S.top] == '*')
                {
                    result = Sres.elements[Sres.top + 1] * Sres.elements[Sres.top];
                    PopNum(Sres);
                    PopNum(Sres);
                    PushNum(result, Sres);
                    result = 0;
                }
                else if (S.elements[S.top] == '/')
                {
                    if (Sres.elements[Sres.top] == 0)
                    {
                        cout << "除数不能为0" << endl;
                    }
                    else
                    {
                        result = Sres.elements[Sres.top + 1] / Sres.elements[Sres.top];
                        PopNum(Sres);
                        PopNum(Sres);
                        PushNum(result, Sres);
                        result = 0;
                    }
                }
                else if (S.elements[S.top] == '^')
                {
                    result = pow(Sres.elements[Sres.top + 1], Sres.elements[Sres.top]);
                    PopNum(Sres);
                    PopNum(Sres);
                    PushNum(result, Sres);
                    result = 0;
                }
                else if (S.elements[S.top] == '-')
                {
                    result = Sres.elements[Sres.top + 1] - Sres.elements[Sres.top];
                    PopNum(Sres);
                    PopNum(Sres);
                    PushNum(result, Sres);
                    result = 0;
                }
                Pop(S);
            }
            Push(c, S);
            in >> c;
        }
        else if (c == '-')
        {
        while (S.elements[S.top] == '*' || S.elements[S.top] == '/' || S.elements[S.top] == '^' || S.elements[S.top] == '+')
        {
            sufExpression[i] = S.elements[S.top];
            i++;
            sufExpression[i] = ' ';
            i++;
            if (S.elements[S.top] == '*')
            {
                result = Sres.elements[Sres.top + 1] * Sres.elements[Sres.top];
                PopNum(Sres);
                PopNum(Sres);
                PushNum(result, Sres);
                result = 0;
            }
            else if (S.elements[S.top] == '/')
            {
                if (Sres.elements[Sres.top] == 0)
                {
                    cout << "除数不能为0" << endl;
                }
                else
                {
                    result = Sres.elements[Sres.top + 1] / Sres.elements[Sres.top];
                    PopNum(Sres);
                    PopNum(Sres);
                    PushNum(result, Sres);
                    result = 0;
                }
            }
            else if (S.elements[S.top] == '^')
            {
                result = pow(Sres.elements[Sres.top + 1], Sres.elements[Sres.top]);
                PopNum(Sres);
                PopNum(Sres);
                PushNum(result, Sres);
                result = 0;
            }
            else if (S.elements[S.top] == '+')
            {
                result = Sres.elements[Sres.top + 1] + Sres.elements[Sres.top];
                PopNum(Sres);
                PopNum(Sres);
                PushNum(result, Sres);
                result = 0;
            }
            Pop(S);
        }
        Push(c, S);
        in >> c;
        }
        else if (c <= '9' && c >= '0' || c == '.')
        {
            if(c >= '0' && c <= '9')
            {
                j = i;
                while (c >= '0' && c <= '9')
                {
                    weight++;
                    sufExpression[i] = c;
                    i++;
                    in >> c;
                }
                while (weight > 0)
                {
                    result += pow(10, weight - 1) * int(sufExpression[j] - '0');
                    j++;
                    weight--;
                }
            }
            if(c=='.')
            {
                sufExpression[i] = c;
                i++;
                in >> c;
                while (c <= '9' && c >= '0')
                {
                    sufExpression[i] = c;
                    i++;
                    decimal = decimal * 0.1;
                    result += decimal * int(c - '0');
                    in >> c;
                }
                decimal = 1;
            }
            PushNum(result, Sres);
            result = 0;
        }
        if ((prec <= '9' && prec >= '0') && (c == '+' || c == '-' || c == '*' || c == '/' || c == ')' || c == '^'))
        {
            sufExpression[i] = ' ';
            i++;
        }
    }
    while (Empty(S) == false)
    {
        if (S.elements[S.top] != '(')
        {
            sufExpression[i] = S.elements[S.top];
            i++;
            sufExpression[i] = ' ';
            i++;
        }
        if (S.elements[S.top] == '+')
        {
            result = Sres.elements[Sres.top] + Sres.elements[Sres.top + 1];
            PopNum(Sres);
            PopNum(Sres);
            PushNum(result, Sres);
            result = 0;
        }
        else if (S.elements[S.top] == '-')
        {
            result = Sres.elements[Sres.top + 1] - Sres.elements[Sres.top];
            PopNum(Sres);
            PopNum(Sres);
            PushNum(result, Sres);
            result = 0;
        }
        else if (S.elements[S.top] == '*')
        {
            result = Sres.elements[Sres.top + 1] * Sres.elements[Sres.top];
            PopNum(Sres);
            PopNum(Sres);
            PushNum(result, Sres);
            result = 0;
        }
        else if (S.elements[S.top] == '/')
        {
            if (Sres.elements[Sres.top] == 0)
            {
                cout << "除数不能为0" << endl;
            }
            else
            {
                result = Sres.elements[Sres.top + 1] / Sres.elements[Sres.top];
                PopNum(Sres);
                PopNum(Sres);
                PushNum(result, Sres);
                result = 0;
            }
        }
        else if (S.elements[S.top] == '^')
        {
            result = pow(Sres.elements[Sres.top + 1], Sres.elements[Sres.top]);
            PopNum(Sres);
            PopNum(Sres);
            PushNum(result, Sres);
            result = 0;
        }
        Pop(S);
    }
    sufExpression[i] = '\0';
    in.close();
    cout << Sres.elements[Sres.top] << endl;
}
哈尔滨工业大学数据结构试题
03-27
本套试题中包含了所有的数据结构要点，是学习和巩固数据结构必备的宝典
哈工大数据结构作业树部分
05-17
哈工大数据结构
哈工大数据结构作业5-查找结构与排序方法
qq_45853731的博客
07-12 978
  本文是笔者2020年秋哈工大数据结构作业5自己的代码，由于本人能力有限，可能存在一些错误，欢迎指出。   本次作业是二选一，临近期末，笔者就选了个比较水的败者树。 文章目录作业题目：利用败者树实现锦标赛排序（树形选择排序）设计败者树的存储结构利用败者树实现锦标赛排序 作业题目：利用败者树实现锦标赛排序（树形选择排序）   败者树实际上是一棵完全二叉树，可以看作是胜者树的一种变体。败者树简化了重构，败者树的重构只是与该结点的父结点的记录有关，而胜者树的重构还与该结点的兄弟结点有关。败者树作为一种重要的数据
HIT-哈工大数据结构-作业2（C++）
LLL_LLLi的博客
02-25 434
数据结构
哈工大数据结构实验二
m0_73423690的博客
05-31 1048
该函数用于统计文章中出现的各个字符及其出现的次数和总字符种类数，打开passage.txt文件后，先将words数组的每一项结构体中的count成员初始化为零，方便后续统计，先读取一个字符，并保存该字符及对其出现次数统计的count进行递增，当未读取到文件末尾时，每读取一个字符，借助found标志变量，判断该字符是否之前被统计过，如果是，则递增该字符出现次数，否则，存储该字符并递增其出现次数，最后关闭文件。为每个字符的结构体，其中的成员为ch，用于存储字符，count用于存储该字符在文章中出现的次数。
哈工大数据结构作业1-线性结构的存储结构与应用
qq_45853731的博客
07-12 1059
 本文是笔者2020年秋哈工大数据结构作业1自己的代码，由于本人能力有限，可能存在一些错误，欢迎指出。 文章目录线性表的顺序存储结构顺序存储结构的定义删除给定元素的算法对于已排好序的线性表，删除所有重复元素的算法线性表“逆置”算法线性表循环左移/右移 k 位的算法合并两个已排好序的线性表的算法辅助函数主函数线性表的链式存储结构链式存储结构的定义删除给定元素的算法对于已排好序的线性表，删除所有重复元素的算法线性表“逆置”算法线性表循环左移/右移 k 位的算法合并两个已排好序的线性表的算法辅助函数主函数 线性表
哈工大-数据结构与算法-实验作业2 线性结构的存储结构与应用.zip
06-01
在哈工大的“数据结构与算法”课程中，实验作业2着重探讨了线性结构的存储结构及其在实际问题中的应用。线性结构是计算机科学中最基础的数据组织形式，包括数组、链表、栈和队列等。这些结构在算法设计和数据处理中...
哈工大-数据结构与算法-实验实验1 线性结构及其应用.zip
06-01
在这个哈工大的课程实验“线性结构及其应用”中，学生们将深入学习并实践这一关键领域。线性结构是数据结构的一种基本类型，它包括数组、链表、栈和队列等。这些结构在编程中有着广泛的应用，如内存管理、数据处理和...
哈工大-数据结构与算法-实验作业3 树形结构及其应用.zip
06-01
在哈工大的数据结构与算法课程中，实验作业3聚焦于树形结构及其应用。树是一种非线性数据结构，它的各个元素（节点）通过父子关系连接，形成一种层次结构，这种结构在计算机科学中有着广泛的应用。在这个实验中，...
哈工大-数据结构与算法-实验实验2 树形结构及其应用.zip
最新发布
06-01
在本实验“哈工大-数据结构与算法-实验2 树形结构及其应用”中，学生将深入理解并实践如何利用树形结构解决实际问题。 树形结构是一种非线性的数据结构，其特点是以节点的形式存储数据，并通过边连接这些节点，形成...
哈工大-数据结构与算法-实验实验3 图形结构及其应用.zip
06-01
在哈工大的“数据结构与算法”课程中，实验3主要关注图形结构及其应用。图形结构是计算机科学中一种至关重要的数据结构，它用于表示实体之间的复杂关系，这些关系可以是非线性的、任意的，因此在解决许多问题时非常...
一元多项式计算器(哈工大数据结构作业)
10-15
该源码用于学习交流，给没有思路的同学提供一些思路，坚决抵制抄袭。源码用clion写的，如果用其他集成开发环境运行可能需要改一下txt文档的相对路径，到时自行百度。
数据结构第三章作业
04-04
数据结构第三章作业，数据结构第三章作业，数据结构第三章作业
HIT-哈工大数据结构-作业1（C++）
LLL_LLLi的博客
02-25 543
数据结构
哈工大数据结构实验2-树形结构及其应用
qq_45853731的博客
07-12 1745
文章目录实验目的实验要求及实验环境实验要求：设计思想（本程序中的用到的所有数据类型的定义，主程序的流程图及各程序模块之间的调用关系）数据类型：存储读入字符及其频率的数据结构存储字符哈夫曼树的数据结构存储字符哈夫曼编码表的数据结构存储单词哈夫曼树的数据结构存储单词哈夫曼编码表的数据结构存储k叉哈夫曼树的数据结构存储堆的数据结构流程图调用关系测试结果测试样例1测试样例2源代码 实验目的 利用树形结构实现对文本的哈夫曼编码及译码，包括对字符的编码译码和对单词的编码译码，在此过程中熟练掌握树形结构的应用。 实验要求
哈工大数据结构作业4-图形结构及其应用
qq_45853731的博客
07-12 1728
  本文是笔者2020年秋哈工大数据结构作业3自己的代码，由于本人能力有限，可能存在一些错误，欢迎指出。   本次作业是有向图和无向图二选一，笔者选的是有向图。 完整源代码链接：https://download.youkuaiyun.com/download/qq_45853731/20213288?spm=1001.2014.3001.5503   本文仅供参考，严禁抄袭！ 文章目录作业题目：图的存储结构的建立与搜索存储结构分别实现有向图的邻接矩阵和邻接表存储结构的建立算法，分析和比较各建立算法的时间复杂度以及存储结
哈工大 数据结构与算法 作业4-图型结构及其应用
TC_Ning的博客
10-10 1553
作业题目 1：图的存储结构的建立与搜索 图的搜索（遍历） 算法是图型结构相关算法的基础，本作业要求编写程序 演示无向图典型存储结构的建立和搜索（遍历）过程。 作业要求： 1．分别实现无向图的邻接矩阵和邻接表存储结构的建立算法，分析和比较各建 立算法的时间复杂度以及存储结构的空间占用情况； 2．实现无向图的邻接矩阵和邻接表两种存储结构的相互转换算法； 3．在上述两种存储结构上，分别实现无向图的深度优先搜索（递归和非递归) 和广度优先搜索算法。并以适当的方式存储和显示相应的搜索结果（深度优先或 广度优
哈工大数据结构实验作业：树形结构应用分析
资源摘要信息:"该文件是一个包含哈尔滨工业大学（哈工大）数据结构与算法课程实验作业的压缩包，其主题为树形结构及其应用。树形结构是计算机科学中一种非常重要的非线性数据结构，它在许多领域，如数据库索引、文件...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值