数据结构习题解析与实验指导第二章课后算法设计题

最新推荐文章于 2023-06-15 18:33:15 发布
最新推荐文章于 2023-06-15 18:33:15 发布
阅读量1k 收藏 21
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013749051/article/details/108213469
版权
  1. 将两个递增的有序列表合并为一个递增的有序链表。要求结果链表仍使用原来两个链表的存储空间，不另外占用存储空间。表中不允许有重复的数据。
#include <iostream>
#include <string>
#include <iomanip>
using namespace std;

class Node {
public:
    int data;
    Node* next;
    Node(int data = 0, Node* next = 0): data(data), next(0) {
    }
};

void add(Node* head, Node* node) {
    for (Node* i = head; i != 0; i = i->next) {
        if (i->next == 0) {
            i->next = node;
            break;
        }
    }
}

void clear(Node* head) {
    while (head->next != 0) {
        Node* temp = head->next;
        head->next = head->next->next;
        delete temp;
    }
}

void display(Node* head) {
    head = head->next;
    while (head != 0) {
        cout << head->data << " ";
        head = head->next;
    }
    cout << endl;
}

Node* combine(Node* list1, Node* list2) {
    Node* head = list1;
    Node* tail = list1;
    list1 = list1->next;
    list2 = list2->next;
    while (list1 != 0 && list2 != 0)
    {
        if (list1->data < list2->data) {
            tail->next = list1;
            tail = tail->next;
            list1 = list1->next;
        }
        else if (list1->data == list2->data) {
            tail->next = list1;
            tail = tail->next;
            Node* temp = list2;
            list1 = list1->next;
            list2 = list2->next;
            delete temp;
        }
        else {
            tail->next = list2;
            tail = tail->next;
            list2 = list2->next;
        }
    }

    if (list1 != 0) {
        tail->next = list1;
    }

    if (list2 != 0) {
        tail->next = list2;
    }

    return head;
}

int main() {
    
    Node list1, list2;
    add(&list1, new Node(1));
    add(&list1, new Node(2));
    add(&list1, new Node(3));
    add(&list1, new Node(4));
    add(&list1, new Node(5));
    add(&list2, new Node(3));
    add(&list2, new Node(5));
    add(&list2, new Node(7));
    add(&list2, new Node(8));
    add(&list2, new Node(9));
    display(&list1);
    display(&list2);
    Node* combined = combine(&list2, &list1);
    display(combined);
    clear(combined);
    return 0;
}

在这里插入图片描述
2. 将两个非递减的有序链表合并为一个非递增的有序链表。要求结果链表仍使用原来两个链表的存储空间，不另外占用存储空间。表中允许有重复的数据。

#include <iostream>
#include <string>
#include <iomanip>

using namespace std;

class Node {
public:
    int data;
    Node* next;
    Node(int data = 0, Node* next = 0): data(data), next(0) {
    }
};

void add(Node* head, Node* node) {
    for (Node* i = head; i != 0; i = i->next) {
        if (i->next == 0) {
            i->next = node;
            break;
        }
    }
}

void clear(Node* head) {
    while (head->next != 0) {
        Node* temp = head->next;
        head->next = head->next->next;
        delete temp;
    }
}

void display(Node* head) {
    head = head->next;
    while (head != 0) {
        cout << head->data << " ";
        head = head->next;
    }
    cout << endl;
}

Node* combine(Node* list1, Node* list2) {
    Node* head = list1;
    Node* tail = list1;
    list1 = list1->next;
    list2 = list2->next;
    while (list1 != 0 && list2 != 0)
    {
        if (list1->data <= list2->data) {
            tail->next = list1;
            tail = tail->next;
            list1 = list1->next;
        }
        else {
            tail->next = list2;
            tail = tail->next;
            list2 = list2->next;
        }
    }

    if (list1 != 0) {
        tail->next = list1;
    }

    if (list2 != 0) {
        tail->next = list2;
    }

    return head;
}

void reverse(Node* head) {
    Node* lastItem = 0;
    for (Node* i = head->next; i != 0; ) {
        Node* temp = i;
        i = i->next;
        if (temp->next == 0) {
            head->next = temp;
        }
        temp->next = lastItem;
        lastItem = temp;
    }
}

