数据结构 实验报告（一）

最新推荐文章于 2024-08-13 17:39:16 发布
最新推荐文章于 2024-08-13 17:39:16 发布
阅读量851 收藏 16
点赞数 24
文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73952485/article/details/139534124
版权

一、实验目的

1、 领会单链表存储结构和掌握单链表中的各种基本运算算法设计；
2、 领会栈链存储结构和掌握栈链中的各种基本运算算法设计；
3、 领会环形队列存储结构和掌握环形队列中的各种基本运算算法设计；
4、 深入掌握单链表应用的算法设计；
5、 掌握栈应用的算法设计；

二、使用仪器、器材

微机一台
操作系统：WinXP
编程软件：C/C++编程软件

三、实验内容及原理

(可能有错误之处，仅供参考~)

1、教材P74

实验题2：实现单链表的各种基本运算的算法
编写一个程序linklist.cpp，实现单链表中的各种基本运算和整体建表算法（假设单链表的元素类型ElemType为char），并在此基础上设计一个程序exp2-2.cpp完成以下功能。
（1）初始化单链表h。
（2）依次采用尾插法插入a、b、c、d、e元素。
（3）输出单链表h。
（4）输出单链表h的长度。
（5）判断单链表h是否为空。
（6）输出单链表h的第3个元素。
（7）输出元素a的位置。
（8）在第4个元素位置上插入f元素。
（9）输出单链表h。
（10）删除单链表h的第3个元素。
（11）输出单链表h。
（12）释放单链表h。

#include <iostream>
using namespace std;

#define ElemType char

typedef struct LNode
{
    ElemType data;
    struct LNode *next;
} *LinkList;

// 初始化
void InitList(LinkList &L)
{
    L = new LNode;
    L->next = NULL;
}

// 打印链表
void PrintList(LinkList &L)
{
    LNode *p = L->next;
    while (p)
    {
        cout << p->data << " ";
        p = p->next;
    }
    cout << "\n";
}

// 输出指定位置的元素
bool PrintList_index(LinkList &L, int n, ElemType &e)
{
    LNode *p = L;
    for (int i = 1; i <= n; i++)
    {
        if (p->next)
            p = p->next;
        else
            return false;
    }
    e = p->data;
    return true;
}

// 尾插法（1）
void CreatList_R(LinkList &L, int n)
{
    LNode *R = L; // 尾指针
    for (int i = 1; i <= n; i++)
    {
        LNode *p = new LNode;
        cin >> p->data;
        p->next = NULL;
        R->next = p;
        R = R->next; // 尾指针后移
    }
}

// 尾插法（2）
void CreatList_R(LinkList &L, int n, ElemType e[])
{
    LNode *R = L;
    for (int i = 0; i < n; i++)
    {
        LNode *p = new LNode;
        p->data = e[i];
        p->next = NULL;
        R->next = p;
        R = R->next; // 尾指针后移
    }
}

// 删除指定位置的元素
bool DeleteList(LinkList &L, int n)
{
    LNode *p = L;
    for (int i = 1; i < n; i++)
    {
        if (p->next)
            p = p->next;
        else
            return false;
    }
    LNode *tmp = p->next;
    if (tmp)
    {
        p->next = p->next->next;
        delete tmp;
        return true;
    }
    return false;
}

// 插入指定位置的元素
bool InsertList(LinkList &L, int n, ElemType e)
{
    LNode *p = L;
    for (int i = 1; i < n; i++)
    {
        if (p->next)
            p = p->next;
        else
            return false;
    }
    LNode *tmp = new LNode;
    tmp->data = e;
    tmp->next = p->next;
    p->next = tmp;
    return true;
}

// 链表长度
int LenList(LinkList &L)
{
    int len = 0;
    LNode *p = L->next;
    while (p)
    {
        len++;
        p = p->next;
    }
    return len;
}

// 链表是否为空
bool EmptyList(LinkList &L)
{
    if (L->next)
        return false;
    else
        return true;
}

// 查找指定位置的元素
bool SearchList(LinkList &L, ElemType e, int &idx)
{
    LNode *p = L->next;
    idx = 1;
    while (p && p->data != e)
    {
        p = p->next;
        idx++;
    }
    return p ? true : false;
}

