【2019年数据结构真题】


【2019统考真题】设线性表L= (a1,a2,a3,…,an-2,an-1,an)采用带头结点的单链表保存,链表中的结点定义如下:

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

请设计一个空间复杂度为0(1)且时间上尽可能高效的算法,重新排列L中的各结点,得到线性表 L2 = (a1,an,a2,an-1,a3,an-1…)

要求:

  1. 给出算法的基本设计思想。

  2. 根据设计思想,采用C或C++语言描述算法,关键之处给出注释。

  3. 说明你所设计的算法的时间复杂度

题目信息:

  • 空间复杂度为O(1)且时间上尽可能高效-----尽量不适用栈,队列等辅助结构
  • 带有头节点,不用单独处理第一个结点

方法一:

void ans(Node* L, int n){
    int t=(n+1)/2;	//即n/2向上取整
    Node* pre=L, p, q, qq;	//q为指向后半段链的指针
    for (int i=0; i<t; i++)
        pre=pre->next;	//pre指向a⌈n/2⌉ 
    q=pre->next;	//q指向a⌈n/2⌉+1
    pre->next=null;	//a⌈n/2⌉的下一个结点为空
    len=n-t;	//后一半链长度
    for (int i=len; i>0; i--){	//一个一个重新插入
        pre=L;
        for (int j=0; j<i; j++)	//找到插入位置
            pre=pre->next;
        p=pre->next;	//pre是插入位置
        pre->next=q;	//插入q
        qq=q->next;	//qq暂存q的下一个结点
        q->next=p;	//q下一个结点是插入位置后的点
        q=qq;	//q指向qq所指结点
    }
}
可这么理解:

给定一个单链表 L:L0→L1→…→Ln-1→Ln ,

将其重新排列后变为: L0→Ln→L1→Ln-1→L2→Ln-2→…

你不能只是单纯的改变节点内部的值,而是需要实际的进行节点交换。

示例 1:

给定链表 1->2->3->4, 重新排列为 1->4->2->3.

示例 2:

给定链表 1->2->3->4->5, 重新排列为 1->5->2->4->3.

算法的基本思想:

  1. 快慢指针找中点,将原链表切分成两段
  2. 将后面的链表翻转
  3. 将第二个链表的每个结点依次插在第一个链表的后面

\

比如:1->2->3->4->5->null

切分变成:1->2->3->null ; 4->5->null ;

将 4->5 翻转变成5->4;

插入变成:1->5->2->4->3->null;

class Solution {
  public:
    void reorderList(ListNode* head) {
        if (head == NULL || head->next == NULL)
            return;
//快慢指针分出两段
        ListNode* slow = head, *fast = head;
        while (fast->next && fast->next->next) {
            slow = slow->next;
            fast = fast->next->next;
        }
//后端反转
        ListNode* needReverser = slow->next;
        slow->next = NULL;
        needReverser = reverse(needReverser);
//插入前端缝隙
        ListNode* cur = head;
        while (cur && needReverser) {
            ListNode* curSecond = needReverser;
            needReverser = needReverser->next;
            ListNode* nextCur = cur->next;
            curSecond->next = cur->next;
            cur->next = curSecond;
            cur = nextCur;
        }
    }
    ListNode* reverse(ListNode* head) {
        ListNode* p1 = NULL;
        ListNode* p2 = head;
        ListNode* p3 = p2;
        while (p2) {
            p3 = p2->next;
            p2->next = p1;
            p1 = p2;
            p2 = p3;
        }
        return p1;
    }
};

你可能感兴趣的:(数据结构,408,考研)