devbox
盐析白兔
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

头歌 单链表的基本操作_头歌单链表的基本操作答案

作者：盐析白兔 | 2024-05-28 08:49:57

赞

踩

头歌单链表的基本操作答案

第1关 单链表的插入操作

  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <iostream>
  4. using namespace std;
  5.  
  6. /* 定义ElemType为int类型 */
  7. typedef int ElemType;
  8. void input(ElemType &s);
  9. void output(ElemType s);
  10. int equals(ElemType a,ElemType b);
  11. /* 单链表类型定义 */
  12. typedef struct LNnode
  13. {	
  14. 	ElemType data;
  15. 	struct LNnode *next;
  16. }LNnode,*LinkList;
  17.  
  18. void InitList(LinkList &L);
  19. int ListInsert(LinkList &L,int i,int e) ;
  20. void ListTraverse(LinkList L,void(*vi)(ElemType));
  21.  
  22. int main()               //main() function 
  23. {	
  24.      LinkList A;
  25.      ElemType e;
  26.      InitList(A);
  27.       int n,i;
  28.      // cout<<"Please input the list number ";
  29.      cin>>n;
  30.      for(i=1;i<=n;i++)
  31.         { 
  32. 		   cin>>e;
  33.          ListInsert(A, i, e);
  34.        }
  35. 	//cout<<"请输入插入的位置："<<endl;
  36. 	cin>>i;
  37. 	//cout<<"请输入插入的值："<<endl;
  38. 	input(e);
  39. 	if(  ListInsert(A,i,e) )
  40.     {
  41.       cout<<"插入成功，插入后单链表如下："<<endl;
  42.       ListTraverse(A,output) ;
  43.     }
  44.     else
  45.     	cout<<"插入位置不合法，插入失败！"<<endl;
  46.     return  0;  
  47.  }
  48.  
  49.  
  50. /*****ElemType类型元素的基本操作*****/
  51. void input(ElemType &s)
  52. {
  53. cin>>s;
  54. }
  55. void output(ElemType s)
  56.  {
  57. cout<<s<<" ";
  58. }
  59. int equals(ElemType a,ElemType b)
  60. {
  61. 	if(a==b)
  62. 		return  1;
  63. 	else
  64. 		return  0;
  65. }
  66.  
  67. /*****单链表的基本操作*****/
  68. void InitList(LinkList &L)
  69. { 
  70. 	// 操作结果：构造一个空的单链表L
  71. 	/********** Begin **********/ 
  72.     L = (LinkList )malloc(sizeof(LNnode));
  73.     if(!L) return ;
  74.     L->next = nullptr;
  75. 	/********** End **********/
  76. }
  77. int ListInsert(LinkList &L,int i,int e) 
  78. {
  79. 	// 在带头结点的单链线性表L的第i个元素之前插入元素e  
  80. 	/********** Begin **********/ 
  81.     if(!L) return 0;
  82.  
  83.     LinkList p = L;
  84.     for(int j = 1;j<i && p;j++){
  85.         p=p->next;
  86.     }
  87.     if(!p) return 0;
  88.     LinkList a = (LinkList ) malloc(sizeof(LNnode));
  89.     if(!a) return 0;
  90.     a->data = e;
  91.     a->next = p->next;
  92.     p->next = a;
  93.     return 1;
  94. 	/********** End **********/
  95. }
  96.  
  97. void ListTraverse(LinkList L,void(*vi)(ElemType))
  98. { 
  99. 	// 初始条件：单链表L已存在。
  100. 	//操作结果：依次对L的每个数据元素调用函数vi()
  101. 	/********** Begin **********/ 
  102.     LinkList p = L;
  103.     while(p->next != nullptr){
  104.         vi(p->next->data);
  105.         p=p->next;
  106.     }   
  107. 	/********** End **********/
  108. }

 第2关 单链表的删除操作

  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <iostream>
  4. using namespace std;
  5.  
  6. /* 定义ElemType为int类型 */
  7. typedef int ElemType;
  8. void input(ElemType &s);
  9. void output(ElemType s);
  10. int equals(ElemType a,ElemType b);
  11.  
  12. /* 单链表类型定义 */
  13. typedef struct LNnode
  14. {	
  15. 	ElemType data;
  16. 	struct LNnode *next;
  17. }LNnode,*LinkList;
  18.  
  19. void InitList(LinkList &L);
  20. int ListInsert(LinkList &L,int i,int e) ;
  21. int ListDelete(LinkList L,int i,ElemType &e);
  22. void ListTraverse(LinkList L,void(*vi)(ElemType));
  23.  
  24. int main()               //main() function 
  25. {	
  26. 	LinkList A;
  27. 	ElemType e;
  28. 	InitList(A);
  29. 	int n,i;
  30. 	// cout<<"Please input the list number ";
  31. 	cin>>n;
  32. 	for(i=1;i<=n;i++)
  33. 	{ 
  34. 		cin>>e;
  35. 		ListInsert(A, i, e);
  36. 	}
  37. 	//cout<<"请输入删除的位置："<<endl;
  38. 	cin>>i;	
  39. 	if(  ListDelete(A,i,e) )
  40. 	{
  41. 		cout<<"删除成功，删除后单链表如下："<<endl;
  42. 		ListTraverse(A,output) ;
  43. 		cout<<"删除元素的值：";
  44. 	   output(e);
  45.    	   cout<<endl;
  46. 	}
  47. 	else
  48. 		cout<<"删除位置不合法，删除失败！"<<endl;
  49. }
  50.  
  51.  
  52.  
  53. /*****ElemType类型元素的基本操作*****/
  54. void input(ElemType &s)
  55. {
  56. 	cin>>s;
  57. }
  58. void output(ElemType s)
  59. {
  60. 	cout<<s<<" ";
  61. }
  62. int equals(ElemType a,ElemType b)
  63. {
  64. 	if(a==b)
  65. 		return  1;
  66. 	else
  67. 		return  0;
  68. }
  69.  
  70. /*****单链表的基本操作*****/
  71. void InitList(LinkList &L)
  72. { 	// 构造一个空的单链表L	
  73. 	L=(LinkList)malloc(sizeof(LNnode)); // 产生头结点，并使L指向此头结点
  74. 	if(!L) // 存储分配失败
  75. 		return ;
  76. 	L->next=NULL; // 指针域为空
  77. 	
  78. }
  79.  
  80. int ListInsert(LinkList &L,int i,ElemType e) 
  81. {	// 在带头结点的单链线性表L的第i个元素之前插入元素e  
  82. 	LinkList p,s;
  83. 	p = L;   
  84. 	int j = 0;
  85. 	while (p && j < i-1) {  // 寻找第i-1个结点
  86. 		p = p->next;
  87. 		++j;
  88. 	} 
  89. 	if (!p || j > i-1) 
  90. 		return 0;                   // i小于1或者大于表长
  91. 	s = (LinkList)malloc(sizeof(LNnode));  // 生成新结点
  92. 	s->data = e;  s->next = p->next;      // 插入L中
  93. 	p->next = s;
  94. 	return 1;
  95. }
  96.  
  97. void ListTraverse(LinkList L,void(*vi)(ElemType))
  98. { 	// 调用函数vi()依次输出单链表L的每个数据元素
  99. 	LinkList p=L->next;
  100. 	while(p)
  101. 	{
  102. 		vi(p->data);
  103. 		p=p->next;
  104. 	}
  105. 	printf("\n");	
  106. }
  107.  
  108. int  ListDelete(LinkList L,int i,ElemType &e) // 算法2.10。不改变L
  109. { 
  110. 	// 在带头结点的单链线性表L中，删除第i个元素，并由e返回其值
  111. 	/********** Begin **********/ 
  112.     if(!L->next) return 0;
  113.  
  114.     LinkList up = L ;
  115.     LinkList p = up->next;
  116.     if(i==1){
  117.         e  = L->next->data;
  118.         LinkList t = L->next;
  119.         L->next = L->next->next;
  120.         free(t);
  121.         return e;
  122.     }
  123.     for(int j = 1;j<i && p;j++){
  124.         p = p->next;
  125.         up = up->next;
  126.     }
  127.     if(!p) return 0 ;
  128.     LinkList t = p;
  129.     up->next = p->next;
  130.     e = t->data;
  131.     free(t);
  132.     return e;
  133. 	/********** End **********/
  134. }

 第3关 单链表的按照序号查找值操作

  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <iostream>
  4. using namespace std;
  5.  
  6. /* 定义ElemType为int类型 */
  7. typedef int ElemType;
  8. void input(ElemType &s);
  9. void output(ElemType s);
  10. int equals(ElemType a,ElemType b);
  11.  
  12. /* 单链表类型定义 */
  13. typedef struct LNnode
  14. {	
  15. 	ElemType data;
  16. 	struct LNnode *next;
  17. }LNnode,*LinkList;
  18.  
  19. void InitList(LinkList &L);
  20. int ListInsert(LinkList &L,int i,int e) ;
  21. void ListTraverse(LinkList L,void(*vi)(ElemType));
  22. int GetElem(LinkList L,int i,ElemType &e) ;
  23.  
  24. int main()               //main() function 
  25. {	
  26. 	LinkList A;
  27. 	ElemType e;
  28. 	InitList(A);
  29. 	int n,i;
  30. 	// cout<<"Please input the list number ";
  31. 	cin>>n;
  32. 	for(i=1;i<=n;i++)
  33. 	{ 
  34. 		cin>>e;
  35. 		ListInsert(A, i, e);
  36. 	}
  37. 	//cout<<"请输入查找的序号："<<endl;
  38. 	cin>>i;	
  39. 	if(  GetElem(A,i,e) )
  40. 	{
  41. 		cout<<"查找成功！"<<endl;
  42. 		cout<<"第"<<i<<"个元素的值："<<endl;
  43. 	    output(e);
  44.         cout<<endl;
  45. 	}
  46. 	else
  47. 		cout<<"查找失败！"<<endl;
  48. }
  49.  
  50. /*****ElemType类型元素的基本操作*****/
  51. void input(ElemType &s)
  52. {
  53. 	cin>>s;
  54. }
  55. void output(ElemType s)
  56. {
  57. 	cout<<s<<" ";
  58. }
  59. int equals(ElemType a,ElemType b)
  60. {
  61. 	if(a==b)
  62. 		return  1;
  63. 	else
  64. 		return  0;
  65. }
  66.  
  67. /*****单链表的基本操作*****/
  68. void InitList(LinkList &L)
  69. { 	// 操作结果：构造一个空的单链表L
  70. 	L=(LinkList)malloc(sizeof(LNnode)); // 产生头结点，并使L指向此头结点
  71. 	if(!L) // 存储分配失败
  72. 		return ;
  73. 	L->next=NULL; // 指针域为空
  74. 	
  75. }
  76.  
  77. int ListInsert(LinkList &L,int i,ElemType e) 
  78. {	// 在带头结点的单链线性表L的第i个元素之前插入元素e  
  79. 	LinkList p,s;
  80. 	p = L;   
  81. 	int j = 0;
  82. 	while (p && j < i-1) {  // 寻找第i-1个结点
  83. 		p = p->next;
  84. 		++j;
  85. 	} 
  86. 	if (!p || j > i-1) 
  87. 		return 0;                   // i小于1或者大于表长
  88. 	s = (LinkList)malloc(sizeof(LNnode));  // 生成新结点
  89. 	s->data = e;  s->next = p->next;      // 插入L中
  90. 	p->next = s;
  91. 	return 1;
  92. }
  93.  
  94. void ListTraverse(LinkList L,void(*vi)(ElemType))
  95. { 	// 初始条件：单链表L已存在。
  96. 	//操作结果：依次对L的每个数据元素调用函数vi()
  97. 	LinkList p=L->next;
  98. 	while(p)
  99. 	{
  100. 		vi(p->data);
  101. 		p=p->next;
  102. 	}
  103. 	printf("\n");
  104. }
  105.  
  106. int GetElem(LinkList L,int i,ElemType &e) 
  107. { 
  108. 	// L为带头结点的单链表的头指针。当第i个元素存在时，其值赋给e并返回1，否则返回0
  109. 	/********** Begin **********/ 
  110. 	if(!L->next) return 0;
  111.     LinkList p = L;
  112.     for(int j =0;j<i && p;j++){
  113.         p = p->next;
  114.     }
  115.     if(!p) return 0;
  116.     e = p->data;
  117.     return e;
  118.     
  119. 	/********** End **********/
  120. }

 第4关 单链表的按照值查找结点位序的操作

  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <iostream>
  4. using namespace std;
  5.  
  6.  
  7. /* 定义ElemType为int类型 */
  8. typedef int ElemType;
  9. void input(ElemType &s);
  10. void output(ElemType s);
  11. int equals(ElemType a,ElemType b);
  12.  
  13. /* 单链表类型定义 */
  14. typedef struct LNnode
  15. {	
  16. 	ElemType data;
  17. 	struct LNnode *next;
  18. }LNnode,*LinkList;
  19. void InitList(LinkList &L);
  20. int ListInsert(LinkList &L,int i,int e) ;
  21. void ListTraverse(LinkList L,void(*vi)(ElemType));
  22. int LocateElem(LinkList L,ElemType e,int(*compare)(ElemType,ElemType));
  23. int main()               //main() function 
  24. {	
  25. 	LinkList A;
  26. 	ElemType e;
  27. 	InitList(A);
  28. 	int n,i;
  29. 	// cout<<"Please input the list number ";
  30. 	cin>>n;
  31. 	for(i=1;i<=n;i++)
  32. 	{ 
  33. 		cin>>e;
  34. 		ListInsert(A, i, e);
  35. 	}
  36. 	//cout<<"请输入查找的元素："<<endl;
  37. 	cin>>e;	
  38. 	i=LocateElem(A,e,equals);
  39. 	if( i ) 
  40. 	{
  41. 		cout<<"查找成功！"<<endl;		
  42. 	    output(e);
  43.       cout<<"是单链表第"<<i<<"个元素"<<endl;
  44. 	}
  45. 	else
  46. 		cout<<"查找失败！"<<endl;
  47. }
  48.  
  49.  
  50.  
  51. /*****ElemType类型元素的基本操作*****/
  52. void input(ElemType &s)
  53. {
  54. 	cin>>s;
  55. }
  56. void output(ElemType s)
  57. {
  58. 	cout<<s<<" ";
  59. }
  60. int equals(ElemType a,ElemType b)
  61. {
  62. 	if(a==b)
  63. 		return  1;
  64. 	else
  65. 		return  0;
  66. }
  67.  
  68. /*****单链表的基本操作*****/
  69. void InitList(LinkList &L)
  70. { 	// 操作结果：构造一个空的单链表L
  71. 	L=(LinkList)malloc(sizeof(LNnode)); // 产生头结点，并使L指向此头结点
  72. 	if(!L) // 存储分配失败
  73. 		return ;
  74. 	L->next=NULL; // 指针域为空	
  75. }
  76.  
  77. int ListInsert(LinkList &L,int i,ElemType e) 
  78. {	// 在带头结点的单链线性表L的第i个元素之前插入元素e  
  79. 	LinkList p,s;
  80. 	p = L;   
  81. 	int j = 0;
  82. 	while (p && j < i-1) {  // 寻找第i-1个结点
  83. 		p = p->next;
  84. 		++j;
  85. 	} 
  86. 	if (!p || j > i-1) 
  87. 		return 0;                   // i小于1或者大于表长
  88. 	s = (LinkList)malloc(sizeof(LNnode));  // 生成新结点
  89. 	s->data = e; 
  90.     s->next = p->next;      // 插入L中
  91. 	p->next = s;
  92. 	return 1;	
  93. }
  94.  
  95. void ListTraverse(LinkList L,void(*vi)(ElemType))
  96. { 	// 初始条件：单链表L已存在。
  97. 	//操作结果：依次对L的每个数据元素调用函数vi()
  98. 	LinkList p=L->next;
  99. 	while(p)
  100. 	{
  101. 		vi(p->data);
  102. 		p=p->next;
  103. 	}
  104. 	printf("\n");
  105. }
  106.  
  107. int LocateElem(LinkList L,ElemType e,int (*equal)(ElemType,ElemType))
  108. { 
  109. 	// 初始条件: 单链表L已存在，equal()是数据元素判定函数(满足为1，否则为0)
  110. 	// 操作结果: 返回L中第1个与e满足关系equal()的数据元素的位序，若这样的数据元素不存在，则返回值为0
  111. 	/********** Begin **********/ 
  112. 	if(!L->next) return 0;
  113.     LinkList p = L->next;
  114.     for(int i = 1;p;i++){
  115.         if(equal(p->data,e))
  116.             return i;
  117.         p = p->next;
  118.     }
  119. 	/********** End **********/
  120. }