// 销毁链表
bool DestroyList(LinkList &L)
{
    LNode *p = L;
    while (p)
    {
        LNode *tmp = p;
        p = p->next;
        delete tmp;
        tmp = nullptr;
    }
    L = nullptr;
    return true;
}

int main()
{
    LinkList h;

    printf("(1)初始化单链表h\n");
    InitList(h);

    printf("(2)依次采用尾插法插入a、b、c、d、e元素\n");
    char input[] = "abcde";
    CreatList_R(h, 5, input);

    printf("(3)输出单链表h: ");
    PrintList(h);

    printf("(4)输出单链表h的长度: ");
    printf("%d\n", LenList(h));

    printf("(5)判断单链表h是否为空: ");
    if (EmptyList(h))
        printf("空！\n");
    else
        printf("不空！\n");

    printf("(6)输出单链表h的第3个元素: ");
    char c;
    if (PrintList_index(h, 3, c))
        printf("%c\n", c);
    else
        printf("不存在!\n");

    printf("(7)输出元素a的位置: ");
    int idx;
    if (SearchList(h, 'a', idx))
        printf("%d\n", idx);
    else
        printf("不存在!\n");

    printf("(8)在第4个元素位置上插入f元素: ");
    if (InsertList(h, 4, 'f'))
        printf("插入成功!\n");
    else
        printf("插入失败!\n");

    printf("(9)输出单链表h: ");
    PrintList(h);

    printf("(10)删除单链表h的第3个元素: ");
    if (DeleteList(h, 3))
        printf("删除成功!\n");
    else
        printf("删除失败!\n");

    printf("(11)输出单链表h: ");
    PrintList(h);

    printf("(12)释放单链表h\n");
    DestroyList(h);

    return 0;
}

2、教材P118

实验题2：实现链栈的各种基本运算的算法
编写一个程序linkstack.cpp，实现链栈（假设栈中元素类型ElemType为char）的各种基本运算，并在此基础上设计一个程序exp3-2.cpp完成以下功能。
（1）初始化栈s。
（2）判断栈s是否为空。
（3）依次进栈元素a、b、c、d、e。
（4）判断栈s是否非空。
（5）输出出栈序列。
（6）判断栈s是否非空。
（7）释放栈。

#include <iostream>
#include <string>
using namespace std;

#define MAXSIZE 200
#define ElemType char
//
typedef struct StackNode
{
    ElemType data;
    struct StackNode *next;
} *LinkStack;

void InitStack(LinkStack &S)
{
    // 构造一个空栈，栈顶指针置为空
    S = nullptr;
}

bool StackEmpty(LinkStack S)
{
    // 若栈为空，返回true;否则返回false
    return S == nullptr;
}

// 销毁链栈
bool DestroyStack(LinkStack &S)
{
    StackNode *p = S;
    while (p)
    {
        S = S->next;
        delete p;
        p = S;
    }
    return true;
}

bool PushStack(LinkStack &S, char e)
{
    StackNode *p = new StackNode;

    if (!p)
        return false;

    p->data = e;
    p->next = S;
    S = p;
}

bool PopStack(LinkStack &S, char &e)
{
    if (S == nullptr) // 栈空
        return false;
    e = S->data;
    StackNode *p = S;
    S = S->next;
    delete p;
    return true;
}

bool GetTop(LinkStack &S, char &e)
{
    if (S == nullptr)
        return false; // 栈空
    e = S->data;
    return true;
}

int main()
{
    LinkStack S;

    printf("(1)初始化栈s\n");
    InitStack(S); // 初始化栈

    printf("(2)判断栈s是否为空: %s\n", StackEmpty(S) ? "空！" : "不空！");

    printf("(3)依次进栈元素: a b c d e\n");
    char input[] = "abcde";
    for (int i = 0; i < 5; i++)
        PushStack(S, input[i]);

    printf("(4)判断栈s是否为空: %s\n", StackEmpty(S) ? "空！" : "不空！");

    printf("(5)输出出栈序列: ");
    char output;
    while (PopStack(S, output))
    {
        printf("%c ", output);
    }

    printf("\n(6)判断栈s是否为空: %s\n", StackEmpty(S) ? "空！" : "不空！");

    printf("(7)释放栈\n");
    DestroyStack(S); // 释放栈

    return 0;
}

3、教材P118