int main() {
    Node list1, list2;
    add(&list1, new Node(1));
    add(&list1, new Node(2));
    add(&list1, new Node(3));
    add(&list1, new Node(4));
    add(&list1, new Node(5));
    add(&list2, new Node(3));
    add(&list2, new Node(5));
    add(&list2, new Node(7));
    add(&list2, new Node(8));
    add(&list2, new Node(9));
    display(&list1);
    display(&list2);
    Node* combined = combine(&list2, &list1);
    reverse(combined);
    display(combined);
    clear(combined);
    return 0;
}

在这里插入图片描述
3. 已知链表A和B分表表示两个集合，其元素递增排列。请设计一个算法，用于求出A和B交集并存放在A链表中。

#include <iostream>
#include <string>
#include <iomanip>

using namespace std;

class Node {
public:
    int data;
    Node* next;
    Node(int data = 0, Node* next = 0): data(data), next(0) {
    }
};

void add(Node* head, Node* node) {
    for (Node* i = head; i != 0; i = i->next) {
        if (i->next == 0) {
            i->next = node;
            break;
        }
    }
}

void clear(Node* head) {
    while (head->next != 0) {
        Node* temp = head->next;
        head->next = head->next->next;
        delete temp;
    }
}

void display(Node* head) {
    head = head->next;
    while (head != 0) {
        cout << head->data << " ";
        head = head->next;
    }
    cout << endl;
}

void intersect(Node* list1, Node* list2) {
    Node* p1 = list1->next;
    Node* p2 = list2->next;
    while (p1 != 0 && p2 != 0)
    {
        if (p1->data < p2->data) {
            Node* temp = p1;
            p1 = p1->next;
            delete temp;
        }
        else if (p1->data > p2->data) {
            p2 = p2->next;
        }
        else {
            list1->next = p1;
            list1 = list1->next;
            p1 = p1->next;
            p2 = p2->next;
        }
    }
    list1->next = 0;
}

int main() {
    Node list1, list2;
    add(&list1, new Node(1));
    add(&list1, new Node(2));
    add(&list1, new Node(3));
    add(&list1, new Node(4));
    add(&list1, new Node(5));
    add(&list2, new Node(3));
    add(&list2, new Node(5));
    add(&list2, new Node(7));
    add(&list2, new Node(8));
    add(&list2, new Node(9));
    display(&list1);
    display(&list2);
    intersect(&list2, &list1);
    display(&list2);
    clear(&list1);
    clear(&list2);
    return 0;
}

在这里插入图片描述
4.已知链表A和B分表表示两个集合，其元素递增排列。请设计算法求出两个集合A和B的差集（即仅由在A中出现而不在B中出现的的元素所构成的集合），并以同样的形式存储，同时返回该集合元素的个数。

#include <iostream>
#include <string>
#include <iomanip>

using namespace std;

class Node {
public:
    int data;
    Node* next;
    Node(int data = 0, Node* next = 0): data(data), next(0) {
    }
};

void add(Node* head, Node* node) {
    for (Node* i = head; i != 0; i = i->next) {
        if (i->next == 0) {
            i->next = node;
            break;
        }
    }
}

void clear(Node* head) {
    while (head->next != 0) {
        Node* temp = head->next;
        head->next = head->next->next;
        delete temp;
    }
}

void display(Node* head) {
    head = head->next;
    while (head != 0) {
        cout << head->data << " ";
        head = head->next;
    }
    cout << endl;
}

int substract(Node* list1, Node* list2) {
    Node* p1 = list1->next;
    Node* p2 = list2->next;
    int count = 0;
    while (p1 != 0 && p2 != 0)
    {
        if (p1->data < p2->data) {
            list1->next = p1;
            list1 = list1->next;
            count++;
            p1 = p1->next;
        }
        else if (p1->data > p2->data) {
            p2 = p2->next;
        }
        else {
            Node* temp = p1;
            p1 = p1->next;
            p2 = p2->next;
            delete temp;
        }
    }
    while (p1 != 0)
    {
        list1->next = p1;
        list1 = list1->next;
        p1 = p1->next;
        count++;
    }
    list1->next = 0;
    return count;
}

int main() {
    Node list1, list2;
    add(&list1, new Node(1));
    add(&list1, new Node(2));
    add(&list1, new Node(3));
    add(&list1, new Node(4));
    add(&list1, new Node(5));
    add(&list2, new Node(3));
    add(&list2, new Node(5));
    add(&list2, new Node(7));
    add(&list2, new Node(8));
    add(&list2, new Node(9));
    display(&list1);
    display(&list2);
    int count = substract(&list2, &list1);
    display(&list2);
    cout << "remain size: " << count << endl;
    clear(&list1);
    clear(&list2);
    return 0;
}

