2021-03-17

TJU数据结构第二章作业简答题

1、判断带头结点的双向循环链表是否对称
Step 1> p和q指针分别指向头结点head的前驱和后继
    2>判断p和q指针指向的结点的数据域是否相等
      若相等，则p = p -> prior, q = q -> next，继续向后判断
      若不相等，则链表不对称
    3>循环2步骤直至p == q 或 p -> prior == q结束
(p == q属于链表除头结点外结点个数为奇数情况，p -> prior == q属于偶数情况)

//head为头指针，prior表示前驱，next表示后继，data表示数据域
bool isBalanced(DblList *head) {
    DblList *p, *q;
    p = head -> prior;
    q = head -> next;
    while (p != q && p -> prior != q) {
        if(p -> data == q -> data) return false;
        else {
            p = p -> prior;
            q = q -> next;
        }
    }
    return true;
}

2、从有序顺序表中删除所有其值重复的元素，使表中所有元素的值均不同
分析：由于是有序顺序表，故值相同的元素一定在连续的位置上，则初始时将第一个元素视为不重复的有序表，之后依此判断后面的元素是否与前面非重复有序表的最后一个元素相同，若相同则继续向后判断，否则插入到前面的非重复的有序表的最后，直至判断到顺序表表尾结束。

typedef struct node
{
    ElemType *data; //ElemType为任意变量类型
    int MaxSize;
    int length;
}SeqList;

bool deleteSame(SeqList &L) {
    if (L.length == 0) return false;
    else {
        int i, j;
        for (int i = 0, j = 1; j < L.length; j ++) {
            if(L.data[j] != L.data[i]) L.data[++i] = L.data[j];
        }
        L.length = i + 1;
        return true;
    }
}

3、写出在双链表中对换值23和15的两个结点相互位置时修改指针的的有关语句（要写出结构体的定义，结点结构可参考：link，data，rlink）
分析：先找到数据域为23和15的结点，并分别用a和b指向它，再定义一个before1和after1分别指向a的前驱和后继，before2和after2分别指向b的前驱和后继
进行如下操作

typedef struct dnode {
    int data;
    struct dnode *link; //后继
    struct dnode *rlink; //前驱
}DblNode;
typedef DblNode *DblList;
DblList head;

void swap(DblNode &L) {
    DblList p = head, a = head, b = head;
    while (p -> link != NULL) {
        if(p -> data == 23 || p -> data == 15 && a == head) {
            a = p;
            p = p -> link;
        }
        if(p -> data == 23 || p -> data == 15) {
            b = p;
            break;
        }
        p = p -> link;
    }
    DblList before1, after1; //before1为a的前驱结点, after1为a的后继节点
    DblList before2, after2; //before2为b的前驱结点，after2为b的后继节点
    before1 = a -> rlink, after1 = a -> link;
    before2 = b -> rlink, after2 = b -> link;
    if(b -> link == NULL) {
        a -> link = after2;
        a -> rlink = before2;
        before2 -> link = a;
        b -> rlink = before1;
        before1 -> link = b;
        b -> link = after1;
        after1 -> rlink = b;
    }
    else {
        a -> link = after2;
        after2 -> rlink = a;
        a -> rlink = before2;
        before2 -> link = a;
        b -> rlink = before1;
        before1 -> link = b;
        b -> link = after1;
        after1 -> rlink = b;
    }
}

4、设计一高效算法，将顺序表的所有元素逆置，要求算法的空间复杂度为O（1）

typedef struct node {
    int *data;
    int length;
}SeqList;

void reverse(SeqList &L) {
    int i;
    int temp;
    for (i = 0; i < L.length / 2; i ++) {
        temp = data[i];
        data[i] = data[L.length - i - 1];
        data[L.length - i - 1] = temp;
    }
}

5、设单链表结点指针域为next，试写出删除链表中指针p所指结点的直接后继的C语言语句

typedef struct node {
    ListData data;
    struct node *link;
}ListNode;

typedef ListNode *LinkList;
int delete(LinkList &p) {
    if(p -> link == NULL) return 0; //标注删除p的后继失败
    else {
        LinkList q;
        q = p -> link;
        p -> link = q -> link;
        delete q;
        return 1;
    }
}