实验题3：实现环形队列的各种基本运算的算法
编写一个程序sqqueue.cpp，实现环形队列（假设队列中元素类型ElemType为char）的各种基本运算，并在此基础上设计一个程序exp3-3.cpp完成以下功能。
（1）初始化队列q。
（2）判断队列q是否非空。
（3）依次进队元素a、b、c。
（4）出队一个元素，输出该元素。
（5）依次进队元素d、e、f。
（6）输出出队序列。
（12）释放队列。

#include <iostream>
#include <cstring>
#define ElemType char
using namespace std;

#define MAXSIZE 100

typedef struct
{
    ElemType *base;
    int front;
    int rear;
} Queue;

// 初始化
bool InitQueue(Queue &Q)
{
    Q.base = new ElemType[MAXSIZE];
    if (!Q.base)
        return false;
    Q.front = Q.rear = 0;
    return true;
}

bool EmptyQueue(Queue &Q)
{
    return Q.front == Q.rear;
}

// 插入
bool EnQueue(Queue &Q, ElemType &e)
{
    if((Q.rear + 1) % MAXSIZE == Q.front)
        return false;
    Q.base[Q.rear] = e;
    Q.rear = (Q.rear + 1) % MAXSIZE;
    return true;
}

// 删除
bool DlQueue(Queue &Q, ElemType &e)
{
    if(EmptyQueue(Q))
        return false;
    e = Q.base[Q.front];
    Q.front = (Q.front + 1) % MAXSIZE;
    return true;
}

bool DestroyQueue(Queue &Q)
{
    delete[] Q.base;
    Q.front = Q.rear = 0;
    Q.base = nullptr;
    return true;
}

int main()
{
    Queue Q;
    printf("(1)初始化队列q\n");
    InitQueue(Q);

    printf("(2)判断队列q是否非空: %s\n", EmptyQueue(Q) ? "空！" : "不空！");

    printf("(3)依次进队元素a b c\n");
    char input[] = "abc";
    for(int i = 0; i < 3; i++)
        EnQueue(Q,input[i]);
    
    char output;
    DlQueue(Q,output);
    printf("(4)出队一个元素，输出该元素: %c\n", output);

    printf("(5)依次进队元素d e f\n");
    strcpy(input,"def");
    for(int i = 0; i < 3; i++)
        EnQueue(Q,input[i]);

    printf("(6)输出出队序列: ");
    while(DlQueue(Q,output))
        printf("%c ", output);
    
    printf("\n(7)释放队列\n");
    DestroyQueue(Q);

    return 0;
}

4、教材P77

实验题12：用单链表实现两个大整数的相加运算
编写一个程序exp2-12.cpp完成以下功能。
（1）将用户输入的十进制整数字符串转化为带头结点的单链表，每个结点存放一个整数位。
（2）求两个整数单链表相加的结果单链表。
（3）求结果单链表的中间位，如123的中间位为2，1234的中间位为2。

#include <iostream>
using namespace std;

#define ElemType int

typedef struct LNode
{
    ElemType data;
    struct LNode *next;
} *LinkList;

// 初始化
void InitList(LinkList &L)
{
    L = new LNode;
    L->next = NULL;
}

// 打印链表【返回链表长度】
int PrintList(LinkList &L)
{
    int num = 0;
    LNode *p = L->next;
    while (p)
    {
        num++;
        cout << p->data;
        p = p->next;
    }
    cout << "\n";
    return num;
}

// 输出指定位置的元素
bool PrintList_index(LinkList &L, int n, ElemType &e)
{
    LNode *p = L;
    for (int i = 1; i <= n; i++)
    {
        if (p->next)
            p = p->next;
        else
            return false;
    }
    e = p->data;
    return true;
}

// 尾插法（1）
void CreatList_R(LinkList &L, int n)
{
    LNode *R = L; // 尾指针
    for (int i = 1; i <= n; i++)
    {
        LNode *p = new LNode;
        cin >> p->data;
        p->next = NULL;
        R->next = p;
        R = R->next; // 尾指针后移
    }
}

// 尾插法（2）
// 注意：数字从低位开始保存：如1234 链表中保存为 4->3->2->1
void CreatList_R(LinkList &L, string num)
{
    LNode *R = L;
    for (int i = num.size() - 1; i >= 0; i--)
    {
        LNode *p = new LNode;
        p->data = num[i] - '0';
        p->next = NULL;
        R->next = p;
        R = R->next; // 尾指针后移
    }
}