在这里插入图片描述
5. 设计算法将一个带头结点的单链表A分解为两个具有相同结构的链表B和C，其中B表的结点为A表中值小于0的结点，而C表的结点为A表中值大于0的结点（链表A中的元素为非0整数，要求B、C表利用A表的结点）。

#include <iostream>
#include <string>
#include <iomanip>

using namespace std;

class Node {
public:
    int data;
    Node* next;
    Node(int data = 0, Node* next = 0): data(data), next(0) {
    }
};

void add(Node* head, Node* node) {
    for (Node* i = head; i != 0; i = i->next) {
        if (i->next == 0) {
            i->next = node;
            break;
        }
    }
}

void clear(Node* head) {
    while (head->next != 0) {
        Node* temp = head->next;
        head->next = head->next->next;
        delete temp;
    }
}

void display(Node* head) {
    head = head->next;
    while (head != 0) {
        cout << head->data << " ";
        head = head->next;
    }
    cout << endl;
}

void split(Node* head, Node* list1, Node* list2) {
    for (Node* i = head->next; i != 0; i = i->next)
    {
        if (i->data < 0) {
            list1->next = i;
            list1 = list1->next;
        }
        else {
            list2->next = i;
            list2 = list2->next;
        }
    }
    head->next = 0;
    list1->next = 0;
    list2->next = 0;
}

int main() {
    Node head, list1, list2;
    add(&head, new Node(-1));
    add(&head, new Node(5));
    add(&head, new Node(-2));
    add(&head, new Node(6));
    add(&head, new Node(-3));
    add(&head, new Node(7));
    add(&head, new Node(-4));
    display(&head);
    split(&head, &list1, &list2);
    display(&list1);
    display(&list2);
    clear(&list1);
    clear(&list2);
    return 0;
}

在这里插入图片描述

  1. 设计一个算法，通过一趟遍历确定长度为n的单链表中值最大的结点，返回该结点的数据域。
#include <iostream>
#include <string>
#include <iomanip>

using namespace std;

class Node {
public:
    int data;
    Node* next;
    Node(int data = 0, Node* next = 0): data(data), next(0) {
    }
};

void add(Node* head, Node* node) {
    for (Node* i = head; i != 0; i = i->next) {
        if (i->next == 0) {
            i->next = node;
            break;
        }
    }
}

void clear(Node* head) {
    while (head->next != 0) {
        Node* temp = head->next;
        head->next = head->next->next;
        delete temp;
    }
}

void display(Node* head) {
    head = head->next;
    while (head != 0) {
        cout << head->data << " ";
        head = head->next;
    }
    cout << endl;
}

int max(Node* head) {
    head = head->next;
    int maxValue = head->data;
    while (head != 0)
    {
        if (head->data > maxValue) {
            maxValue = head->data;
        }
        head = head->next;
    }
    return maxValue;
}

int main() {
    Node head;
    add(&head, new Node(-1));
    add(&head, new Node(5));
    add(&head, new Node(-2));
    add(&head, new Node(6));
    add(&head, new Node(-3));
    add(&head, new Node(7));
    add(&head, new Node(-4));
    display(&head);
    cout << "max in it: " << max(&head) << endl;
    clear(&head);
    return 0;
}

在这里插入图片描述
7. 设计一个算法，将链表中所有结点中的链接方向原地逆转，即要求利用原表中的存储空间，换句话说，要求算法的空间复杂度为O(1)。

#include <iostream>
#include <string>
#include <iomanip>

using namespace std;

class Node {
public:
    int data;
    Node* next;
    Node(int data = 0, Node* next = 0): data(data), next(0) {
    }
};

void add(Node* head, Node* node) {
    for (Node* i = head; i != 0; i = i->next) {
        if (i->next == 0) {
            i->next = node;
            break;
        }
    }
}

void clear(Node* head) {
    while (head->next != 0) {
        Node* temp = head->next;
        head->next = head->next->next;
        delete temp;
    }
}

void display(Node* head) {
    head = head->next;
    while (head != 0) {
        cout << head->data << " ";
        head = head->next;
    }
    cout << endl;
}

