数据结构实验教程-第三套

问题1:

已知递增有序的单链表A、B、C分别存储了一个集合。设计算法完成运算:A=A-B∩C

#include <cstddef>
#include <cstdio>
#include <cstdlib>
#define ElemType int

typedef struct Lnode {
    
    
    ElemType data;
    struct Lnode* next;
} Lnode, *LinkList;

void ListShow(LinkList L){
    
    
    for (Lnode *p = L->next;p;p = p->next){
    
    
        printf("%d\t",p->data);
    }
    printf("\n");
}

LinkList List_TailInsert(LinkList &L,int a[],int n){
    
    
    ElemType x;
    Lnode *s,*r;
    // r是尾指针，始终指向链表的尾部
    L = (LinkList)malloc(sizeof(Lnode));
    r = L;
   for(int i=0;i<n;i++){
    
    
        x = a[i];
        s = (Lnode*)malloc(sizeof(Lnode));
        s->next = r->next;
        r->next = s;
        s->data = x;
        r = s;
    }
    return L;
}

LinkList Union(LinkList &l1,LinkList &l2){
    
    
    Lnode *l3 = (Lnode*)malloc(sizeof(Lnode)),*p = l1->next,*q = l2->next,*rear = l3;
    l3->next = NULL;
    while (p&&q) {
    
    
        if(p->data == q->data){
    
    
            Lnode *tmp = (Lnode*)malloc(sizeof(Lnode));
            tmp->data = p->data;
            tmp->next = rear->next;
            rear->next = tmp;
            rear = tmp;
            p = p->next;
            q = q->next;
        }else if(p->data > q->data) q = q->next;
        else p = p->next;
    }
    return l3;
}

void Deduct(LinkList &l1,LinkList &l2){
    
    
    // 实现L1 - L2，结果直接储存到L1中
    Lnode *pre = l1,*p = l1->next,*q = l2->next;
    while (p&&q) {
    
    
        if(p->data == q->data){
    
    
            p = p->next;
            pre->next = p;
            // 删除节点
        }else if(p->data<q->data){
    
    
            pre = p;
            p = p->next;
        }else {
    
    
            q = q->next;
        }
    }
}
int main() {
    
    
    LinkList A,B,C,D;
    int a[] = {
    
    1,2,3,4,5,6,7,8,9},b[] = {
    
    1,3,5,7,9},c[] = {
    
    1,2,3,4,5};
    A = List_TailInsert(A,a,9);
    B = List_TailInsert(B,b,5);
    C = List_TailInsert(C,c,5);
    D = Union(C,B);
    ListShow(D);
    Deduct(A,D);
    ListShow(A);
    return 0;
}
// 已知递增有序的单链表A、B、C分别存储了一个集合。设计算法完成运算:A=A-B∩C

问题2:

#include<stdio.h>
#include<string.h>
#include <stdlib.h>


struct TreeNode {
    
    
     char val;
     struct TreeNode *left;
     struct TreeNode *right;
 };


struct TreeNode* Build(char *preorder,int p1,int p2,char *order,int o1,int o2){
    
    
    struct TreeNode *root = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    root->val = preorder[p1];
    int mid;
    for(mid = o1;order[mid]!=root->val;mid++) ;
    int llen = mid - o1;
    int rlen = o2 - mid;
    if(llen){
    
    
        root->left = Build(preorder,p1+1,p1+llen,order,o1,o1+llen-1);
    }
    else
        root->left = NULL;
    if(rlen){
    
    
        root->right = Build(preorder,p2-rlen+1,p2,order,o2-rlen+1,o2);
    }
    else
        root->right = NULL;
    return root;
}
struct TreeNode* buildTree(char* preorder, int preorderSize, char* inorder, int inorderSize){
    
    
    struct TreeNode *root;
    root = Build(preorder,0,preorderSize-1,inorder,0,inorderSize-1);
    return root;
}

void PrintLevel(struct TreeNode *root,int level){
    
    
    if(!root) return;
    printf("(%c,%d)\t",root->val,level);
    PrintLevel(root->left,level+1);
    PrintLevel(root->right,level+1);
}
int main()
{
    
    
    char *pre = "ABCDEFGHIJK";
    char *in = "CBEDFAHGJIK";
    struct TreeNode* t = buildTree(pre,11,in,11);
    PrintLevel(t,1);

    return 0;
}

问题3:

#define Maxsize 100
int martx[n][n] = {
    
    0};
//邻接矩阵
int visited[n];
void BFS(Graph G,int v){
    
    
    //广度优先遍历,从v开始
    int queue[Maxsize],tmp;
    int front = -1,rear = -1;
    visited[v] = 1;
    //将当前节点标记为已访问
    queue[++rear] = v;
    //入队
    while(rear>front){
    
    
        //队列非空
        tmp = queue[++front];
        //出队
        arcnode *p = G->vartex[tmp].firstarc;
        while(p){
    
    
            int j = p->adjvex;
            if(visited[j] == 0){
    
    
                queue[++rear] = j;
                visited[j] = 1;
                martx[v][j] = 1;
                martx[j][v] = 1;
                //由于是无向图，所以邻接矩阵对称
            }
            p = p->nextarc;
        }
    }
}

void BFSTraverse(Graph G){
    
    
    for(int i=0;i<G->vexnum;i++)
        visited[i] = 0;
    for(int i=0;i<G->vexnum;i++)
        if(visited[i] == 0)
            BFS(G,i);
}