// 删除指定位置的元素
bool DeleteList(LinkList &L, int n)
{
    LNode *p = L;
    for (int i = 1; i < n; i++)
    {
        if (p->next)
            p = p->next;
        else
            return false;
    }
    LNode *tmp = p->next;
    if (tmp)
    {
        p->next = p->next->next;
        delete tmp;
        return true;
    }
    return false;
}

// 插入指定位置的元素
bool InsertList(LinkList &L, int n, ElemType e)
{
    LNode *p = L;
    for (int i = 1; i < n; i++)
    {
        if (p->next)
            p = p->next;
        else
            return false;
    }
    LNode *tmp = new LNode;
    tmp->data = e;
    tmp->next = p->next;
    p->next = tmp;
    return true;
}

// 链表长度
int LenList(LinkList &L)
{
    int len = 0;
    LNode *p = L->next;
    while (p)
    {
        len++;
        p = p->next;
    }
    return len;
}

// 链表是否为空
bool EmptyList(LinkList &L)
{
    if (L->next)
        return false;
    else
        return true;
}

// 查找指定位置的元素
bool SearchList(LinkList &L, ElemType e, int &idx)
{
    LNode *p = L->next;
    idx = 1;
    while (p && p->data != e)
    {
        p = p->next;
        idx++;
    }
    return p ? true : false;
}

// 销毁链表
bool DestroyList(LinkList &L)
{
    LNode *p = L;
    while (p)
    {
        LNode *tmp = p;
        p = p->next;
        delete tmp;
        tmp = nullptr;
    }
    L = nullptr;
    return true;
}

// 反转链表
void Reverse_List(LinkList &L)
{
    //从首元结点开始处理
    LNode *prev = L->next; // 指向前一个结点
    LNode *curr = L->next->next; // 指向当前结点
    while(curr)
    {
        LNode *tmp = curr->next; // 临时保存【下一个结点】
        curr->next = prev;
        //指针后移，注意两条语句的顺序
        prev = curr;
        curr = tmp;
    }
    //最后，先把首元结点的next指向空
    L->next->next = NULL;
    //再把头结点指向原本的最后一个元素【prev】
    L->next = prev;
}

LinkList Add(LinkList &A, LinkList &B)
{
    LinkList C;
    InitList(C);

    int t = 0; // 保存进位

    LNode *a = A->next;
    LNode *b = B->next;
    LNode *c = C;

    while(a || b || t)
    {
        LNode *p = new LNode;
        p->next = NULL;

        if(a) t += a->data, a = a->next;
        if(b) t += b->data, b = b->next;

        p->data = t % 10; // 保存当前位
        t /= 10; // 计算进位
        
        c->next = p;
        // 指针后移
        c = c->next;
    }

    return C;
}

int main()
{
    LinkList a, b;
    InitList(a);
    InitList(b);
    string A, B;

    printf("请输入两个整数: \n");
    cin >> A >> B;

    CreatList_R(a, A);
    CreatList_R(b, B);

    // 保存结果
    LinkList c = Add(a, b);
    // 保存结果的链表C反转
    Reverse_List(c);

    // 结果单链表的中间位保存到 e 中
    int e;
    printf("\n两个数相加后结果为:\n");
    PrintList_index(c, (PrintList(c) + 1) / 2, e);
    printf("\n结果单链表的中间位为: \n%d\n", e);

    return 0;
}

5、教材P119

实验题7：求解栈元素排序问题
编写一个程序exp3-7.cpp，按升序对一个字符栈进行排序，即最小元素位于栈顶，最多只能使用一个额外的栈存放临时数据，并输出栈排序过程。

#include <iostream>
#include <string>
using namespace std;
#define MAXSIZE 200

// 顺序栈
typedef struct
{
    char *base;    // 栈底指针
    char *top;     // 栈顶指针
    int stacksize; // 栈可用最大容量
} SqStack;

bool InitStack(SqStack &S)
{
    // 构造一个空栈
    S.base = new char[MAXSIZE];
    if (!S.base)
        return false; // 存储分配失败
    S.top = S.base;   // 栈顶指针等于栈底指针
    S.stacksize = MAXSIZE;
    return true;
}