void reverse(Node* head) {
    Node* last = 0;
    Node* curr = head->next;
    while (curr != 0) {
        Node* temp = curr;
        curr = curr->next;
        temp->next = last;
        last = temp;
        if (curr == 0) {
            head->next = temp;
        }
    }

}

int main() {
    Node head;
    add(&head, new Node(-1));
    add(&head, new Node(5));
    add(&head, new Node(-2));
    add(&head, new Node(6));
    add(&head, new Node(-3));
    add(&head, new Node(7));
    add(&head, new Node(-4));
    display(&head);
    reverse(&head);
    display(&head);
    clear(&head);
    return 0;
}

在这里插入图片描述

8.设计一个算法，删除递增有序链表中值大于mink且小于maxk（mink和maxk是给定的两个参数，其值可以和表中的元素相同，也可以不同）的所用元素。

#include <iostream>
#include <string>
#include <iomanip>

using namespace std;

class Node {
public:
    int data;
    Node* next;
    Node(int data = 0, Node* next = 0): data(data), next(0) {
    }
};

void add(Node* head, Node* node) {
    for (Node* i = head; i != 0; i = i->next) {
        if (i->next == 0) {
            i->next = node;
            break;
        }
    }
}

void clear(Node* head) {
    while (head->next != 0) {
        Node* temp = head->next;
        head->next = head->next->next;
        delete temp;
    }
}

void display(Node* head) {
    head = head->next;
    while (head != 0) {
        cout << head->data << " ";
        head = head->next;
    }
    cout << endl;
}

void removeBetween(Node* head, int mink, int maxk) {
    while (head->next != 0)
    {
        if (head->next->data > mink&& head->next->data < maxk) {
            Node* temp = head->next;
            head->next = head->next->next;
            delete temp;
            continue;
        }

        head = head->next;
    }
}

int main() {
    Node head;
    add(&head, new Node(1));
    add(&head, new Node(5));
    add(&head, new Node(10));
    add(&head, new Node(16));
    add(&head, new Node(29));
    add(&head, new Node(50));
    add(&head, new Node(1000));
    display(&head);
    removeBetween(&head, 10, 51);
    display(&head);
    clear(&head);
    return 0;
}

在这里插入图片描述
9.已知p指向双向循环链表中的一个结点，基结点结构为data、prior、next三个域，写出算法Exchange§，交换p所指向的结点及其前驱结点的的顺序。


#include <iostream>
#include <string>
#include <iomanip>

using namespace std;

class Node {
public:
    int data;
    Node* prior;
    Node* next;
    Node(int data = 0) : data(data) {
        this->prior = this;
        this->next = this;
    }
};

void add(Node* head, Node* node) {
    Node* before = head->prior;
    Node* after = head;
    node->prior = before;
    node->next = after;
    before->next = node;
    after->prior = node;
}

void clear(Node* head) {
    while (head->next != head)
    {
        Node* temp = head->next;
        Node* before = head;
        Node* after = head->next->next;
        delete temp;
        before->next = after;
        after->prior = before;
    }
}

void display(Node* head) {
    Node* curr = head->next;
    while (curr != head)
    {
        cout << curr->data << " ";
        curr = curr->next;
    }
    cout << " <> ";
    Node* curb = head->prior;
    while (curb != head)
    {
        cout << curb->data << " ";
        curb = curb->prior;
    }
    cout << endl;
}


void moveForward(Node* head, Node* node) {
    //drop
    node->prior->next = node->next;
    node->next->prior = node->prior;
    //insert
    node->prior = node->prior->prior;
    node->next = node->next->prior;
    node->prior->next = node;
    node->next->prior = node;
}

int main() {
    Node head;
    add(&head, new Node(1));
    add(&head, new Node(3));
    Node* five = new Node(5);
    add(&head, five);
    add(&head, new Node(7));
    add(&head, new Node(9));
    display(&head);
    moveForward(&head, five);
    display(&head);
    clear(&head);
    return 0;
}

在这里插入图片描述

10.已知长度为n的经线性表A采用顺序存储结构，请写出时间复杂度为O(n)，空间复杂度为O(1)的算法，该算法可以删除线性表中所有值为item的数据元素。

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

void remove(int table[], int& size, int k) {
    int count = 0;
    for (int i = 0; i < size; i++) {
        if (table[i] == k) {
            count++;
        }
        else {
            table[i - count] = table[i];
        }
    }
    size -= count;
}