第5关 单链表的逆置操作

  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <iostream>
  4. using namespace std;
  5.  
  6. /* 定义ElemType为int类型 */
  7. typedef int ElemType;
  8. void input(ElemType &s);
  9. void output(ElemType s);
  10. int equals(ElemType a,ElemType b);
  11.  
  12. /* 单链表类型定义 */
  13. typedef struct LNnode
  14. {	
  15. 	ElemType data;
  16. 	struct LNnode *next;
  17. }LNnode,*LinkList;
  18. void InitList(LinkList &L);
  19. int ListInsert(LinkList &L,int i,int e) ;
  20. void ListTraverse(LinkList L,void(*vi)(ElemType));
  21. void reverse (LinkList  L);
  22. int main()               //main() function 
  23. {	
  24. 	LinkList A;
  25. 	ElemType e;
  26. 	InitList(A);
  27. 	int n,i;
  28. 	// cout<<"Please input the list number ";
  29. 	cin>>n;
  30. 	for(i=1;i<=n;i++)
  31. 	{ 
  32. 		cin>>e;
  33. 		ListInsert(A, i, e);
  34. 	}
  35. 	cout<<"逆置单链表："<<endl;
  36. 	reverse(A);
  37. 	ListTraverse(A,output) ;	
  38. }
  39.  
  40. /*****ElemType类型元素的基本操作*****/
  41. void input(ElemType &s)
  42. {
  43. 	cin>>s;
  44. }
  45. void output(ElemType s)
  46. {
  47. 	cout<<s<<" ";
  48. }
  49. int equals(ElemType a,ElemType b)
  50. {
  51. 	if(a==b)
  52. 		return  1;
  53. 	else
  54. 		return  0;
  55. }
  56.  
  57. /*****单链表的基本操作*****/
  58. void InitList(LinkList &L)
  59. { 	// 操作结果：构造一个空的单链表L
  60. 	L=(LinkList)malloc(sizeof(LNnode)); // 产生头结点，并使L指向此头结点
  61. 	if(!L) // 存储分配失败
  62. 		return ;
  63. 	L->next=NULL; // 指针域为空	
  64. }
  65.  
  66. int ListInsert(LinkList &L,int i,ElemType e) 
  67. {	// 在带头结点的单链线性表L的第i个元素之前插入元素e  
  68. 	LinkList p,s;
  69. 	p = L;   
  70. 	int j = 0;
  71. 	while (p && j < i-1) {  // 寻找第i-1个结点
  72. 		p = p->next;
  73. 		++j;
  74. 	} 
  75. 	if (!p || j > i-1) 
  76. 		return 0;                   // i小于1或者大于表长
  77. 	s = (LinkList)malloc(sizeof(LNnode));  // 生成新结点
  78. 	s->data = e;  s->next = p->next;      // 插入L中
  79. 	p->next = s;
  80. 	return 1;	
  81. }
  82.  
  83. void ListTraverse(LinkList L,void(*vi)(ElemType))
  84. { 	// 初始条件：单链表L已存在。
  85. 	//操作结果：依次对L的每个数据元素调用函数vi()
  86. 	LinkList p=L->next;
  87. 	while(p)
  88. 	{
  89. 		vi(p->data);
  90. 		p=p->next;
  91. 	}
  92. 	printf("\n");	
  93. }
  94.  
  95. void reverse (LinkList  L)
  96. {  
  97. 	//逆置L指针所指向的单链表
  98. 	/********** Begin **********/ 
  99.     LinkList l = L->next;
  100.     LinkList end = l->next;
  101.     LinkList t;
  102.     while(end){
  103.         t = L->next;
  104.         L->next = l->next;
  105.         l->next = end->next;
  106.         end->next = t;
  107.         end = l->next;
  108.     }
  109.  
  110.  
  111.     
  112. 	/********** End **********/
  113. }

 第6关 两个有序单链表的合并操作

  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <iostream>
  4.  
  5. using namespace std;
  6.  
  7. /* 定义ElemType为int类型 */
  8. typedef int ElemType;
  9.  
  10. void input(ElemType &s);
  11.  
  12. void output(ElemType s);
  13.  
  14. int equals(ElemType a, ElemType b);
  15.  
  16. /* 单链表类型定义 */
  17. typedef struct LNnode {
  18.     ElemType data;
  19.     struct LNnode *next;
  20. } LNnode, *LinkList;
  21.  
  22. void InitList(LinkList &L);
  23.  
  24. int ListInsert(LinkList &L, int i, int e);
  25.  
  26. void ListTraverse(LinkList L, void(*vi)(ElemType));
  27.  
  28. void MergeList(LinkList &La, LinkList &Lb, LinkList &Lc);
  29.  
  30. int main()               //main() function
  31. {
  32.     LinkList A, B, C;
  33.     ElemType e;
  34.     InitList(A);
  35.     InitList(B);
  36.     int n, i;
  37.     // cout<<"Please input the list number ";
  38.     cin >> n;
  39.     for (i = 1; i <= n; i++) {
  40.         cin >> e;
  41.         ListInsert(A, i, e);
  42.     }
  43.     cin >> n;
  44.     for (i = 1; i <= n; i++) {
  45.         cin >> e;
  46.         ListInsert(B, i, e);
  47.     }
  48.     cout << "合并两个有序单链表：" << endl;
  49.     MergeList(A, B, C);
  50.     
  51.     ListTraverse(C, output);
  52. }
  53.  
  54. /*****ElemType类型元素的基本操作*****/
  55. void input(ElemType &s) {
  56.     cin >> s;
  57. }
  58.  
  59. void output(ElemType s) {
  60.     cout << s << " ";
  61. }
  62.  
  63. int equals(ElemType a, ElemType b) {
  64.     if (a == b)
  65.         return 1;
  66.     else
  67.         return 0;
  68. }
  69.  
  70. /*****单链表的基本操作*****/
  71. void InitList(LinkList &L) {    // 操作结果：构造一个空的单链表L
  72.     L = (LinkList) malloc(sizeof(LNnode)); // 产生头结点，并使L指向此头结点
  73.     if (!L) // 存储分配失败
  74.         return;
  75.     L->next = NULL; // 指针域为空
  76. }
  77.  
  78. int ListInsert(LinkList &L, int i, ElemType e) {    // 在带头结点的单链线性表L的第i个元素之前插入元素e
  79.     LinkList p, s;
  80.     p = L;
  81.     int j = 0;
  82.     while (p && j < i - 1) {  // 寻找第i-1个结点
  83.         p = p->next;
  84.         ++j;
  85.     }
  86.     if (!p || j > i - 1)
  87.         return 0;                   // i小于1或者大于表长
  88.     s = (LinkList) malloc(sizeof(LNnode));  // 生成新结点
  89.     s->data = e;
  90.     s->next = p->next;      // 插入L中
  91.     p->next = s;
  92.     return 1;
  93. }
  94.  
  95. void ListTraverse(LinkList L, void(*vi)(ElemType)) {    // 初始条件：单链表L已存在。
  96.     //操作结果：依次对L的每个数据元素调用函数vi()
  97.     LinkList p = L->next;
  98.     while (p) {
  99.         vi(p->data);
  100.         p = p->next;
  101.     }
  102.     printf("\n");
  103. }
  104.  
  105. void MergeList(LinkList &La, LinkList &Lb, LinkList &Lc) {    // LC 只是指正 没有指向任何地址
  106.     // 已知单链线性表La和Lb的元素按值非递减排列。
  107.     // 归并La和Lb得到新的单链线性表Lc，Lc的元素也按值非递减排列。
  108.     /********** Begin **********/
  109.  
  110.     LinkList a = La->next, b = Lb->next, c = La;
  111.     Lc = c;
  112.  
  113.     while (a && b) {
  114.         LinkList t= (LinkList) malloc(sizeof(LNnode));
  115.         if (!t) return;
  116.         t->next = nullptr;
  117.  
  118.         if (a->data < b->data) {
  119.             t->data = a->data;
  120.             c->next = t;
  121.             c = c->next;
  122.             a = a->next;
  123.         }else {
  124.             t->data = b->data;
  125.             c->next = t;
  126.             c = c->next;
  127.             b = b->next;
  128.         }
  129.     }
  130.  
  131.     while (a) {
  132.         LinkList t= (LinkList) malloc(sizeof(LNnode));
  133.         if (!t) return;
  134.         t->next = nullptr;
  135.  
  136.         t->data = a->data;
  137.         c->next = t;
  138.         c = c->next;
  139.         a = a->next;
  140.     }
  141.     while (b) {
  142.         LinkList t= (LinkList) malloc(sizeof(LNnode));
  143.         if (!t) return;
  144.         t->next = nullptr;
  145.         t->data = b->data;
  146.         c->next = t;
  147.         c = c->next;
  148.         b = b->next;
  149.     }
  150.  
  151.     /********** End **********/
  152. }
  153.

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/盐析白兔/article/detail/636639
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号