bool StackEmpty(SqStack S)
{
    // 若栈为空，返回TRUE;否则返回FALSE
    if (S.top == S.base)
        return true;
    else
        return false;
}

int StackLength(SqStack S)
{
    // 指针相减，结果为元素个数
    return S.top - S.base;
}

// 清空顺序栈[不是销毁]
bool ClearStack(SqStack &S)
{
    if (S.base)
        S.top = S.base;
    return true;
}

// 销毁顺序栈
bool DestroyStack(SqStack &S)
{
    if (S.base)
    {
        delete []S.base;
        S.stacksize = 0;
        S.base = S.top = nullptr;
    }
    return true;
}

bool PushStack(SqStack &S, char e)
{
    if (S.top - S.base == S.stacksize) // 栈满
        return false;
    *S.top++ = e; // 相当于*S.top=e;  S.top++;
    return true;
}

bool PopStack(SqStack &S, char &e)
{
    // 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR
    if (S.top == S.base) // 栈空
        return false;
    e = *--S.top; // 相当于--S.top;   e=*S.top;
    return true;
}

bool GetTop(SqStack S, char &e)
{
    if (S.top == S.base)
        return false; // 栈空
    e = *(S.top - 1);
    return true;
}

void Solve(SqStack &S)
{
    int num = 1;
    // 开辟一个额外的栈
    printf("(%d) 开辟一个额外的栈tmp\n", num++);
    SqStack tmp;
    InitStack(tmp);

    while (!StackEmpty(S))
    {
        // 先取出S的栈顶e
        char e;
        PopStack(S, e);
        printf("(%d) 取出S的栈顶: %c\n", num++, e);
        // 情况1：tmp不空
        while (!StackEmpty((tmp)))
        {
            // 获取tmp 的栈顶
            char t;
            GetTop(tmp, t);
            printf("(%d) 当前栈tmp不空, 获取栈tmp 的栈顶: %c\n", num++, t);
            // 如果 S栈顶 >= tmp栈顶
            if (e >= t)
            {
                // 那么直接把它加入tmp即可
                PushStack(tmp, e);
                printf("(%d) 因为【原来的S栈顶 %c >= 当前tmp栈顶 %c】, 所以把原来的S栈顶 %c 加入tmp \n", num++, e, t, e);
                break;
            }
            // 如果 S栈顶 < tmp栈顶
            else
            {
                // 不断取出tmp栈顶，放入S中（注意：最初的S栈顶e已被取出），直至e可以放入到tmp中
                // 最后使得tmp【一直】呈【降序】排序
                printf("(%d) 因为【原来的S栈顶 %c < 当前tmp栈顶 %c】, 所以取出当前的tmp栈顶 %c 加入栈S中 \n", num++, e, t, t);
                PopStack(tmp, t);
                PushStack(S, t);
            }
        }

        // 情况2：tmp空
        if (StackEmpty(tmp))
        {
            printf("(%d) 当前栈tmp空, 把栈S的栈顶元素 %c 取出并加入到栈tmp中\n", num++, e);
            PushStack(tmp, e); // 直接把S的栈顶元素e放到tmp即可
        }

    }

    // 以上算法结束后，tmp内元素呈【降序】排序，重新将其放入到S中，即可使得S内的元素呈【升序】排序
    printf("(%d) 最后, 重新把栈tmp中的元素放入栈S中: ", num++);
    while (!StackEmpty(tmp))
    {
        char t;
        PopStack(tmp, t);
        PushStack(S, t);
        printf("%c ", t);
    }
    printf("\n");
    // 销毁tmp
    DestroyStack(tmp);
}