void display(int table[], int size) {
    for (int i = 0; i < size; i++) {
        cout << table[i] << " ";
    }
    cout << endl;
}

int main() {
    
    int table[] = { 1, 3, 5, 7, 9, 7, 3, 2, 4, 3, 7, 6 };
    int size = 12;
    display(table, size);
    remove(table, size, 7);
    display(table, size);
    return 0;
}

在这里插入图片描述

学者(cloudea)
关注
  • 0
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
数据结构课后答案第二章算法设计题1-5
vener_的博客
10-14 470
题目略 1. typedef struct { ElemType data[max]; int length; }SqList; bool DelSame(SqList &L) { if(L.length==0) return false; int i,j; for(i=0,j=1;j<L.length;j++) if(L.data[i]!=L.data[j]) L.data[++i]=L.data[j]; L.length=i+1; return true;
数据结构（C语言版第2版）课后习题答案
阿齐Archie
05-12 9106
第1章 绪论、第2章 线性表、第3章 栈和队列、第4章 串、数组和广义表、第5章 树和二叉树、第6章 图、第7章 查找、第8章 排序。数据结构（C语言版第2版）课后习题答案
数据结构习题解析与实验指导-严蔚敏数据结构-第二章：线性表（刷题记录）
BH04250909的博客
04-07 1960
第二章：线性表（刷题记录） P[18-20] 第一题：2022年4月7日 星期四 凌晨00：28 - 01：12 void MergeList(LinkList &La, LinkList &Lb, LinkList &Lc) {//将两个递增的有序链表La,Lb合并为一个递增的有序链表Lc LinkList pa, pb, pc,q; pa = La->next; //pa是链表La的工作指针，初始化为首元结点 pa = La->next..
《数据结构试验》第二章实验
Zijeak的博客
11-23 570
1.（顺序表）编写一个程序，其功能是：从顺序表的第i个位置开始，删除k个元素，并输出删除前后的元素。   实现代码如下 #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #define MAXSIZE 20 #define FALSE 0 #define OK 1 typedef int ElemType;//顺序表中存放整形元素 t...
【循环单链表算法】（C语言实现）设一个带头结点的非空循环单链表 L，结点的值可能重复。 设计一个算法在 L 中第一个最大值结点（最大值结点可能有多个）之前那插入一 个值为想的结点
热门推荐
weixin_45963815的博客
03-22 1万+
【循环单链表算法】设一个带头结点的非空循环单链表 L，结点的值可能重复。 设计一个算法在 L 中第一个最大值结点（最大值结点可能有多个）之前那插入一 个值为想的结点 源程序： #include<stdio.h> #include<malloc.h> typedef struct node{ int data; struct node* next; }node; no...
（陈慧南 第3版）算法设计与分析——课后习题答案（1~8章）
07-14
2. **第二章：数据结构** 数据结构是算法的基础，本章涵盖了线性表、栈、队列、数组、链表、树等基本数据结构。理解这些数据结构的特性和操作，有助于设计更高效的算法。 3. **第三章：排序算法** 排序是计算机...
算法设计与分析基础 第三版 课后答案 (Anany.Levitin 潘彦)
06-20
《算法设计与分析基础》是计算机科学领域的一本经典教材，由Anany Levitin撰写，潘彦翻译的第三版提供了一套系统而深入的算法学习框架。这本书旨在帮助读者理解和掌握设计高效算法的方法，并能够对算法进行严谨的...
数据结构（C语言版 第2版）课后习题答案 严蔚敏 编著
01-21
数据结构（C语言版 第2版）课后习题答案 严蔚敏 编著 数据结构是计算机科学中的一门基础课程，对于计算机科学和技术专业的学生来说是必修课程。本书是数据结构（C语言版 第2版）的课后习题答案，编著者是严蔚敏。...
数据结构（C语言）第二版课后习题答案（严蔚敏 李冬梅 吴伟民）.doc
03-16
本文将详细解析《数据结构（C语言）第二版》课后习题答案中的主要知识点，涵盖从绪论到排序的全部章节。 1. **绪论** - 数据与数据元素：数据是计算机处理的对象，可以是数字、文字、图像等各种形式。数据元素是...
Java语言程序设计与数据结构（基础篇）第9章课后习题代码chapter9.rar
06-07
在本压缩包“chapter9.rar”中，包含的是关于Java语言程序设计与数据结构基础篇的第9章课后习题代码。这个章节通常会深入探讨数据结构与算法，这是编程学习中的核心部分，特别是对于Java这样的面向对象编程语言而言...
单向链表的第N个节点前插入一个节点
ymlsd的博客
05-17 4075
题目：在一个单向链表的第N个节点前插入一个节点。 我们平常的想法是从头结点开始遍历，找到第N-1个结点，然后插入结点。但本题并没有给出头结点，所以我们无法通过遍历找到要插入的位置，所以我们需要转变思想，目前只知道第N个结点，如果在第N个结点后插入一个结点就很简单。假设要插入的结点M，第N个结点为结点N。如果先将M插入到N结点后，如果能将两个结点调换那就是实现了将M插入到了N结点前。 本题解题的关键...
单链表的创建算法(头插法)
weixin_63381305的博客
09-19 1049
给指针p开辟结点空间的语句为：p = (LinkList *)malloc(sizeof(LinkList));其中data为整形数域，next为指针域，编写函数创建一个带头结点的单链表。设有一个带头结点的链表，存储结构为。
（实验二）《数据结构》第二章线性表实验
HuangWeiJie2013GDOU
10-19 1079
一．.实验目的      巩固线性表的数据结构，学会线性表的应用。 1.回顾线性表的逻辑结构，线性表的物理存储结构和常见操作。 2.学习运用线性表的知识来解决实际问题。 3.进一步巩固程序调试方法。 4.进一步巩固模板程序设计。 二．实验时间    准备时间为第2周到第4周，具体集中实验时间为第4周第2次课。2个学时。 三．.实验内容 1.建立
数据结构作业——P53算法设计题（6）：设计一个算法，通过一趟遍历确定长度为n的单链表中值最大的结点
weiyuexin的博客
10-11 5739
思路： 设单链表首个元素为最大值max 通过遍历元素，与最大值max作比较，将较大值附给max 输出最大值max 算法： /* *title:P53页程序设计第6题 *writer:weiyuexin *data:2020-9-26 */ #include<iostream> using namespace std; #define ElemType int typedef struct LNode{ ElemType data; //定义数据域 struct L
数据结构-第二章线性表-算法设计题6
最新发布
Xiao_Ya__的博客
06-15 1888
6.设计一个算法，通过一趟遍历确定长度为n的单链表中值最大的结点。
【计算机考研数据结构代码题总结】链表
qq_43506256的博客
12-10 1476
1.在带头节点的单链表L中，删除所有值为X的结点，并释放其空间，假设值为X的节点不唯一，试编写算法实现。 //单链表 //要放置三个指针，pre指向头结点(p结点的前驱)，p指向头结点的下一个结点，q指向要被删除的结点 typedef struct LNode{ int data; struct LNode *next; }LNode; void Del_X(LNode *L, ElemType X){ LNode *pre, *p, *q; pre = L; p = L->next;
数据结构第二章代码
xr5827的博客
05-01 322
#include &lt;iostream&gt;#include &lt;fstream&gt;#include &lt;string&gt;#include &lt;vector&gt;#include &lt;iterator&gt;#include &lt;initializer_list&gt;#include &lt;deque&gt;#include &lt;list&amp
第2章课后习题算法设计题（严蔚敏数据结构c语言版第2版）
路漫漫小菜狗的博客
04-15 1460
2-6 设计一个算法，通过一趟遍历确定长度为n的单链表中值最大的结点 #include<iostream> typedef struct LNode{ int data; struct LNode *next; }LNode,*LinkList; int MAXList(LinkList L); bool InitList(LinkList &L); void...
单链表-找出最大结点
weixin_42299851的博客
06-02 3062
找出最大结点 设计一个算法，通过一趟遍历确定长度为n的单链表中值最大的结点 LNode * FindMax(LNode *L) { LNode *p=L->next,*max=p; while(p){ if(p->data>max->data) max=p; p=p->next; } return (LNode*)max; } ...
数据结构(c语言版)课后习题答案完整版资料.doc
11-15
数据结构是计算机科学中...本文总结了关于数据结构的一些内容，包括课后习题答案和两个算法设计题。数据结构是计算机科学中的重要概念，对于理解和应用计算机算法和数据存储非常有帮助。希望本文可以对读者有所帮助。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值