在双向链表存储结构中，删除p所指的结点时须修改指针（ ）。 A．p->next->prior=p->prior; p->prior->next=p->next; B．p->next=p->next->next; p->next->prior=p; C．p->prior->next=p; p->prior=p->prior->prior; D．p->prior=p->next->next; p->next=p->prior->prior;

正确答案是 A．p->next->prior=p->prior; p->prior->next=p->next;

在双向链表中，每个结点都有一个前驱指针 prior 和一个后继指针 next，指向其前驱结点和后继结点。删除某个结点 p 时，需要将其前驱结点的后继指针指向其后继结点，同时将其后继结点的前驱指针指向其前驱结点，即 p->next->prior=p->prior; p->prior->next=p->next; 这样才能保证链表的连续性。选项 B 是删除 p 结点后将其后继结点的前驱指针指向 p 结点的后继结点，而不是指向 p 结点的前驱结点；选项 C 和 D 都存在指针越界的情况，因此都不正确。

相关问题

优化这段代码的运行时间#include<stdio.h> #include<stdlib.h> typedef struct node* DNode; struct node { int data; DNode prior; //前面数据地址 DNode next; //后面数据地址 }; //创建双向链表 void CreatNode(DNode *head) { DNode s; //新节点指针 char e; (*head) = (DNode)malloc(sizeof(struct node));//头结点 (*head)->prior = (*head); //初始头结点的前驱和后驱都指向自己 (*head)->next = (*head); printf("输入数据\n"); scanf("%c", &e); while (e!='\n') { s = (DNode)malloc(sizeof(struct node)); //新节点分配空间 s->data = e; s->prior = (*head); //新节点的prior连前一个结点 s->next = (*head)->next; //新节点的next连后边结点 (*head)->next->prior = s; //后一个结点的prior连新结点 (*head)->next = s; //新节点前面的next连新结点 scanf("%c", &e); } } //向后遍历输出 void PrintList1(DNode L) { DNode p; p = L; p = p->next; while (p != L) { printf("%c", p->data); p = p->next; } printf("\n"); } //向前遍历输出 void PrintList2(DNode L) { DNode p; p = L->prior; while (p != L) { printf("%c", p->data); p = p->prior; } printf("\n"); } //查找第i处数据的地址 DNode FindPosition(DNode L,int i) { int j = 0; DNode p = L; while (p->next != L&&j < i) { p = p->next; j++; } return p; } //插入 void InsertList(DNode L) { DNode s,p; //s为新结点 p为新节点前一个结点 int i; char e; printf("在第几处插入:\n"); scanf("%d", &i); getchar(); printf("插入什么数据:\n"); scanf("%c", &e); p = FindPosition(L, i-1); //新节点前一个结点地址 s = (DNode)malloc(sizeof(struct node));//申请新节点空间 s->data = e; s->prior = p; //新节点的prior连上前一个结点 s->next = p->next; //新节点的next连上后一个结点 p->next->prior = s; //新节点后的结点的prior连上新结点 p->next = s; //新节点前的结点的next连上新结点 } //删除 void DeleteList(DNode L){ DNode s,p; //s为新结点 p为要删除的结点 int i; printf("删除第几处的数据:\n"); scanf("%d", &i); p = FindPosition(L, i); //要删除结点的地址 p->prior->next = p->next; //要删除的结点的前一个结点的next，连上要删结点后的结点 p->next->prior = p->prior;//要删除结点的后一个结点的prior，连上要删结点的前一个结点 free(p); } int main() { DNode list; CreatNode(&list); //PrintList1(list); PrintList2(list); InsertList(list); PrintList2(list); DeleteList(list); PrintList2(list); }

要优化这段代码的运行时间，可以考虑以下几个方面：

1. 减少循环次数：如果代码中有循环语句，可以尝试减少循环次数，比如使用更高效的算法或数据结构来代替循环。

