2021秋季《数据结构》_第一章书面作业

已于 2022-02-06 13:55:59 修改
阅读量380 收藏 1
点赞数
分类专栏： 数据结构 文章标签： 数据结构 链表 算法
于 2021-10-13 19:49:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rd142857/article/details/120750914
版权
这篇博客涵盖了几个关于链表的操作，包括如何逆转单链表、在单链表中插入新节点以及如何合并两个有序的环形链表。逆转链表的函数通过迭代法实现，插入函数允许在找到特定值节点前插入新节点，而合并环形链表的函数则创建了一个新的有序环形链表。此外，还讨论了广义表的深度计算问题，提供了相应的C函数实现。
摘要由CSDN通过智能技术生成

代码

  1. 编写一个将给定的线性单链表逆转的函数，只允许改变结点的指针值，不允许移动结点值，返回逆转后的链表的头指针。

    Node* reverse_Linklist(Node* head)
// 带头结点
{
    // 空表返回头结点
    if(!head->next) return head;
    else
    {
        Node* p = head->next;
        Node* tmp = NULL;       // 待修改指针的结点
        Node* front = NULL;     // 存放tmp的上一个结点
                                // 由于尾结点指向NULL，初始化为NULL
        while (p->next)
        {
            tmp = p;
            p = p->next;
            tmp->next = front;  // 指向上一个结点
            front = tmp;        // 更新front
        }
        p->next = front;        // 修改尾结点的指针
        head->next = p;         // 头结点指向原来的尾结点
        return head;
    }
}

  2. 对于给定的单链表，编写一个把值为 a 的结点插在值为 b 的结点的前面的函数。若值为b的结点不在线性链表中，则把 a 插在链表的最后。若有多个值为 b 的结点，则插在第一个出现的 b 结点之前。

    Node* insertLinklist_t2(Node* head, int a, int b)
// 把值为 a 的结点插在值为 b 的结点前面
{
    if(!head->next) return head;
    else
    {
        Node* tmp = new Node;
        tmp->data = a;
        Node* p = head;
        while (p->next)  // 找值为b的结点
        {
            if(p->next->data==b)
                break;
            p = p->next;
        }
        tmp->next = p->next;
        p->next = tmp;
        return head;
    }
}

  3. （已改正）假设 A 和 B 是两个按结点值从小到大排列的有序环形链表（带表头结点，表头结点中不存放有效信息）。试编写一个将这两个有序的环形链表归并为一个按节点值从小到大排列的有序环形链表的 C 函数。

