【数据结构】头歌实践教学平台·链表_链表的逆转头歌

题目练习

1.尾插法建立单链表

要求

从键盘上输入n个整数，用尾插法建立一个带头结点的单链表。

代码

void CreateList(LinkList &L, int n)
{   //尾插法建立一个带结点的单链表    
    /**************begin************/
    LNode *p, *r;
    L = new LNode;
    L->next = NULL;
    r = L;
    for (int i = 0; i < n; i++) {
        p = new LNode;
        cin >> p->data;
        p->next = NULL;
        r->next = p;
        r = p;
    }
    /**************end************/
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

2.查找单链表中结点的最大值

要求

通过一趟遍历在单链表中确定值最大的结点。

代码

Status MaxData(LinkList L, int &max)
{  //L为带头结点的单链表，若L为空链表表，函数返回ERROR，否则获取链表结点的最大值max,函数返回OK
   /**************begin************/
    LNode *p = L->next;
    LNode *pmax;
    if (p == NULL) return ERROR;
    max=-100;    //用来记录最大值
    while (p != NULL){
        if(p->data > max){
            max = p->data;
            pmax = p;
        }
        p = p->next;
    }
    pmax->data = max;
    return OK;
}
    /**************end************/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

3.删除链表中满足区间值的结点

要求

利用单链表表示一个整数序列，删除链表中值大于等于mink且小于等于maxk的所有元素（mink和maxk是给定的两个参数，其值可以和表中的元素相同，也可以不同）。

代码

void DeleteMinMax(LinkList &L,ElemType mink,ElemType maxk)
{   //删除链表中满足区间值的结点
    /**************begin************/
    LNode *p = L;
	while (p) {
		LNode *q = p, *r = p->next;
		while (r) {
			if (r->data >= mink && r->data <= maxk){
				LNode *s = r;
				q->next = r->next;
				r = r->next;
				delete s;
			}
			else{
				q = r;
				r = r->next;
			}
		}	
		p = p->next;
	}
}
    /**************end************/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

4.链表的逆转

要求

利用单链表表示一个整数序列，通过一趟遍历，将单链表中所有结点的链接方向逆转。要求空间复杂度为O(1)。

代码

void Reverse(LinkList &L)
{   //逆置带头结点的单链表L
    /**************begin************/
    LNode *head = L;
    
    LNode *p = head->next;
    LNode *pre = NULL;
    LNode *end = p->next;

    while (p)
    {
        p->next = pre;
        pre = p;
        p = end;
        if (p) {
            end = p->next;
        }
    }
    head->next = pre;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

别人的代码：

linkList reverseLinkList(linkList head) {
	linkList p,pre,latter;
	p= head->next;//当前节点
	pre=NULL;//前一结点
	latter=p->next;//下一节点
	while(p)
	{
		p->next=pre;
		pre=p;
		p=latter;
		if(p){
            latter=p->next;
		}
	}
	head->next=pre;//连入头节点
	return head;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

5.查找链表中倒数第k个结点

要求

利用单链表表示一个整数序列，请实现一个时间复杂度为O(n)、空间复杂度为O(1)的算法，通过一趟遍历在单链表中确定倒数第k个结点。

代码

void Search_k(LinkList L,int k)
{   //在带头结点的单链表L中查找倒数第k个数 
    /**************begin************/
    int len = 0;
    LNode *p = L;
    while (p) {
        len++;
        p = p->next;
    }
    if (k < len && k > 0) {
        p = L;
        for (int i = 1; i < len - k + 1; i++) {
            p = p->next;
        }
        cout << p->data;
    }
    /**************end************/
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

6.基于链表的两个非递减有序序列的合并

要求

给定两个非递减的整数序列LA和LB，利用链表表示序列LA和LB，将LA和LB合并为一个非递增的有序序列LC，序列LC包含LA和LB的所有元素，且元素依然非递减有序。要求空间复杂度为O(1)。

代码

void MergeList(LinkList &La,LinkList &Lb,LinkList &Lc){
   //将两个带头结点的非递减有序表La,Lb，利用原表空间，合并成一个新的非递减有序表Lc 
   /**************begin************/
   LNode *pa = La->next;
   LNode *pb = Lb->next;
   Lc = La;
   LNode *pc = Lc;
   while (pa && pb) {
       if (pa->data <= pb->data) {
           pc->next = pa;
           pc = pa;
           pa = pa->next;
       }
       else {
           pc->next = pb;
           pc = pb;
           pb = pb->next;
       }
   }
   pc->next = pa ? pa : pb;
   delete Lb;
   /**************end************/
}//MergeList 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23