2. 减少重复计算：如果代码中有重复计算的部分，可以尝试将其缓存起来，避免重复计算。

3. 减少函数调用：函数调用会带来一定的开销，如果代码中有频繁的函数调用，可以尝试将其合并或优化。

4. 使用并行计算：如果代码中有可以并行计算的部分，可以尝试使用多线程或分布式计算来加速运行。

5. 优化内存使用：如果代码中有大量的内存分配和释放操作，可以尝试优化内存使用，比如使用对象池或缓存来避免频繁的内存分配和释放。

6. 使用更高效的数据结构和算法：如果代码中使用的数据结构和算法不够高效，可以尝试使用更高效的数据结构和算法来代替。

已知p指向双向循环链表中的一个结点，其结点结构为data、prior、next三个域，写出算法change(p),交换p所指向的结点和它的前驱结点的顺序。

### 回答1：
算法change(p)的步骤如下：

1. 如果p为空或者p的前驱结点为空，则直接返回。

2. 定义一个临时变量temp，将p的前驱结点赋值给temp。

3. 将p的前驱结点的前驱结点的next指针指向p。

4. 将p的next指针指向temp。

5. 将p的前驱结点的next指针指向p的next指针所指向的结点。

6. 如果p的next指针不为空，则将p的next指针所指向的结点的prior指针指向p的前驱结点。

7. 如果p的前驱结点的prior指针不为空，则将p的前驱结点的prior指针指向p。

8. 返回。

### 回答2：
算法change(p)的实现步骤如下：

1. 首先判断p是否为空，若为空则返回。

2. 判断p所指向的结点是否为链表的头结点，若是则返回。

3. 定义两个指针q和r，分别指向p的前驱结点和p所指向的结点。

4. 将p的前驱结点的next指针指向p的下一个结点，保证链表的连续性。

5. 将p的前驱结点赋值给p所指向的结点的prior指针，保证链表的双向性。

6. 将p所指向的结点赋值给p的前驱结点的next指针，保证链表的双向性。

7. 将p所指向的结点的next指针指向p的前驱结点，保证链表的双向性。

8. 将p的next指针指向p所指向的结点的next指针，保证链表的连续性。

9. 将p所指向的结点的next指针赋值给p所指向的结点的prior指针，保证链表的双向性。

10. 将p所指向的结点赋值给p所指向的结点的next指针的前驱结点，保证链表的双向性。

11. 返回链表。

该算法的时间复杂度为O(1)，对于双向循环链表，只需要进行常数次的操作即可完成结点和其前驱结点的交换。

### 回答3：
算法change(p)的实现思路如下：

1. 判断p是否为空指针或p所指向的结点是否为链表的头结点，如果满足条件，则无法交换，直接返回。

2. 获取p所指向的结点的前驱结点pre和后继结点next，分别通过p->prior和p->next指针获取。

3. 如果pre为头结点，则将链表的头结点修改为p所指向的结点。

4. 将p所指向的结点与pre结点的前驱结点pre_prev连接。

5. 将p所指向的结点与其后继结点next连接。

6. 将pre_prev结点与p所指向的结点连接。

7. 将p所指向的结点的前驱结点修改为pre_prev。

8. 将p所指向的结点的后继结点修改为pre。

9. 返回修改后的链表。

具体的算法实现如下：

void change(Node *p) {
    if (p == NULL || p->prior == NULL) {
        return;  // 无法交换，直接返回
    }

    Node *pre = p->prior;
    Node *next = p->next;

    if (pre == head) {
        head = p;  // 若pre为头结点，则修改头结点
    }

    Node *pre_prev = pre->prior;

    pre_prev->next = p;
    p->prev = pre_prev;

    p->next = pre;
    pre->prev = p;

    pre->next = next;
    if (next != NULL) {
        next->prev = pre;
    }
}

以上是算法change(p)的具体实现，核心思想是通过调整各个结点之间的连接关系实现结点的交换。该算法的时间复杂度为O(1)。