数据结构考试用👹

数据元素、数据项、数据结构

数据元素是数据的基本单位，

数据项是数据的最小单位，

数据结构是带有结构的各数据元素的集合。

通常要求同一逻辑结构中的所有数据元素具有相同的特性，这意味着

数据元素所包含的数据项的个数相同，且对应数据项的类型要一致

2.线性表

1746501803306

算法设计：

（1）将两个递增的有序链表合并为一个递增的有序链表。要求结果链表仍使用原来两个链表的存储空间, 不另外占用其它的存储空间。表中不允许有重复的数据。

[题目分析]

合并后的新表使用头指针 Lc 指向，pa 和 pb 分别是链表 La 和 Lb 的工作指针,初始化为相

应链表的第一个结点，从第一个结点开始进行比较，当两个链表 La 和 Lb 均为到达表尾结点

时，依次摘取其中较小者重新链接在 Lc 表的最后。如果两个表中的元素相等，只摘取 La 表

中的元素，删除 Lb 表中的元素，这样确保合并后表中无重复的元素。当一个表到达表尾结

点，为空时，将非空表的剩余元素直接链接在 Lc 表的最后。

[算法描述]

void MergeList(LinkList &La, LinkList &Lb, LinkList &Lc)

{ // 合并链表 La 和 Lb，合并后的新表使用头指针 Lc 指向

    pa = La->next;
    pb = Lb->next;

    // pa 和 pb 分别是链表 La 和 Lb 的工作指针,初始化为相应链表的第一个结点

    Lc = pc = La; // 用 La 的头结点作为 Lc 的头结点

    while (pa && pb)

    {
        if (pa->data`< pb->`data)
        {
            pc->next = pa;
            pc = pa;
            pa = pa->next;
        }

        // 取较小者 La 中的元素，将 pa 链接在 pc 的后面，pa 指针后移

        else if (pa->data > pb->data)
        {
            pc->next = pb;
            pc = pb;
            pb = pb->next;
        }

        // 取较小者 Lb 中的元素，将 pb 链接在 pc 的后面，pb 指针后移8

        else // 相等时取 La 中的元素，删除 Lb 中的元素

        {
            pc->next = pa;
            pc = pa;
            pa = pa->next;

            q = pb->next;
            delete pb;
            pb = q;
        }
    }

    pc->next = pa ? pa : pb;

    // 插入剩余段

    delete Lb;

    // 释放 Lb 的头结点
}

（2）将两个非递减的有序链表合并为一个非递增的有序链表。要求结果链表仍使用原来

两个链表的存储空间, 不另外占用其它的存储空间。表中允许有重复的数据。

[题目分析]

合并后的新表使用头指针 Lc 指向，pa 和 pb 分别是链表 La 和 Lb 的工作指针,初始化为相

应链表的第一个结点，从第一个结点开始进行比较，当两个链表 La 和 Lb 均为到达表尾结点

时，依次摘取其中较小者重新链接在 Lc 表的表头结点之后，如果两个表中的元素相等，只摘

取 La 表中的元素，保留 Lb 表中的元素。当一个表到达表尾结点，为空时，将非空表的剩余

元素依次摘取，链接在 Lc 表的表头结点之后。

[算法描述]

void MergeList(LinkList &La, LinkList &Lb, LinkList &Lc, )

{ // 合并链表 La 和 Lb，合并后的新表使用头指针 Lc 指向

    pa = La->next;
    pb = Lb->next;

    // pa 和 pb 分别是链表 La 和 Lb 的工作指针,初始化为相应链表的第一个结点

    Lc = pc = La; // 用 La 的头结点作为 Lc 的头结点

    Lc->next = NULL;

    while (pa || pb)

    { // 只要存在一个非空表，用 q 指向待摘取的元素

        if (!pa)
        {
            q = pb;
            pb = pb->next;
        }

        // La 表为空，用 q 指向 pb，pb 指针后移

        else if (!pb)
        {
            q = pa;
            pa = pa->next;
        }

        // Lb 表为空，用 q 指向 pa，pa 指针后移

        else if (pa->data <= pb->data)
        {
            q = pa;
            pa = pa->next;
        }

        // 取较小者（包括相等）La 中的元素，用 q 指向 pa，pa 指针后移

        else
        {
            q = pb;
            pb = pb->next;
        }

        // 取较小者 Lb 中的元素，用 q 指向 pb，pb 指针后移

        q->next = Lc->next;
        Lc->next = q;

        // 将 q 指向的结点插在 Lc 表的表头结点之后
    }

    delete Lb;

    // 释放 Lb 的头结点
}

(3)设计一个算法，通过遍历一趟，将链表中所有结点的链接方向逆转，仍利用原表的存储空间。

[题目分析]

从首元结点开始，逐个地把链表 L 的当前结点 p 插入新的链表头部。

[算法描述]

void inverse(LinkList &L)

{ // 逆置带头结点的单链表 L

    p = L->next;
    L->next = NULL;

    while (p)
    {

        q = p->next;

        // q 指向*p 的后继

        p->next = L->next;

        L->next = p;

        // *p 插入在头结点之后

        p = q;
    }
}