Node* MergeLinkList(Node* head1, Node* head2)
{
    Node* p1 = head1->next;
    Node* p2 = head2->next;
    Node* head = p1->data<p2->data? head1:head2;            // 挑选首结点较小的头结点作为头结点
    Node* front = head;                                     // 记录当前结点，作为遍历时结点的上一个结点
    while (p1!=head1 && p2!=head2)
    {
        if(p1->data<p2->data)
        {
            front->next = p1;                             
            front = p1;
            p1 = p1->next;
        }
        else
        {
            front->next = p2;
            front = p2;
            p2 = p2->next;
        }
    }

    while(p1!=head1)
    {
        front->next = p1;
        front = p1;
        p1 = p1->next;
    }  
    
    while (p2!=head2)
    {
        front->next = p2;
        front = p2;
        p2 = p2->next;
    }
    
    front->next = head;
    
    return head;
}

  1. 求广义表的深度。我们规定空的广义表的深度为 0，而一般地有
    d e p t h ( s ) = { 1 , 若 s 是 一 个 原 子 1 + m a x { d e p t h ( a 0 ) , ⋯   , d e p t h ( a n − 1 ) , 若 s 是 广 义 表 ( a 0 , a 1 , ⋯   , a n − 1 ) } depth(s)= \begin{cases} 1, & 若s是一个原子 \\ 1+max\{depth(a_0),\cdots,depth(a_{n-1}), & 若s是广义表(a_0, a_1, \cdots, a_{n-1})\} \end{cases} depth(s)={1,1+max{depth(a0​),⋯,depth(an−1​),​若s是一个原子若s是广义表(a0​,a1​,⋯,an−1​)}​
    编写一个求解广义表 s s s的深度的C函数。

    • 思考

      1. 如果是一个递归表，你的函数会输出什么结果？

        广义表 C = ( a , C ) C=(a, C) C=(a,C)， a a a为原子， C C C为一个广义表

      2. 在写递归程序时，需要特别注意哪些情况？

    int glistDepth(GNode* C)
{
    if (!C)  // 如果C为空表，返回长度0
    {
        return 0;
    }
    if (C->tag == 0)
    // 如果C为原子，返回长度1
    {
        return 1;
    }
    int max = 0;
    for (GNode* p = C; p; p = p->ptr.tp)
    // 遍历每一个子表，寻找最大深度
    {
        int depth = glistDepth(p->ptr.hp);
        if (max < depth) max = depth;
    }
    return max+1;
}

    注意判断空表情况
注意判断递归终止条件：子表为原子的情况

附录

测试代码：

  1. #include<bits/stdc++.h>
using namespace std;

typedef struct  node
{
    int data;
    struct node* next;
}Node;

Node* initLinklist(Node* head)
{
    head = new Node;
    head->data = 0;
    head->next = NULL;
    return head;
}

Node* insertLinklist(Node* head, int n)
// 尾插
{
    Node* L = head;
    for(int i = 0; i < n; i++)
    {
        Node* p = new Node;
        cin>>p->data;
        p->next = NULL;
        L->next = p;
        L = p;
    }
    return head;
}

void printLinklist(Node* head)
{
    Node* p = head->next;
    while (p)
    {
        cout<<p->data<<' ';
        p = p->next;
    }
    cout<<endl;
    
}

Node* reverse_Linklist(Node* head)
// 带头结点
{
    // 空表返回头结点
    if(!head->next) return head;
    else
    {
        Node* p = head->next;
        Node* tmp = NULL;       // 待修改指针的结点
        Node* front = NULL;     // 存放tmp的上一个结点
                                // 由于尾结点指向NULL，初始化为NULL
        while (p->next)
        {
            tmp = p;
            p = p->next;
            tmp->next = front;  // 指向上一个结点
            front = tmp;        // 更新front
        }
        p->next = front;        // 修改尾结点的指针
        head->next = p;         // 头结点指向原来的尾结点
        return head;
    }
}

int main()
{
    Node* head;
    head = initLinklist(head);
    cout<<"Please enter the number of elements"<<endl;
    int n; cin>>n;
    cout<<"Please enter the values(>0) of elements"<<endl;
    insertLinklist(head, n);
    cout<<"The original order is:"<<endl;
    printLinklist(head);
    reverse_Linklist(head);
    cout<<"The reversed order is:"<<endl;
    printLinklist(head);
    system("pause");
    return 0;
}

  2. #include<bits/stdc++.h>
using namespace std;

typedef struct  node
{
    int data;
    struct node* next;
}Node;

Node* initLinklist(Node* head)
{
    head = new Node;
    head->data = 0;
    head->next = NULL;
    return head;
}

Node* insertLinklist(Node* head, int n)
{
    Node* L = head;
    for(int i = 0; i < n; i++)
    {
        Node* p = new Node;
        cin>>p->data;
        p->next = NULL;
        L->next = p;
        L = p;
    }
    return head;
}

Node* insertLinklist_t2(Node* head, int a, int b)
// 把值为 a 的结点插在值为 b 的结点前面
{
    if(!head->next) return head;
    else
    {
        Node* tmp = new Node;
        tmp->data = a;
        Node* p = head;
        while (p->next)  // 找值为b的结点
        {
            if(p->next->data==b)
                break;
            p = p->next;
        }
        tmp->next = p->next;
        p->next = tmp;
        return head;
    }
}

void printLinklist(Node* head)
{
    Node* p = head->next;
    while (p)
    {
        cout<<p->data<<' ';
        p = p->next;
    }
    cout<<endl;
    
}

int main()
{
    Node* head;
    head = initLinklist(head);
    cout<<"Please enter the number of elements"<<endl;
    int n; cin>>n;
    cout<<"Please enter the values(>0) of elements"<<endl;
    insertLinklist(head, n);
    cout<<"The original order is:"<<endl;
    printLinklist(head);
    insertLinklist_t2(head, 1, 2);
    cout<<"The inserted order is:"<<endl;
    printLinklist(head);
    system("pause");
    return 0;
}

  3. #include<bits/stdc++.h>
using namespace std;

typedef struct  node
{
    int data;
    struct node* next;
}Node;

Node* initCircularList(Node* head)
{
    head = new Node;
    head->data = 0;
    head->next = head;
    return head;
}

Node* insertCircularList(Node* head, int n)
// 尾插
{
    Node* L = head;
    for(int i = 0; i < n; i++)
    {
        Node* p = new Node;
        cin>>p->data;
        p->next = L->next;
        L->next = p;
        L = p;
    }
    return head;
}

Node* MergeLinkList(Node* head1, Node* head2)
{
    Node* p1 = head1->next;
    Node* p2 = head2->next;
    Node* head = p1->data<p2->data? head1:head2;            // 挑选首结点较小的头结点作为头结点
    Node* front = head;                                     // 记录当前结点，作为遍历时结点的上一个结点
    while (p1!=head1 && p2!=head2)
    {
        if(p1->data<p2->data)
        {
            front->next = p1;                             
            front = p1;
            p1 = p1->next;
        }
        else
        {
            front->next = p2;
            front = p2;
            p2 = p2->next;
        }
    }

    while(p1!=head1)
    {
        front->next = p1;
        front = p1;
        p1 = p1->next;
    }  
    
    while (p2!=head2)
    {
        front->next = p2;
        front = p2;
        p2 = p2->next;
    }
    
    front->next = head;
    
    return head;
}

void printCircularList(Node* head)
{
    Node* p = head->next;
    while (p!=head)
    {
        cout<<p->data<<' ';
        p = p->next;
    }
    cout<<endl;
}


int main()
{
    Node* head1, *head2;
    head1 = initCircularList(head1);
    head2 = initCircularList(head2);
    cout<<"Please enter the number of elements in list1:"<<endl;
    int n1; cin>>n1;
    cout<<"Please enter the values of elements in list1:"<<endl;
    insertCircularList(head1, n1);
    cout<<"The original order of list1 is:"<<endl;
    printCircularList(head1);
    cout<<"Please enter the number of elements in list2:"<<endl;
    int n2; cin>>n2;
    cout<<"Please enter the values of elements in list2:"<<endl;
    insertCircularList(head2, n2);
    cout<<"The original order of list2 is:"<<endl;
    printCircularList(head2);
    cout<<"The merged list is:"<<endl;
    Node* head = MergeLinkList(head1, head2);
    printCircularList(head);
    

    system("pause");
    return 0;
}

// 3
// 1 4 6
// 4
// 2 3 5 7


  4. #include<bits/stdc++.h>
using namespace std;

typedef struct node
{
	int tag;
	union
	{
		char atom;
		struct
		{
			struct node* hp, * tp;
		}ptr;
	};
}GNode, *Glist;

Glist creatGlist(Glist C) {
    //广义表C
    C = (Glist)malloc(sizeof(Glist));
    C->tag = 1;
    //表头原子‘a’
    C->ptr.hp = (Glist)malloc(sizeof(Glist));
    C->ptr.hp->tag = 0;
    C->ptr.hp->atom = 'a';
    //表尾子表（b,c,d）,是一个整体
    C->ptr.tp = (Glist)malloc(sizeof(Glist));
    C->ptr.tp->tag = 1;
    C->ptr.tp->ptr.hp = (Glist)malloc(sizeof(Glist));
    C->ptr.tp->ptr.tp = NULL;
    //开始存放下一个数据元素（b,c,d）,表头为‘b’，表尾为（c,d）
    C->ptr.tp->ptr.hp->tag = 1;
    C->ptr.tp->ptr.hp->ptr.hp = (Glist)malloc(sizeof(Glist));
    C->ptr.tp->ptr.hp->ptr.hp->tag = 0;
    C->ptr.tp->ptr.hp->ptr.hp->atom = 'b';
    C->ptr.tp->ptr.hp->ptr.tp = (Glist)malloc(sizeof(Glist));
    //存放子表(c,d)，表头为c，表尾为d
    C->ptr.tp->ptr.hp->ptr.tp->tag = 1;
    C->ptr.tp->ptr.hp->ptr.tp->ptr.hp = (Glist)malloc(sizeof(Glist));
    C->ptr.tp->ptr.hp->ptr.tp->ptr.hp->tag = 0;
    C->ptr.tp->ptr.hp->ptr.tp->ptr.hp->atom = 'c';
    C->ptr.tp->ptr.hp->ptr.tp->ptr.tp = (Glist)malloc(sizeof(Glist));
    //存放表尾d
    C->ptr.tp->ptr.hp->ptr.tp->ptr.tp->tag = 1;
    C->ptr.tp->ptr.hp->ptr.tp->ptr.tp->ptr.hp = (Glist)malloc(sizeof(Glist));
    C->ptr.tp->ptr.hp->ptr.tp->ptr.tp->ptr.hp->tag = 0;
    C->ptr.tp->ptr.hp->ptr.tp->ptr.tp->ptr.hp->atom = 'd';
    C->ptr.tp->ptr.hp->ptr.tp->ptr.tp->ptr.tp = NULL;
    return C;
}

int glistDepth(GNode* C)
{
    if (!C)  // 如果C为空表，返回长度0
    {
        return 0;
    }
    if (C->tag == 0)
    // 如果C为原子，返回长度1
    {
        return 1;
    }
    int max = 0;
    for (GNode* p = C; p; p = p->ptr.tp)
    // 遍历每一个子表，寻找最大深度
    {
        int depth = glistDepth(p->ptr.hp);
        if (max < depth) max = depth;
    }
    return max+1;

}

int main()
{
    GNode* C = NULL;
    C = creatGlist(C);
    cout << glistDepth(C) << endl;
	return 0;
}
rd142857
关注
专栏目录
（PTA）数据结构（作业）1、基本概念
Misasagi Inori的博客
03-10 5236
作业，仅供参考，欢迎指正，轻喷谢谢
数据结构书面作业1
12-07
一、选择题 1. 在线性结构中，第一个结点没有前驱结点，其余每个结点有且只有 （ ） 个前驱结点；最后一个结点没有后继结点，其余每个结点有且只有（ ）个后继结点。 A. 1 , 1 B. 1 , 2 C. 2 , 1 D. 2 , 2 2. 线性表若采用链式存储结构时，要求内存中可用存储单元的地址___。 A. 必须是连续的 B. 部分地址必须是连续的 C. 一定是不连续的 D. 连续或不连续都可以
2021秋季《数据结构》_第六章书面作业（基础练习）
rd142857的博客
12-06 708
二叉查找树 输入为一组未排序的结点序列（类型为整数，用做结点的键值），生成由它们作结点键值 的一棵查找树（结点未排序，依次插入树中）。 中序输出这棵查找树。 判断这棵查找树是否平衡。 计算这棵查找树查找结点的平均比较次数（假设每个结点的使用概率相同，且每次查找 都是一次成功的查找）。 参考公式： AVG（二叉查找法）= ∑树中的????????(????)(???? + ????????) 输入格式： 第一行输入一个正整数???? (???? ≤ 1000)表示结点数量。 第二行输入 n 个整数表示未排序
2021秋季《数据结构》_第三章书面作业
rd142857的博客
11-03 316
测试代码见附录 题目 对于给定的线性表，A=(12,2,16,30,8,28,4,10,20)，分别写出用下列排序方法对 A 进行排序时，每一趟处理后的结果。 插入排序 2 12 16 30 8 28 4 10 20 2 12 16 30 8 28 4 10 20 2 12 16 30 8 28 4 10 20 2 8 12 16 30 28 4 10 20 2 8 12 16 28 30 4 10 20 2 4 8 12 16 28 30 10 20 2 4 8 10 12 16 28 30 .
链表从指定节点前（后）插入（3）
m0_57440581的博客
11-23 707
链表插入
西南交通大学2020秋季_数据结构第5次作业
12-30
在这个西南交通大学2020秋季学期的数据结构第5次作业中，主要涵盖了查找和内部排序两大主题。 一、查找 1. 对分查找算法：这是一种在有序数组中查找特定元素的高效方法。在已知n元顺序表（数组）按关键字递增有序...
修井工程2021年秋_第一阶段在线作业全对答案.docx
10-15
这份2021年秋季第一阶段的在线作业提供了关于这些关键知识点的解答。 首先，井身结构中的第一层套管被称为导管，它的主要作用是引导钻具进入井眼，并保护井壁。最常用的完井方法是射孔完井，包括套管射孔和尾管射孔...
东北大学21秋季 《数据结构ⅱ》在线平时作业1 参考答案.pdf
最新发布
04-17
数据结构是计算机科学中至关重要的一个分支，它研究如何在计算机中有效地组织和存储数据，以便于高效地访问和操作。本题涉及的数据结构相关知识点包括图的存储、排序算法、数据结构的基本概念以及特定操作的实现。 ...
数据结构复习笔记(西南交通大学2020秋季学期数据结构A)-Keller_Wang.pdf
01-09
而且考察的很多知识点其实不需要对算法和数据结构本身有很深入的了解就可以解决，因此就考虑写这么一篇笔记，主要希望能够帮助大家快速并全面的应对数据结构A课程的期末考试。 ​ 本文更侧重与对各个知识点对应的**...
设A和B是两个单链表，其表中元素递增有序
11-29
设A和B是两个单链表，其表中元素递增有序。试写一算法将A和B归并成一个按元素值递减有序的单链表C，并要求辅助空间为O(1),试分析算法的时间复杂度。
数据结构复习笔记(西南交通大学2020秋季学期数据结构A)V1.2-Keller_Wang.pdf
01-09
用于西南交通大学2020秋季学期的数据结构A课程的期末考试复习： ​写这个笔记的初衷是因为老师发的ppt中并没有对于各个例题的过多解答，而且考察的很多知识点其实不需要对算法和数据结构本身有很深入的了解就可以...
C语言算法基础-在一个单链表中值为y的结点前面插入一个值为x的结点
海风依旧
11-17 6037
C语言算法基础-在一个单链表中值为y的结点前面插入一个值为x的结点
数据结构C语言版（李云清）实验3 带头结点的单链表
热门推荐
CSDNadmin00的博客
12-28 1万+
实验3 带头结点的单链表 1、编写函数void delx(linklist head, datatype x)，删除带头结点单链表head中第一个值为x 的结点。 并构造测试用例进行测试。 /**********************************/ /*文件名称：lab3_01.c */ /******************************...
【期末不挂科 数据结构】第二章 线性表
qq_62902169的博客
11-23 668
首先说明一下 期末不挂科 系列专为零基础计算机小白所写，因而不会涉及太多较难问题，基本上都是书本中的知识点和一些简单例题，建议搭配系列习题（会有详解~）作为巩固练习，预祝大家期末考试都不挂科，取得一个好成绩~
算法与数据结构之带头结点的单链表
谁D了我的BUG
01-01 2807
单链表的定义 #include&amp;amp;amp;amp;lt;stdio.h&amp;amp;amp;amp;gt; #include&amp;amp;amp;amp;lt;malloc.h&amp;amp;amp;amp;gt; #include&amp;amp;amp;amp;lt;stdlib.h&amp;amp;amp;amp;gt; typedef struct Node { int data; //数据域 struct
《数据结构与算法》 第2章 线性表——习题
weixin_45705159的博客
05-17 693
1.请编写一个倒置顺序表的算法，要求算法的时间复杂性为O(n)，空间复杂性为O(1)。n是顺序表的长度。 #include <stdio.h> #define MAXN 100 void turn(int List[],int *p_len) { if (*p_len<0||*p_len>MAXN) printf("数组越界"); else{ for (int i=0;i<=*p_len/2;i++) { int tmp = List[i]; L
第九章：链表
霹雳游侠
08-25 820
我们需要设计一种新的表数据结构，这种数据结构允许元素分散于内存的各个位置，并不强求他们都在一个连续的内存块里。为了建立表元素之间的链接，每个元素结构都要包含指向临近元素在内存中位置的指针。这种结构叫做链表。 9.1 链表节点 要在计算机上实现链表，第一步就是建立节点结构。在节点结构中，包括数据（称作nodeValue）和一个指针（next），她指向序列中的下一个节点。 一般来说，类的数据成员应该声明为private的，通过public的成员函数来访问和更新他们。但是，node类只是为实现单向链表而设计
常见c++面试题
furuidelei123的专栏
08-14 1316
 SIZEOF CONST 预处理题目:1. sizeof相关系列问题 a. 对于 struct s{char a;int b};  sizeof(s) = 8; 因为当结构体内元素长度都小于处理器位数（32位＝4字节）的时候，便以结构体中最长的数据元素为对齐条件,a 按 1 字节对齐，b 按 4 字节对齐，所以s默认对其参数为8  struct A{short a1;short a2;s
数据结构作业：查找与排序算法挑战
"西南交通大学2020秋季的数据结构第5次作业，涉及查找和排序相关的知识点，包括对分查找、平衡二叉排序树、B-树、哈希表、内部排序（插入排序、冒泡排序的递归实现）以及链式基数排序。" 在本次数据结构作业中，...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值