线性表练习之Example041-重排链表节点L=(a1, a2, a3, ..., a(n-2), a(n-1), an) 排成 L‘=(a1, an, a2, a(n-1), a3, a(n-2)

最新推荐文章于 2023-06-13 13:41:40 发布
最新推荐文章于 2023-06-13 13:41:40 发布
阅读量3k 收藏 47
点赞数 7
分类专栏： 数据结构 文章标签： java c 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cnds123321/article/details/123806550
版权

Example041

原文链接：Example041

题目

设线性表 L=(a1, a2, a3, ..., a(n-2), a(n-1), an) 采用带头结点的单链表保存，链表中的节点定义如下：

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

请设计一个空间复杂度为 O(1) 且时间上尽可能高效的算法，重新排列 L 中的各节点，得到线性表 L'=(a1, an, a2, a(n-1), a3, a(n-2), ...)。

分析

本题考查的知识点：

  • 单链表
  • 寻找单链表的中间节点
  • 逆置单链表
  • 尾插法创建单链表

分析：

例如链表节点个数为奇数，如 L = [1, 2, 3, 4, 5] 重新排列后为 L' = [1, 5, 2, 4, 3]。例如链表节点个数为偶数，如 L = [1, 2, 3, 4, 5, 6] 重新排列后为 L' = [1, 6, 2, 5, 3, 4]。

发现规律是 L' 是 L 摘取第一个元素，再摘取倒数第一个元素……依次合并而成的。如果没有对空间复杂度有要求，那么如果把所有节点的数据存入数组，然后通过数组下标来取元素组成新链表，实现就很容易了。但题目要求用 O(1)
的空间复杂度，所以必须原地修改链表。

为了方便后半段取元素，需要先将 L 后半段原地逆置（要求空间复杂度为 O(1)），否则每取最后一个节点都需要遍历一次链表。

  • ①先找出链表 L 的中间节点，利用快慢指针的方法，设置两个指针 fast 和 slow，指针 slow 每次走一步，指针 fast 每次走两步，当快指针 fast 到达链表尾时，慢指针 slow
    正好处于链表的中间节点。
  • ②然后将 L 的后半段节点原地逆置。
  • ③从单链表前后两段依次各取一个节点，按要求重排。

注意；

  • 无论是寻找链表中间节点还是重排链表，都需要注意链表节点个数是奇数还是偶数，分情况处理。
  • 寻找链表中间节点可参考：寻找链表的中间节点
  • 逆置单链表可参考：原地逆置单链表

图解

请添加图片描述

C实现

核心代码：

/**
 * 重排链表中的节点
 * @param list 链表
 */
void reverse(LNode **list) {
    // 1.寻找链表的中间节点
    // 使用快慢指针法，快指针 fast 前进两步，慢指针 slow 前进一步，当快指针到达链表尾部时慢指针刚好到达链表的中部
    LNode *fast = *list;
    LNode *slow = *list;
    while (fast != NULL && fast->next != NULL) {
        fast = fast->next->next;
        slow = slow->next;
    }

    // 2.逆置后半部分链表节点
    // 变量，记录单链表的中间节点。如果链表节点个数是奇数，则是最中间的节点；如果链表节点个数是偶数，则是两个中间节点中的前一个
    LNode *mid = slow;
    // 变量，记录后半部分的节点，初始为中间节点的后继节点，即后半部分链表的第一个节点
    LNode *back = mid->next;
    // 将中间节点的 next 指针指向 null，表示把当 mid 当作一个头节点，后半部分节点逆置后仍然链接到 mid 的后面
    mid->next = NULL;
    // 扫描 back 所表示的后半部分链表，通过头插法重新插入到 mid 的后边，即逆置后半部分单链表
    while (back != NULL) {
        LNode *temp = back->next;

        back->next = mid->next;
        mid->next = back;

        back = temp;
    }

    // 3.同时扫描前半部分节点和后半部分节点，重排链表节点
    // 变量，记录前半部分的节点，初始指向链表的第一个节点，用于扫描链表前半部分的所有节点
    LNode *preNode = (*list)->next;
    // 变量，记录后半部分的节点
    LNode *backNode = mid->next;
    // 由于要重新移动链表节点，所以将头节点的 next 指向 null，重新为链表插入元素
    (*list)->next = NULL;
    // 变量，记录新链表的尾节点，用于尾插法插入
    LNode *tailNode = *list;
    // 同时扫描 preNode 和 backNode 所代表的链表，将 preNode 和 backNode 节点插入到 list 后面，直至 backNode 为 NULL 结束
    while (backNode != NULL) {
        // 使用尾插法将 preNode 节点插入到 list 后面，然后继续下一个节点
        tailNode->next = preNode;
        tailNode = preNode;
        preNode = preNode->next;

        // 使用尾插法将 backNode 节点插入到 list 后面，然后继续下一个节点
        tailNode->next = backNode;
        tailNode = backNode;
        backNode = backNode->next;
    }
    // 如果链表节点是奇数个，则可能前半部分有一个节点还未插入新链表
    if (preNode == mid) {
        tailNode->next = mid;
        tailNode = mid;
        tailNode->next = NULL;// 由于 mid 节点的 next 指针指向不为 null，为了一个链表的完整性，将最后一个节点的 next 指向 null 才能正常使用，否则陷入链表循环
    }
}

完整代码：

#include <stdio.h>
#include <malloc.h>

/**
 * 单链表节点
 */
typedef struct LNode {
    /**
     * 单链表节点的数据域
     */
    int data;
    /**
     * 单链表节点的的指针域，指向当前节点的后继节点
     */
    struct LNode *next;
} LNode;

/**
 * 通过尾插法创建单链表
 * @param list 单链表
 * @param nums 创建单链表时插入的数据数组
 * @param n 数组长度
 * @return 创建好的单链表
 */
LNode *createByTail(LNode **list, int nums[], int n) {
    // 1.初始化单链表
    // 创建链表必须要先初始化链表，也可以选择直接调用 init() 函数
    *list = (LNode *) malloc(sizeof(LNode));
    (*list)->next = NULL;

    // 尾插法，必须知道链表的尾节点（即链表的最后一个节点），初始时，单链表的头结点就是尾节点
    // 因为在单链表中插入节点我们必须知道前驱节点，而头插法中的前驱节点一直是头节点，但尾插法中要在单链表的末尾插入新节点，所以前驱节点一直都是链表的最后一个节点，而链表的最后一个节点由于链表插入新节点会一直变化
    LNode *node = (*list);

    // 2.循环数组，将所有数依次插入到链表的尾部
    for (int i = 0; i < n; i++) {
        // 2.1 创建新节点，并指定数据域和指针域
        // 2.1.1 创建新节点，为其分配空间
        LNode *newNode = (LNode *) malloc(sizeof(LNode));
        // 2.1.2 为新节点指定数据域
        newNode->data = nums[i];
        // 2.1.3 为新节点指定指针域，新节点的指针域初始时设置为 null
        newNode->next = NULL;

        // 2.2 将新节点插入到单链表的尾部
        // 2.2.1 将链表原尾节点的 next 指针指向新节点
        node->next = newNode;
        // 2.2.2 将新节点置为新的尾节点
        node = newNode;
    }
    return *list;
}

/**
 * 重排链表中的节点
 * @param list 链表
 */
void reverse(LNode **list) {
    // 1.寻找链表的中间节点
    // 使用快慢指针法，快指针 fast 前进两步，慢指针 slow 前进一步，当快指针到达链表尾部时慢指针刚好到达链表的中部
    LNode *fast = *list;
    LNode *slow = *list;
    while (fast != NULL && fast->next != NULL) {
        fast = fast->next->next;
        slow = slow->next;
    }

    // 2.逆置后半部分链表节点
    // 变量，记录单链表的中间节点。如果链表节点个数是奇数，则是最中间的节点；如果链表节点个数是偶数，则是两个中间节点中的前一个
    LNode *mid = slow;
    // 变量，记录后半部分的节点，初始为中间节点的后继节点，即后半部分链表的第一个节点
    LNode *back = mid->next;
    // 将中间节点的 next 指针指向 null，表示把当 mid 当作一个头节点，后半部分节点逆置后仍然链接到 mid 的后面
    mid->next = NULL;
    // 扫描 back 所表示的后半部分链表，通过头插法重新插入到 mid 的后边，即逆置后半部分单链表
    while (back != NULL) {
        LNode *temp = back->next;

        back->next = mid->next;
        mid->next = back;

        back = temp;
    }

    // 3.同时扫描前半部分节点和后半部分节点，重排链表节点
    // 变量，记录前半部分的节点，初始指向链表的第一个节点，用于扫描链表前半部分的所有节点
    LNode *preNode = (*list)->next;
    // 变量，记录后半部分的节点
    LNode *backNode = mid->next;
    // 由于要重新移动链表节点，所以将头节点的 next 指向 null，重新为链表插入元素
    (*list)->next = NULL;
    // 变量，记录新链表的尾节点，用于尾插法插入
    LNode *tailNode = *list;
    // 同时扫描 preNode 和 backNode 所代表的链表，将 preNode 和 backNode 节点插入到 list 后面，直至 backNode 为 NULL 结束
    while (backNode != NULL) {
        // 使用尾插法将 preNode 节点插入到 list 后面，然后继续下一个节点
        tailNode->next = preNode;
        tailNode = preNode;
        preNode = preNode->next;

        // 使用尾插法将 backNode 节点插入到 list 后面，然后继续下一个节点
        tailNode->next = backNode;
        tailNode = backNode;
        backNode = backNode->next;
    }
    // 如果链表节点是奇数个，则可能前半部分有一个节点还未插入新链表
    if (preNode == mid) {
        tailNode->next = mid;
        tailNode = mid;
        tailNode->next = NULL;// 由于 mid 节点的 next 指针指向不为 null，为了一个链表的完整性，将最后一个节点的 next 指向 null 才能正常使用，否则陷入链表循环
    }
}


/**
 * 打印链表的所有节点
 * @param list 单链表
 */
void print(LNode *list) {
    printf("[");
    // 链表的第一个节点
    LNode *node = list->next;
    // 循环单链表所有节点，打印值
    while (node != NULL) {
        printf("%d", node->data);
        if (node->next != NULL) {
            printf(", ");
        }
        node = node->next;
    }
    printf("]\n");
}

int main() {
    // 声明单链表
    LNode *list;
    int nums[] = {1, 2, 3, 4, 5, 6};
    int n = 6;
    createByTail(&list, nums, n);
    print(list);

    // 调用函数
    reverse(&list);
    print(list);
}

执行结果：

[1, 2, 3, 4, 5, 6]
[1, 6, 2, 5, 3, 4]

Java实现

核心代码：

    /**
     * 重排链表中的节点
     */
    public void reverse() {
        // 1.寻找链表的中间节点
        // 使用快慢指针法，快指针 fast 前进两步，慢指针 slow 前进一步，当快指针到达链表尾部时慢指针刚好到达链表的中部
        LNode fast = list;
        LNode slow = list;
        while (fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
        }

        // 2.逆置后半部分链表节点
        // 变量，记录单链表的中间节点。如果链表节点个数是奇数，则是最中间的节点；如果链表节点个数是偶数，则是两个中间节点中的前一个
        LNode mid = slow;
        // 变量，记录后半部分的节点，初始为中间节点的后继节点，即后半部分链表的第一个节点
        LNode back = mid.next;
        // 将中间节点的 next 指针指向 null，表示把当 mid 当作一个头节点，后半部分节点逆置后仍然链接到 mid 的后面
        mid.next = null;
        // 扫描 back 所表示的后半部分链表，通过头插法重新插入到 mid 的后边，即逆置后半部分单链表
        while (back != null) {
            LNode temp = back.next;

            back.next = mid.next;
            mid.next = back;

            back = temp;
        }

        // 3.同时扫描前半部分节点和后半部分节点，重排链表节点
        // 变量，记录前半部分的节点，初始指向链表的第一个节点，用于扫描链表前半部分的所有节点
        LNode preNode = (list).next;
        // 变量，记录后半部分的节点
        LNode backNode = mid.next;
        // 由于要重新移动链表节点，所以将头节点的 next 指向 null，重新为链表插入元素
        (list).next = null;
        // 变量，记录新链表的尾节点，用于尾插法插入
        LNode tailNode = list;
        // 同时扫描 preNode 和 backNode 所代表的链表，将 preNode 和 backNode 节点插入到 list 后面，直至 backNode 为 null 结束
        while (backNode != null) {
            // 使用尾插法将 preNode 节点插入到 list 后面，然后继续下一个节点
            tailNode.next = preNode;
            tailNode = preNode;
            preNode = preNode.next;

            // 使用尾插法将 backNode 节点插入到 list 后面，然后继续下一个节点
            tailNode.next = backNode;
            tailNode = backNode;
            backNode = backNode.next;
        }
        // 如果链表节点是奇数个，则可能前半部分有一个节点还未插入新链表
        if (preNode == mid) {
            tailNode.next = mid;
            tailNode = mid;
            tailNode.next = null;// 由于 mid 节点的 next 指针指向不为 null，为了一个链表的完整性，将最后一个节点的 next 指向 null 才能正常使用，否则陷入链表循环
        }
    }

完整代码：

public class LinkedList {
    /**
     * 单链表
     */
    private LNode list;

    /**
     * 通过尾插法创建单链表
     *
     * @param nums 创建单链表时插入的数据
     * @return 创建好的单链表
     */
    public LNode createByTail(int... nums) {
        // 1.初始化单链表
        // 创建链表必须要先初始化链表，也可以选择直接调用 init() 函数
        list = new LNode();
        list.next = null;

        // 尾插法，必须知道链表的尾节点（即链表的最后一个节点），初始时，单链表的头结点就是尾节点
        // 因为在单链表中插入节点我们必须知道前驱节点，而头插法中的前驱节点一直是头节点，但尾插法中要在单链表的末尾插入新节点，所以前驱节点一直都是链表的最后一个节点，而链表的最后一个节点由于链表插入新节点会一直变化
        LNode tailNode = list;

        // 2.循环数组，将所有数依次插入到链表的尾部
        for (int i = 0; i < nums.length; i++) {
            // 2.1 创建新节点，并指定数据域和指针域
            // 2.1.1 创建新节点，为其分配空间
            LNode newNode = new LNode();
            // 2.1.2 为新节点指定数据域
            newNode.data = nums[i];
            // 2.1.3 为新节点指定指针域，新节点的指针域初始时设置为 null
            newNode.next = null;

            // 2.2 将新节点插入到单链表的尾部
            // 2.2.1 将链表原尾节点的 next 指针指向新节点
            tailNode.next = newNode;
            // 2.2.2 将新节点置为新的尾节点
            tailNode = newNode;
        }

        return list;
    }

    /**
     * 重排链表中的节点
     */
    public void reverse() {
        // 1.寻找链表的中间节点
        // 使用快慢指针法，快指针 fast 前进两步，慢指针 slow 前进一步，当快指针到达链表尾部时慢指针刚好到达链表的中部
        LNode fast = list;
        LNode slow = list;
        while (fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
        }

        // 2.逆置后半部分链表节点
        // 变量，记录单链表的中间节点。如果链表节点个数是奇数，则是最中间的节点；如果链表节点个数是偶数，则是两个中间节点中的前一个
        LNode mid = slow;
        // 变量，记录后半部分的节点，初始为中间节点的后继节点，即后半部分链表的第一个节点
        LNode back = mid.next;
        // 将中间节点的 next 指针指向 null，表示把当 mid 当作一个头节点，后半部分节点逆置后仍然链接到 mid 的后面
        mid.next = null;
        // 扫描 back 所表示的后半部分链表，通过头插法重新插入到 mid 的后边，即逆置后半部分单链表
        while (back != null) {
            LNode temp = back.next;

            back.next = mid.next;
            mid.next = back;

            back = temp;
        }

        // 3.同时扫描前半部分节点和后半部分节点，重排链表节点
        // 变量，记录前半部分的节点，初始指向链表的第一个节点，用于扫描链表前半部分的所有节点
        LNode preNode = (list).next;
        // 变量，记录后半部分的节点
        LNode backNode = mid.next;
        // 由于要重新移动链表节点，所以将头节点的 next 指向 null，重新为链表插入元素
        (list).next = null;
        // 变量，记录新链表的尾节点，用于尾插法插入
        LNode tailNode = list;
        // 同时扫描 preNode 和 backNode 所代表的链表，将 preNode 和 backNode 节点插入到 list 后面，直至 backNode 为 null 结束
        while (backNode != null) {
            // 使用尾插法将 preNode 节点插入到 list 后面，然后继续下一个节点
            tailNode.next = preNode;
            tailNode = preNode;
            preNode = preNode.next;

            // 使用尾插法将 backNode 节点插入到 list 后面，然后继续下一个节点
            tailNode.next = backNode;
            tailNode = backNode;
            backNode = backNode.next;
        }
        // 如果链表节点是奇数个，则可能前半部分有一个节点还未插入新链表
        if (preNode == mid) {
            tailNode.next = mid;
            tailNode = mid;
            tailNode.next = null;// 由于 mid 节点的 next 指针指向不为 null，为了一个链表的完整性，将最后一个节点的 next 指向 null 才能正常使用，否则陷入链表循环
        }
    }

    /**
     * 打印单链表所有节点
     */
    public void print() {
        // 链表的第一个节点
        LNode node = list.next;
        // 循环打印
        String str = "[";
        while (node != null) {
            // 拼接节点的数据域
            str += node.data;
            // 只要不是最后一个节点，那么就在每个节点的数据域后面添加一个分号，用于分隔字符串
            if (node.next != null) {
                str += ", ";
            }
            // 继续链表的下一个节点
            node = node.next;
        }
        str += "]";
        // 打印链表
        System.out.println(str);
    }
}

/**
 * 单链表的节点
 */
class LNode {
    /**
     * 链表的数据域，暂时指定为 int 类型，因为 Java 支持泛型，可以指定为泛型，就能支持更多的类型了
     */
    int data;
    /**
     * 链表的指针域，指向该节点的下一个节点
     */
    LNode next;
}

测试代码：

public class LinkedListTest {
    public static void main(String[] args) {
        // 链表节点为奇数的情况
        LinkedList list1 = new LinkedList();
        list1.createByTail(1, 2, 3, 4, 5);// 创建单链表
        list1.print();
        list1.reverse();// 调用函数
        list1.print();

        System.out.println();

        // 链表节点为奇数的情况
        LinkedList list2 = new LinkedList();
        list2.createByTail(1, 2, 3, 4, 5, 6, 7, 8);// 创建单链表
        list2.print();
        list2.reverse();// 调用函数
        list2.print();
    }
}

执行结果：

[1, 2, 3, 4, 5]
[1, 5, 2, 4, 3]

[1, 2, 3, 4, 5, 6, 7, 8]
[1, 8, 2, 7, 3, 6, 4, 5]
二木成林
关注
  • 7
    点赞
  • 踩
  • 47
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线性表重排及双指针（快慢指针）
qq_43016111的博客
11-08 520
//时间复杂度O（n），空间复杂度O（n） void change_list(Node *h){ Node *p,*q,*r,*s; p=q=h;//先开始都是从表头开始 while(q->next!=NULL)//寻找中间结点 p=p->next;//p走一步 q=q->next; if(q->next!=NULL)//使q走两步 利用步长来控制长度的比 q=q->next; } q=p->next;//使q指向中间结点 p-&.
2. 线性表-链式存储-链表1
08-03
线性表是计算机科学中基础的数据结构之一，它是由相同类型元素组成的有序序列。在实际应用中，线性表可以采用两种不同的存储方式：顺序存储和链式存储。本篇主要讨论的是链式存储，特别是链表这一实现方式。 链表是...
设双链表表示的线性表L=（a1,a2,……an）,试写一时间复杂吨为O(n)的算法，将L改造为L=（a1,a3……an……,a4,a2）
11-29
设双链表表示的线性表L=（a1,a2,……an）,试写一时间复杂度为O(n)的算法，将L改造为L=（a1,a3……an……,a4,a2）
C++ 已知单链表L=（a1,a2,a3,…an）.设计一个算法实现单链表的重新排列，即得到L‘=（a1,an,a2,an-1,a3,an-2…..）
weixin_62717970的博客
10-27 1102
C++ 已知单链表L=（a1,a2,a3,…an）.设计一个算法实现单链表的重新排列，即得到L‘=（a1,an,a2,an-1,a3,an-2…..）
【数据结构每日一题】链表——单链表重排
DAY I 的成长之路
05-31 797
p作为中间结点的指针，若要链表逆序，则最后p的next指针一定是要指向链表的尾结点的，所以，我们每扫到一个后段结点，都把他当作尾结点来看，则 q的next指针要指向上一轮 p的next指向的结点，这样就完成了箭头反向（因为上一轮p的next指向前一个结点），再让 p的next指向当前结点 q，即连接了表尾，实现了。由于中间结点（两个或一个）在重排后一定是不动的，所以中间结点或中间结点的 next在重排后会变为尾结点，因此必须使其指向 NULL，相当于特判，否则最后打印单链表时会进入死循环。
数据结构学习：有关带头结点的单向链表的常见考题（c语言）
weixin_58526281的博客
08-13 863
1.将链表中pp结点之后的结点原地逆置（反转）。 2.反向打印链表中全部的元素。 3.找出带头结点的单链表倒数第k(k>0)个结点。 4.判断单链表是否有环，并找到环的入口。 5.找出两个汇聚单链表的公共结点，如果没有汇聚，返回空，如果有，返回汇聚的第一个结点。 6.将线性表L=(a1,a2,a3,...,an-2,an-1,an)变成L=(a1,an,a2,an-1,a3,an-2,...)。数据结...
设双链表表示的线性表L=（a1,a2,....,an），试写一时间复杂度为O（n）的算法，将L改造为L=（a1,a2,,,,an....,a4,a2）。
10-13
设双链表表示的线性表L=（a1,a2,....,an），试写一时间复杂度为O（n）的算法，将L改造为L=（a1,a2,,,,an....,a4,a2）。
数据结构实验报告-2-2-线性表(链表实现).docx
11-12
在本实验中，我们将重点讨论线性表的链表实现，这是数据结构领域的一个重要概念。 链表是一种动态数据结构，它不像数组那样需要预先分配连续的内存空间。在链表中，每个元素称为节点，每个节点包含两个部分：数据域...
数据结构实验报告-2-2-线性表(链表实现).pdf
11-12
线性表是数据结构中的一种基础结构，它是由n（n>=0）个相同类型元素构成的有限序列。在这个实验报告中，我们关注的是线性表的链表实现，这是一种非常重要的数据结构，广泛应用于各种计算机算法和系统设计中。 链表...
数据结构作业：第2章-线性表作业题目.docx
12-16
"数据结构作业：第2章-线性表作业题目.docx" 在这份作业中，我们可以总结出以下几个重要的知识点： 1. 线性表的存储方式：线性表可以采用顺序存储和链式存储两种方式。顺序存储方式是指将所有元素存储在一片连续的...
小白算法积累——单链表25#带头结点单链表+穿插+逆置
aprilzj123的博客
02-22 2785
题目：设线性表L=（a1,a2,a3,…an-2，an-1，an）采用带头结点的单链表保存，链表中的结点定义如下： typedef struct node { int data; struct node*next }Node; 请设计一个空间复杂度为O（1）且时间上尽可能高效的算法，重新排列L中的各结点，得到线性表L’=（a1,an,a2,an-1,a3,an-2…） 关键字：带头结点单链表+...
单链表的基本操作之部分习题的讲解
weixin_56169816的博客
05-05 1490
单链表的基本操作之习题篇 1、有一个线性表（a1,a2,a3,…an），n>=2，采用带头结点的单链表L存储，设计一个算法将其就地逆置，空间复杂度为O（1） 解题思路1： ​ 用指针p遍历原单链表，先将头节点L的next域置为NULL而变成一个空链表，然后节点采用头插法插入L中。 示例图： 对应算法如下： void ReverseLinkList(LinkList& L) { LNode* p = L->next, * q; L->next = NULL; //将L
每日一题———27.重新排列线性表的顺序
而塞过的学习之旅
06-13 655
前言 数据结构每日一题 声明：因个人能力有限，本文仅是个人的学习记录笔记，有错误之处还望指出 题目 设线性表L为{a1,a2,a3…an-1,an}采用头节点的单链表保存，按要求重新排列L中的各个结点，得到线性表的顺序为{a1,an,a2,an-1…} 要点 双指针的使用 头插法逆置结点 思想 分析插入后的结点的规律是间隔顺序递增，但是给出的后部分结点是递减，且结点可以分为两部分 找到中间节点（两个指针，快指针一次走两步，慢指针一次走一步，故在快指针到达链尾的时候，慢指针在中间结点） 将后部.
数据结构3_线性表 _单链表的基本操作及实现
毛钱儿的博客
04-09 1658
数据结构3_线性表_2 总览： 线性表： 线性表是具有相同数据类型的n(n>=0)个数据元素的有序序列，其中n为表长，当n=0时线性表是一个空表。若用L命名线性表，其一般表示为： L=(a1,a2,a3,a4,∗∗∗,an) L = (a1,a2,a3,a4,***,an) L=(a1,a2,a3,a4,∗∗∗,an) a1为表头元素，an为表尾元素，除了an其他元素都有唯一的直接后继，除...
链表：重新排列链表中的各节点【C语言，数据结构】（内含源代码）
哦豁果奶的博客
10-28 887
设线性表L=(a1,a2,^,an-1,an)采用带头节点的单链表保存，设计并实现一个空间复杂度为O(1)且时间上尽可能高效的算法，重新排列L中的各结点，得到线性表L'=(a1,an,a2,an-1,a3,an-2……). 题目分析： 1.空间复杂度为O(1)，这个意思是，我们不能用到的工具空间不能随着输入链表长度大小而改变，代表不能复制一个反向链表再插入，这种做法是不行的，这个要求代表，我们只能通过工具指针来进行本题的操作。 2.时间上尽可能高效，代表，我们的指针要尽可能的减少遍历链表的次数，这里要注
链表---重新排列和拆分
weixin_30781631的博客
07-28 98
本随笔描述链表的重新排列和拆分。 4）不带头结点的链表，要求将链表按数据域的值从小到大重新链接。不能使用额外的结点空间。 本题有一定难度 #include "stdafx.h" #include<iostream> using namespace std; typedef struct node { int data; struct node *ne...
单链表的变换（2019年考研统考真题）
最新发布
m0_72671017的博客
06-13 174
【问题描述】设线性表L={a1,a2,a3,...,an-2,an-1,an}采用带头结点的单链表保存，请设计一个空间复杂度为O（1）且时间上尽可能高效的算法，重新排列L中的各结点，得到线性表L'={a1,an,a2,an-1,a3,an-2,...)。如输入1 2 3 4 5 6 7 8 9 0，输出为1 9 2 8 3 7 4 6 5 ，输入9 8 7 6 5 4 3 2 1 0，输出则为9 1 8 2 7 3 6 4 5。②找到与当前结点配对的结点之后，要插入的结点应该插到哪个位置？
数据结构--知识点16--搜索算法(二叉树)
ANingL的博客
09-06 2989
文章目录一、树的概念1、特点2、树的术语3、树的种类4、树的存储与表示5、常见的树的应用场景二、二叉树1、概念2、性质 一、树的概念 树是一种抽象数据类型(ADT)或是视作这种抽象数据类型的数据结构 1、特点 每个节点有零个或多个子节点 没有父节点的节点称为根节点 每一个非根节点有且只有一个父节点 除了根节点外，每个子节点可以分为**多个不相交(因为都只有一个父节点)**的子树 2、树的术语 节点的度：一个节点含有的子树的个数称为该节点的度 树的度：一棵树中，最大的节点的度称为树的度 叶节点或终端节点
数据结构习题——将链表L（a1,a2,a3,...,an-2,an-1,an）改造成（a1,an,a2,an-1,a3,an-2,...）
无由页的博客
06-09 6404
前言 王道2019统考真题 正文 题目 设链表L（a1,a2,a3,…,an-2,an-1,an）采用头结点的单链表保存 请设计一个空间复杂度为O(1)时间上尽可能高效的算法，重新排列L，得到线性表变成（a1,an,a2,an-1,a3,an-2,…） 关键 先找出链表L的中间点，为此设置了两个指针p和q，指针p每次走一步，q每次走两步，当指针q达到链尾时，指针p正好在链表的中间点 然后将L的后半部分原地逆置 从单链表前后两段中以此各取一个结点，按要求重排 这道题涉及了链表的双指针法，链表的逆置，链表的
设计一个算法，使线性表L=(a1,a2,a3,...,an-1,an)重新排列得到L'(a1,an,a2,an-1,a3,an-2)
03-10
1. 将线性表L分成两个部分，前一半为(a1,a2,a3,...,an/2)，后一半为(an/2+1,an/2+2,...,an)。 2. 将后一半的元素逆序排列，得到(an,an-1,...,an/2+1)。 3. 将前一半和逆序排列后的后一半依次交替合并，得到L'=(a1,...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值