int main()
{
    SqStack S;
    if (InitStack(S))
    {
        int N;
        printf("请问需要存放几个元素？\n");
        scanf("%d", &N);
        printf("请输入元素: \n");
        for (int i = 0; i < N; i++)
        {
            char t;
            cin >> t;
            if (!PushStack(S, t))
            {
                printf("空间不足，插入失败！\n");
                return 0;
            }
        }
        printf("\n排序过程: \n");
        Solve(S);
        printf("\n排序后结果为:");
        while (!StackEmpty(S))
        {
            char c;
            PopStack(S, c);
            printf("%c ", c);
        }
        printf("\n");
    }
    
return 0;

}
Vitalis_
关注
数据结构第二次上机 第二章之单链表
Haruno_Sakura的博客
11-04 3178
实验题 2：实现单链表的各种基本运算的算法 2. 编写一个程序linklist.cpp，实现单链表的各种基本运算和整体建表运算（假设单链表的元素类型为char），并在此基础上设计一个程序exp2-2.cpp完成以下功能： （1）初始化单链表h； （2）采用尾插法依次插入元素a，b，c，d，e； （3）输出单链表h； （4）输出单链表h长度； （5）判断单链表h是否为
单链表实验报告
03-11
数据结构实验报告:单链表的建立 1．实验目的 （1）了解数据的逻辑结构和数据的存储结构之间的区别与联系； （2）掌握线性表的链式表示和实现方法，特别是插入、删除操作。 （3）掌握运用C语言上机调试线性表的基本方法。 2．实验内容 （1）建立一个类型为整型链接表的头文件和基本操作，特别是初始化操作、插入操作、删除操作、查找操作、遍历操作等。 （2）创建有10个元素的线性链接表，验证插入、删除、查找操作的结果 3．实验步骤 在微型计算机上调试编写的程序，记录运行结果。
6-62 单链表基本运算算法的实现
最新发布
Y1593578642的博客
08-13 242
/指向后继结点} LinkNode;//单链表结点类型下列各函数签名中，L为带头结点的单链表的头指针，如下图所示：/*** 头插法建立单链表*//*** 尾插法建立单链表*//*** 初始化线性表*//*** 销毁线性表*//*** 判线性表是否为空表。空表返回true，否则返回false。*//*** 求线性表的长度*//*** 输出线性表: 每个数据后面一个空格*//*** 求线性表中第i个元素值。
单链表实验报告（C++）
06-24
单链表的C++实现，实验报告加代码都在里面了，代码分成几个文件的，如果要运行记得分开
数据结构--单链表操作实验报告
04-12
1.从键盘输入顺序任意的5个整数，按有序插入的要求生成第一个有序单链表，将该链表输出显示。 2.再从键盘输入顺序任意的5个整数，按有序插入的要求生成第二个有序单链表，将该链表输出显示。 3.将这两个有序单链表合并成一个有序单链表，要求使用两个单链表的原有空间进行合并，将生成的有序单链表输出显示。
实验报告2 单链表的操作
09-10
单链表的查找、插入与删除。设计算法，实现线性结构上的单链表的产生以及元素的查找、插入与删除。具体实现要求： 1. 从键盘输入10个整数，产生不带表头的单链表，并输入结点值。 2. 从键盘输入1个整数，在单链表中查找该结点的位置。若找到，则显示“找到了”；否则，则显示“找不到”。 3. 从键盘输入2个整数，一个表示欲插入的位置i，另一个表示欲插入的数值x，将x插入在对应位置上，输出单链表所有结点值，观察输出结果。 4. 从键盘输入1个整数，表示欲删除结点的位置，输出单链表所有结点值，观察输出结果。 5. （★）输入两个单链表，将一个单链表连在另一个单链表的后面。 6. （★）已知两个单链表有序，将此两个单链表合并成一个新的有序单链表。
【头歌】第2关：实现单链表各种基本运算的算法 | 数据结构与算法（C语言）
2301_76435948的博客
10-01 1679
单链表的基本运算如下: (1)初始化单链表h (2)依次采用尾插法插入a,b,c,d,e元素 (3)输出单链表h:a b c d e (4)单链表h长度:5 (5)单链表h为非空 (6)单链表h的第3个元素:c (7)元素a的位置:1 (8)在第4个元素位置上插入f元素 (9)输出单链表h:a b c f d e (10)删除h的第3个元素 (11)输出单链表h:a b f d e (12)释放单链表h
数据结构实验报告一.doc
12-13
数据结构实验报告一 数据结构实验报告一是一个典型的数据结构实验报告，涵盖了非循环单链表的存储和操作。该实验报告旨在帮助学生掌握线性表链式存储情况下的基本特征，并学会在实践中利用这种方式完成对一些有前后...
西北工业大学数据结构实验报告
07-12
包含11次数据结构实验报告以及配套代码，结构完整，符合要求，实验成绩97分。 啰嗦几句： 更加建议大家自己写，我这个更多的是自己的资源存档 有问题的话私信，看到会回复 关于代码，因为当时比较仓促，还没有进行...
数据结构实验报告答案.pdf
08-22
数据结构实验报告答案
数据结构实验迷宫问题实验报告
11-18
数据结构实验迷宫问题实验报告 本实验报告主要是关于数据结构实验中的迷宫问题，通过设计数据结构存储迷宫、设计存储结构保存从入口到出口的通路、设计算法完成迷宫问题的求解，并分析算法的时间复杂度。 首先，...
数据结构实验报告.zip
05-24
数据结构实验报告.zip 数据结构实验报告.zip 数据结构实验报告.zip 数据结构实验报告.zip 数据结构实验报告.zip 数据结构实验报告.zip 数据结构实验报告.zip 数据结构实验报告.zip 数据结构实验报告.zip 数据结构...
【C语言】数据结构实验报告--单链表
qq_62775411的博客
10-18 3976
【C语言】数据结构实验报告--单链表
数据结构实验报告单链表的基本操作
热门推荐
moonlululu的博客
02-15 1万+
错误1 public void add(int idx,AnyType x){ Node newNode=new Node(x); if(headNode==null||idx==0){ newNode.next=headNode; headNode=newNode; theSize++; } else{ Node p=getNode(idx-1);//如果此处写成idx就会把第
c语言单链表设计报告,单链表实验报告
weixin_34489135的博客
05-18 5979
《数据结构》实验报告二分校：学号：日期：班级：姓名：程序名： L2311.CPP一、上机实验的问题和要求：单链表的查找、插入与删除。设计算法，实现线性结构上的单链表的产生以及元素的查找、插入与删除。具体实现要求：1. 从键盘输入20个整数，产生带表头的单链表，并输入结点值。2. 从键盘输入1个整数，在单链表中查找该结点。若找到，则显示“找到了”；否则，则显示“找不到”。3. 从键盘输入2个整数，一...
c语言单链表设计报告,单链表的实现实验报告.doc
weixin_34393451的博客
05-18 1997
单链表的实现实验报告篇一：数据结构单链表实验报告一、 设计人员相关信息1. 设计者姓名、学号和班号：12地信李晓婧 120122429832. 设计日期：2014.3. 上机环境：VC++6.0二、 程序设计相关信息1. 实验题目：编写一个程序，实现单链表的各种基本运算(假设单链表的元素类型为char)，并在此基础上设计一个程序，完成如下功能：(1) 初始化单链表；(2) 采用尾插法依次插入元素a...
c语言 链表 实验报告,实验1单链表实验报告.doc
weixin_42360722的博客
05-19 2226
实验1单链表实验报告实验一 单链表实验目的掌握单链表中元素的前驱、后续的概念。掌握单链表的建立、插入元素、删除表中某元素的算法。3、对单链表相应算法的时间复杂度进行分析。4、理解单链表数据结构的特点(优缺点)。二、实验内容说明以下概念单链表：用一组任意的存储单元存储线性表的数据元素。以元素(数据元素的映象) + 指针(指示后继元素存储位置) = 结点 (表示数据元素或数据元素的映象)结点和单链...
数据结构实验报告 链表
喵头鹰的博客
04-17 1万+
一、实验目的（1）掌握线性表的基本运算在两种存储结构（顺序结构和链式结构）上的实现； （2）掌握线性表的各种操作（建立、插入、删除等）的实现算法；二、实验仪器及环境：PC计算机 windows 7操作系统 CodeBlocks10.05三、实验内容及结果（按照具体实验题目，按照如下格式书写）1．随机产生或键盘输入一组元素，建立一个带头结点的单向链表（无序）。 2．遍历单向链表。 3．把单向链
单链表的实现和部分操作实验报告2（含完整代码）
xiongshuxian2019的博客
03-11 9786
仅供参考，记得看看自己班的课代表有没有发模板哦2333 实 验 报 告 课 程： 数据结构 班 级： 实验序号： 1 姓 名： 学 号: 实验日期： 题 目: 单链表基本操作的实现 一、实验目的和要求 ①熟悉C语言的上机环境，进一步掌握C语言的结构特点。 ②熟练掌握单链表的结构特点和基本操作。 ③学会使用单链表解决实际问题。 二、实验环境 Windows2000 ,VB 三、实验内容及实施 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值