• 线性表章节课后习题答案集锦

    目录

    2.5

    2.6

    2.7

    2.8

    2.9

    2.10

    2.11

    2.12

    2.13

    2.5

    1. /*
    2. 要比较两个单词在字典中的顺序，可以逐个比较它们的字符。首先比较两个单词的第一个字符，如果相同，则继续比较下一个字符，直到找到不同的字符或者某个单词比较完毕。比较时，可以利用ASCII码进行比较，因为字母在ASCII码中是按顺序排列的。
    3. */
    4. #include<stdio.h>
    5. #include<string.h>
    6.  
    7. int compareWords(char* word1, char* word2) {
    8.     int len1 = strlen(word1);
    9.     int len2 = strlen(word2);
    10.     int minLen = len1 < len2 ? len1 : len2;//三目运算符，如果？前面的式子成立，返回：前面的值，否则返回后面的 
    11.     int i;
    12.     for (i = 0; i < minLen; i++) {
    13.         if (word1[i] < word2[i]) {
    14.             return -1; // word1在字典中排在前面
    15.         } else if (word1[i] > word2[i]) {
    16.             return 1; // word2在字典中排在前面
    17.         }
    18.     }
    19.     // 如果前面的字符都相同，则长度较短的单词在字典中排在前面
    20.     if (len1 < len2) {
    21.         return -1;
    22.     } else if (len1 > len2) {
    23.         return 1;
    24.     }
    25.     // 两个单词相等
    26.     return 0;
    27. }
    28.  
    29. int main() {
    30.     char word1[] = "apple";
    31.     char word2[] = "banana";
    32.  
    33.     int result = compareWords(word1, word2);
    34.  
    35.     if (result < 0) {
    36.         printf("%s 在字典中排在 %s 前面\n", word1, word2);
    37.     } else if (result > 0) {
    38.         printf("%s 在字典中排在 %s 前面\n", word2, word1);
    39.     } else {
    40.         printf("%s 和 %s 相等\n", word1, word2);
    41.     }
    42.     return 0;
    43. }

    2.6

    1. /*
    2. 定义两个指针，分别指向顺序表的头部和尾部。
    3. 依次交换头部和尾部指针指向的元素，直到两个指针相遇或者交叉。
    4. 当两个指针相遇或者交叉时，表就地逆置完成。
    5. */
    6. #include<stdio.h>
    7. #define MaxSize 50
    8.  
    9. typedef int ElemType;
    10. typedef struct
    11. {
    12.     ElemType data[MaxSize]; // 存放顺序表元素
    13.     int length;             // 存放顺序表的长度
    14. } SqList;                   // 顺序表的类型
    15.  
    16. void InitList(SqList *L)
    17. {
    18.     L->length = 0;
    19. }
    20.  
    21. void CreateList(SqList *L, ElemType a[], int n)
    22. {
    23.     int i;
    24.     for (i = 0; i < n; i++)
    25.     {
    26.         L->data[i] = a[i];
    27.     }
    28.     L->length = n;
    29. }
    30.  
    31. void ReverseList(SqList *L)
    32. {
    33.     int i, temp;
    34.     for (i = 0; i < L->length / 2; i++)
    35.     {
    36.         // 交换位置i和length-i-1的元素
    37.         temp = L->data[i];
    38.         L->data[i] = L->data[L->length - i - 1];
    39.         L->data[L->length - i - 1] = temp;
    40.     }
    41. }
    42.  
    43. void DisplayList(SqList *L)
    44. {
    45. 	int i; 
    46.     for (i = 0; i < L->length; i++)
    47.     {
    48.         printf("%d ", L->data[i]);
    49.     }
    50.     printf("\n");
    51. }
    52.  
    53. int main()
    54. {
    55.     SqList L;
    56.     ElemType a[] = {1, 2, 3, 4, 5};
    57.     CreateList(&L, a, 5); // 创建顺序表
    58.     printf("原顺序表元素：");
    59.     DisplayList(&L);
    60.     ReverseList(&L); // 就地逆置顺序表
    61.     printf("逆置后顺序表元素：");
    62.     DisplayList(&L);
    63.     return 0;
    64. }

    2.7

    1. /*根据m和n的大小选择将谁接在谁的后面，设置指针分别指向两个链表开头，从端链表的开头开始向后移动，直到移动到最后，然后末尾接在下一个链表的第一个节点，两个链表连接在一起*/
    2. #include<stdio.h>
    3. #include<stdlib.h>
    4.  
    5. typedef struct Node {
    6.     int value;
    7.     struct Node* next;
    8. } LinkList;
    9.  
    10. LinkList* connect(LinkList* ha, LinkList* hb, int m, int n) {
    11.     LinkList* hc, *rear;
    12.     if (m >= n) {
    13.         hc = hb;
    14.         rear = ha;
    15.     }
    16.     else {
    17.         hc = ha;
    18.         rear = hb;
    19.     }
    20.     LinkList* head = hc;
    21.     while (hc->next != NULL) {
    22.         hc = hc->next;
    23.     }
    24.     hc->next = rear->next;
    25.     ha = hb = NULL;
    26.     return head;
    27. }
    28.  
    29. LinkList* createList(int arr[], int n) {
    30.     LinkList* rear;
    31.     LinkList* l = (LinkList*)malloc(sizeof(LinkList));
    32.     rear = l;
    33.     int i;
    34.     for (i = 0; i < n; i++) {
    35.         LinkList* tmp = (LinkList*)malloc(sizeof(LinkList));
    36.         tmp->value = arr[i];
    37.         rear->next = tmp;
    38.         rear = rear->next;
    39.     }
    40.     rear->next = NULL;
    41.     return l;
    42. }
    43.  
    44. int main() {
    45.     int a[] = { 1,5,6,2,1,7 };
    46.     int b[] = { 7,3,12,2,9,8,11 };
    47.     LinkList* l1 = createList(a, sizeof(a) / sizeof(a[0]));
    48.     LinkList* l2 = createList(b, sizeof(b) / sizeof(b[0]));
    49.     LinkList* l = connect(l1, l2, sizeof(a) / sizeof(a[0]), sizeof(b) / sizeof(b[0]));
    50.     l = l->next;
    51.     while (l != NULL) {
    52.         printf("%d ", l->value);
    53.         l = l->next;
    54.     }
    55.     return 0;
    56. }

    2.8

    1. /*定义指针分别指向两个链表的开头，以及开头的下一个元素，然后使用一个指针在两个链表之间交叉移动，将两个链表串起来*/
    2. #include<stdio.h>
    3. #include<stdlib.h>
    4. #define error -1;
    5. #define OK 1;
    6.  
    7. typedef int ElemType;//typedef表示重命名 
    8. typedef int status;
    9.  
    10. typedef struct LNode
    11. {
    12.     ElemType data;
    13.     struct LNode *next;
    14. }LNode, *LinkList;
    15.  
    16. LinkList creat()
    17. {//使用尾插法建立带头结点的单链表；
    18.     LinkList L;
    19.     L = (LinkList)malloc(sizeof(LNode));    //开辟头结点空间
    20.     if(!L){
    21.     	printf("memory malloc error!\n");
    22. 	}
    23.     LinkList p = L;
    24.     ElemType a;
    25.     int len;
    26.     
    27.     printf("请输入待建表的表长：");
    28.     scanf("%d", &len);
    29.     
    30.     if(len>0)
    31.     {
    32.     	int i;
    33.         for(i=0; i<len; i++)
    34.         {   
    35.             printf("请输入第%d个元素的值:", i+1);
    36.             scanf("%d", &a);
    37.             p->next = (LinkList)malloc(sizeof(LNode));
    38.             p->next->data = a;
    39.             p = p->next;
    40.         }
    41.     }
    42.     p->next = NULL;
    43.     return L;
    44. }
    45.  
    46. void print(LinkList L)
    47. {
    48.     LinkList p = L ->next;
    49.     while(p != NULL)
    50.     {
    51.         printf("%d\n", p->data);
    52.         p = p->next;
    53.     }
    54. }
    55. LinkList mix_connect(LinkList A, LinkList B)
    56. {//A,B均为带头结点的单链表，长度均未显式存储
    57.     if(A->next == NULL && B->next == NULL)
    58.         return NULL;
    59.     else
    60.     {
    61.         LinkList p = A->next;
    62.         LinkList q = B->next;
    63.         LinkList C = A; C->next = NULL;
    64.         LinkList s = C; 
    65.         free(B);
    66.         
    67.         while(p != NULL && q != NULL)
    68.         {
    69.             s->next = p;
    70.             p = p->next;
    71.             s = s->next;
    72.             s->next = q;
    73.             q = q->next;
    74.             s = s->next;
    75.         }
    76.         if(p != NULL)
    77.             s->next = p;
    78.         if(q != NULL)
    79.             s->next = q;    //这两个if只会执行其中一个
    80.         return C;
    81.     }
    82. }
    83. int main()
    84. {
    85.     LinkList A = creat();
    86.     LinkList B = creat();
    87.     
    88.     LinkList C=mix_connect(A, B);
    89.     print(C);
    90.     return 0;
    91. }

    2.9

    1. /*
    2. 创建三个循环链表，分别用于存放字母字符、数字字符和其它键盘字符。
    3. 遍历原链表，将不同类别的字符按照类别链接到对应的循环链表中。
    4. 遍历完成后，将每个循环链表的尾节点的 next 指针指向头节点，形成循环链表。
    5. */
    6. #include<stdio.h>
    7. #include<stdlib.h>
    8.  
    9. typedef struct Node {
    10.     char data;
    11.     struct Node* next;
    12. } Node, *LinkList;
    13.  
    14. void splitList(LinkList L, LinkList* alphabetList, LinkList* digitList, LinkList* otherList) {//遍历原链表，将不同类别的字符按照类别链接到对应的循环链表中。
    15.  
    16.     Node *p = L->next, *q, *r, *s, *t, *u;
    17.     *alphabetList = (LinkList)malloc(sizeof(Node));
    18.     *digitList = (LinkList)malloc(sizeof(Node));
    19.     *otherList = (LinkList)malloc(sizeof(Node));
    20.     (*alphabetList)->next = (*digitList)->next = (*otherList)->next = NULL;
    21.     q = *alphabetList;
    22.     r = *digitList;
    23.     s = *otherList;
    24.     while (p != NULL) {
    25.         if ((p->data >= 'a' && p->data <= 'z') || (p->data >= 'A' && p->data <= 'Z')) {
    26.             q->next = p;
    27.             q = p;
    28.         } else if (p->data >= '0' && p->data <= '9') {
    29.             r->next = p;
    30.             r = p;
    31.         } else {
    32.             s->next = p;
    33.             s = p;
    34.         }
    35.         p = p->next;
    36.     }
    37.     q->next = (*alphabetList)->next;
    38.     r->next = (*digitList)->next;
    39.     s->next = (*otherList)->next;
    40.     // 移除哑结点，并连接头指针到第一个有效节点上
    41.     *alphabetList = (*alphabetList)->next;
    42.     *digitList = (*digitList)->next;
    43.     *otherList = (*otherList)->next;
    44.     // 将最后一个节点的next指针置为NULL，避免环形链表
    45.     q->next = NULL;
    46.     r->next = NULL;
    47.     s->next = NULL;
    48. }
    49.  
    50. void printList(LinkList L) {
    51.     Node* p = L;
    52.     while (p != NULL) {
    53.         printf("%c ", p->data);
    54.         p = p->next;
    55.     }
    56.     printf("\n");
    57. }
    58.  
    59. int main() {
    60.     char chars[] = "a1b2c3!@#d4";
    61.     LinkList L = (LinkList)malloc(sizeof(Node));
    62.     Node* p = L;
    63.     int i;
    64.     for (i = 0; i < sizeof(chars) / sizeof(chars[0]); i++) {
    65.         Node* newNode = (Node*)malloc(sizeof(Node));
    66.         newNode->data = chars[i];
    67.         newNode->next = NULL;
    68.         p->next = newNode;
    69.         p = newNode;
    70.     }
    71.     LinkList alphabetList, digitList, otherList;//分别表示字母，数字和其它 
    72.     splitList(L, &alphabetList, &digitList, &otherList);
    73.     printf("Alphabet List: ");
    74.     printList(alphabetList);
    75.     printf("Digit List: ");
    76.     printList(digitList);
    77.     printf("Other List: ");
    78.     printList(otherList);
    79.     return 0;
    80. }

    2.10

    1. #include<stdio.h>
    2.  
    3. typedef int ElemType;
    4. typedef struct DuLNode{
    5. 	ElemType data;
    6. 	struct DuLNode *prior;
    7. 	struct DuLNode *next;
    8. } DuLNode, *DuLinkList;
    9.  
    10. //初始化双向循环链表(头节点)
    11. DuLinkList InitDuLinkList()
    12. {
    13. 	DuLNode *dnode = (DuLNode *)malloc(sizeof(DuLNode));
    14. 	dnode->data = 0;
    15. 	dnode->prior = dnode;
    16. 	dnode->next = dnode;
    17. 	return dnode;
    18. }
    19. //创建链表元素
    20. void CreateDuLinkList(DuLinkList L, ElemType *arr, int n)
    21. {
    22. 	DuLNode *dnode;
    23. 	DuLNode *p = L;
    24. 	int i;
    25. 	for (i = 0; i < n; i++)
    26. 	{
    27. 		dnode = (DuLNode *)malloc(sizeof(DuLNode));
    28. 		dnode->data = arr[i];
    29. 		dnode->next = L;
    30. 		dnode->prior = p;
    31. 		p->next = dnode;
    32. 		p = p->next;
    33. 	}
    34. }
    35. //输出链表
    36. void ShowList(DuLinkList L)
    37. {
    38. 	int i;
    39. 	DuLNode *r = L->next;
    40. 	while (r->next != L){
    41. 		printf("%d ", r->data);
    42. 		r = r->next;
    43. 	}
    44. 	printf("%d ", r->data);
    45. 	printf("\n");
    46. }
    47.  
    48. /*
    49. 将L中的元素，按如下规则插入新表，并返回新表。
    50. （1,2）->(1,3,2)->(1,3,4,2)->(1,3,5,4,2)->(1,3,5,6,4,2)->...
    51. */
    52. DuLinkList Transform(DuLinkList L)
    53. {
    54. 	DuLinkList Lnew = InitDuLinkList();
    55. 	DuLNode *p, *q, *pa, *pb;
    56. 	q = p = L->next;
    57. 	pa = pb = Lnew;
    58.  
    59. 	while (p != L)
    60. 	{
    61. 		if (p != L)
    62. 		{
    63. 			/*L中寄数个数据插入Lnew*/
    64. 			q = p->next;//保留 L 链表
    65. 			//pa之后插入p
    66. 			p->prior = pa;
    67. 			pa->next = p;
    68. 			p->next = pb;
    69. 			pb->prior = p;
    70.  
    71. 			pa = pa->next;
    72. 			p = q;//p指向 待操作 L
    73. 		}
    74. 		if (p != L)
    75. 		{
    76. 			/*L中偶数个数据插入Lnew*/
    77. 			q = p->next;//保留 L 链表
    78. 			//pb之前插入p
    79. 			p->next = pb;
    80. 			pb->prior = p;
    81. 			p->prior = pa;
    82. 			pa->next = p;
    83.  
    84. 			pb = pb->prior;
    85. 			p = q;//p指向 待操作 L
    86. 		}
    87. 	}
    88. 	return Lnew;
    89. }
    90.  
    91. int main()
    92. {
    93. 	ElemType data[7] = { 1, 2, 3, 4, 5, 6, 7 };//测试数据1（奇数个）
    94. 	//ElemType data[8] = { 1, 2, 3, 4, 5, 6, 7, 8 };//测试数据2（偶数个）
    95. 	int length = sizeof(data) / sizeof(ElemType);
    96. 	DuLinkList L = InitDuLinkList(), Lnew;
    97. 	CreateDuLinkList(L, data, length);
    98. 	printf("原链表：");
    99. 	ShowList(L);
    100.  
    101. 	Lnew = Transform(L);
    102. 	printf("改造表：");
    103. 	ShowList(Lnew);
    104.  
    105. 	getchar();
    106. 	return 0;
    107. }

    2.11

    1. /*从最小的位置开始，将后面的数据依次往前赋值，然后指针向后移动*/
    2. #include<stdio.h>
    3. #include<string.h>
    4. #include<stdlib.h>
    5.  
    6. typedef struct node
    7. {
    8. 	int data;//数据
    9. 	int length;//长度
    10. 	struct node  *next;
    11. }Node,*LinkList;
    12. //删除超过范围的内容
    13. void deLinkList(LinkList L,int mink,int maxk)
    14. {
    15. 	LinkList p,q;p=L;
    16. 	while(p!=NULL)
    17. 	{
    18. 		if(p->data>mink&&p->data<maxk)
    19. 		{
    20. 		printf("找到错误目标\n");
    21. 		q=p->next;
    22. 		p->data=q->data;
    23. 		p->next=q->next;
    24. 		free(q);
    25. 		}
    26. 		else p=p->next;
    27. 	}
    28. }
    29. //得到要输入的数据数量
    30. int getnumber()
    31. {
    32. 	int n;
    33. 	printf("请输入你要录入的数据数量：");
    34. 	scanf("%d",&n);
    35. 	return n;
    36. }
    37.  
    38. /*建立链表
    39. 后插入法创造链表
    40. 算法时间复杂度为O(n)
    41. */
    42. LinkList init(int n)
    43. {
    44. 	int i;
    45. 	LinkList L;
    46. 	Node *r;
    47. 	Node *p;
    48. 	L=(LinkList)malloc(sizeof(Node));//建立一个带头指针的空链表
    49. 	L->next=NULL;
    50. 	r=L;//尾指针r指向头结点
    51. 	for(i=1;i<=n;i++)
    52. 	{
    53. 		p=(Node *)malloc(sizeof(Node));//生成新结点
    54. 		printf("输入第%d位的数据：",i);//输入元素值赋给新结点*p的数据域
    55.      	scanf("%d",&p->data);
    56. 		p->next=NULL;//将新结点*p插入尾结点*r之后
    57. 		r->next=p;//r指向新的尾结点*p
    58. 		r=p;
    59. 	}
    60. 	L->length=n;
    61. 	return L;
    62. }
    63. //展示信息
    64. //算法的时间复杂度未O(n),n为单链表中的数据节点的个数
    65. void show(LinkList L)
    66. {
    67. 	int i=0;
    68. 	Node *p;
    69. 	p=L->next;
    70. 	while(p)
    71. 	{
    72. 		i++;
    73. 		printf("第%d位的数据:%d\n",i,p->data);
    74. 		p=p->next;
    75. 		
    76.  
    77. 	}
    78. 	printf("\n信息已全部输出\n");
    79.  
    80. }
    81. //主函数
    82. int main()
    83. {
    84. 	int n,mink,maxk;
    85. 	LinkList L;
    86. 	n=getnumber();
    87. 	L=init(n);
    88. 	show(L);
    89. 	//删除mink~maxk之间的元素
    90. 	printf("请输入mink、maxk的值\n");
    91. 	scanf("%d%d",&mink,&maxk);
    92. 	deLinkList(L,mink,maxk);
    93. 	show(L);
    94. 	free(L);
    95. }

    2.12

    1. #include<stdio.h>
    2. #include<stdlib.h>
    3.  
    4. typedef struct LNode
    5. {
    6.     int data;
    7.     struct LNode *next;
    8. }LNode, *LinkList;
    9.  
    10. int InitList(LinkList *L)
    11. {
    12.     *L = (LinkList)malloc(sizeof(LNode));
    13.     (*L)->next = NULL;
    14.     return 0;
    15. }
    16.  
    17. int CreateList(LinkList *L, int e)
    18. {
    19.     LinkList p = *L;
    20.     while(p->next)
    21.         p = p->next;
    22.     LinkList temp = (LinkList)malloc(sizeof(LNode));
    23.     temp->data = e;
    24.     temp->next = NULL;
    25.     p->next = temp;
    26.     return 0;
    27. }
    28.  
    29. int DispList(LinkList *L)
    30. {
    31.     LinkList p = (*L)->next;
    32.     while(p)
    33.     {
    34.         printf("%d\t", p->data);
    35.         p = p->next;
    36.     }
    37.     return 0;
    38. }
    39.  
    40. int ListOppose(LinkList *L)
    41. {
    42.     LinkList q, p, s;
    43.     p = *L;
    44.     p = p->next;
    45.     (*L)->next = NULL;
    46.     while(p)
    47.     {
    48.         q = p;
    49.         p = p->next;
    50.         q->next = (*L)->next;
    51.         (*L)->next = q;
    52.     }
    53.     return 0;
    54. }
    55.  
    56. int ListMerge(LinkList *A, LinkList *B, LinkList *C)
    57. {
    58.     LinkList qa, pa, pb, qb;
    59.     pa = *A;  qa = pa;   pa = pa->next;
    60.     pb = (*B)->next;
    61.     *C = *A;
    62.     while(pa && pb)
    63.     {
    64.         if(pa->data <= pb->data)
    65.         {
    66.             qb = pb;
    67.             pb = pb->next;
    68.             qb->next = qa->next;
    69.             qa->next = qb;
    70.             qa = qa->next;
    71.         }
    72.         else
    73.         {
    74.             qb = pb;
    75.             pb = pb->next;
    76.             qb->next = pa->next;
    77.             pa->next = qb;
    78.             pa = pa->next;
    79.         }
    80.     }
    81.     free(*B);
    82.     return 0;
    83. }
    84.  
    85. int main()
    86. {
    87.     LinkList A, B, C;
    88.     InitList(&A);    
    89. 	InitList(&B);
    90. 	int i;
    91.     for(i = 1; i< 6; i++)
    92.         CreateList(&A, i);
    93.     int j;
    94.     for(j = 4; j < 11; j++)
    95.         CreateList(&B, j);
    96.     printf("\nA 链表为:\n");
    97.     DispList(&A);
    98.     printf("\nB 链表为:\n");
    99.     DispList(&B);
    100.     printf("\nC 链表为:\n");
    101.     ListOppose(&A);
    102.     ListOppose(&B);
    103.     printf("\n逆置后的 A 链表为:\n");
    104.     DispList(&A);
    105.     printf("\n逆置后的 B 链表为:\n");
    106.     DispList(&B);
    107.  
    108.     ListMerge(&A, &B, &C);
    109.     printf("\n合并后的 C 链表为:\n");
    110.     DispList(&C);
    111.  
    112.     return 0;
    113. }

    2.13

    1. #include<stdio.h>
    2. #include<stdlib.h>
    3.  
    4. typedef struct {
    5.     int* data; // 存放元素的数组
    6.     int length; // 当前长度
    7.     int maxSize; // 最大长度
    8. } SqList;
    9.  
    10. // 初始化顺序表
    11. void initList(SqList* list, int maxSize) {
    12.     list->data = (int*)malloc(maxSize * sizeof(int));
    13.     list->length = 0;
    14.     list->maxSize = maxSize;
    15. }
    16.  
    17. // 在顺序表中查找元素的位置，返回位置下标
    18. int locateElem(SqList* list, int elem) {
    19. 	int i;
    20.     for (i = 0; i < list->length; i++) {
    21.         if (list->data[i] == elem) {
    22.             return i;
    23.         }
    24.     }
    25.     return -1; // 找不到返回-1
    26. }
    27.  
    28. // 添加元素到顺序表的末尾
    29. void addElem(SqList* list, int elem) {
    30.     if (list->length < list->maxSize) {
    31.         list->data[list->length++] = elem;
    32.     }
    33. }
    34.  
    35. // 求A和B的交集，结果保存在C中
    36. void intersection(SqList* A, SqList* B, SqList* C) {
    37.     int i = 0, j = 0;
    38.     while (i < A->length && j < B->length) {
    39.         if (A->data[i] == B->data[j]) {
    40.             addElem(C, A->data[i]);
    41.             i++;
    42.             j++;
    43.         } else if (A->data[i] < B->data[j]) {
    44.             i++;
    45.         } else {
    46.             j++;
    47.         }
    48.     }
    49. }
    50.  
    51. // 打印顺序表的元素
    52. void printList(SqList* list) {
    53. 	int i;
    54.     for (i = 0; i < list->length; i++) {
    55.         printf("%d ", list->data[i]);
    56.     }
    57.     printf("\n");
    58. }
    59.  
    60. int main() {
    61.     SqList A, B, C;
    62.     int maxSize = 10; // 假设最大长度为10
    63.     initList(&A, maxSize);
    64.     initList(&B, maxSize);
    65.     initList(&C, maxSize);
    66.  
    67.     // 假设A和B的元素是有序且不重复的
    68.     int a[] = {1, 3, 5, 7, 9};
    69.     int b[] = {3, 4, 5, 6, 7};
    70.     int i;
    71.     for (i = 0; i < sizeof(a) / sizeof(a[0]); i++) {
    72.         addElem(&A, a[i]);
    73.     }
    74.     int j;
    75.     for (j = 0; j < sizeof(b) / sizeof(b[0]); j++) {
    76.         addElem(&B, b[j]);
    77.     }
    78.  
    79.     printf("集合A：");
    80.     printList(&A);
    81.     printf("集合B：");
    82.     printList(&B);
    83.  
    84.     intersection(&A, &B, &C);
    85.  
    86.     printf("集合C（A和B的交集）：");
    87.     printList(&C);
    88.  
    89.     free(A.data);
    90.     free(B.data);
    91.     free(C.data);
    92.  
    93.     return 0;
    94. }
  • 相关阅读:
    【C++】C++面向对象编程三大特性之一——继承
    Java枚举类 （详细解析java中的枚举类深入浅出）
    自大型人格分析，如何改变自大型性格？
    杰理强制升级工具4.0使用和原理解析
    Star CCM+相关资料分享
    JavaEE 多线程下的HashTable、HashMap、ConcurrentHashMap
    价值1000元的稀有二开版的无限坐席在线客服系统源码+教程
    使用扩展有效对齐 SwiftUI 内容，创建自定义 SwiftUI 方法以快速对齐项目并使您的代码看起来简洁明了（教程含源码）
    微信小程序 js中写一个px单位转rpx单位的函数
    实例删除后volume仍然为in-use解决方法
  • 原文地址：https://blog.csdn.net/m0_72674633/article/details/136759141