单链表与leetcode典型题目(C++)_leetcode 单链表 c

---

前言

给出单链表两种程序实现方法，一种是用数组模拟单链表，一种是结构体实现单链表；分析单链表常见的插入、删除、遍历操作；结合Leetcode典型题目，给出头插法、尾插法、双指针的程序实现。

---

链表

链表是一种线性数据结构，是线性表的一种，内存中用一段不连续的内存空间来存储，每个结点保存下一个相邻结点的地址，以此来实现表的线性结构，像一条链子一样链接在一起。

单链表

单链表顾名思义单向链表，通过每一个结点next域的值可以找到下一个结点的位置，比如下图第二个结点的地址0x34，第一个结点next域保存这个0x34，通过当前结点 next域就能以O(1)的时间复杂度找到下一个结点，如果想要找到上一个结点需要遍历整个链表，时间复杂度是O(n)。

利用数组实现单链表结构

数组实现单链表是一种非常高效的结构，分别建立两个数组，一个数组存放结点的值val，另一个数组存放结点的下一个结点的索引，这两个数组通过索引联系起来。对单链表常见的操作包括插入、删除、遍历（在头部插入一个元素、删除链表中的某个结点、遍历整个链表），现在对数组实现单链表过程进行解释

• 链表初始化
  这里为避免对链表中第一个结点的特判，使用带头节点的单链表，并规定头节点head索引是0，空指针的索引是-1
  初始化过程就是建立一个头节点，且头节点的next域指向空
  

void init(){
    idx =0 ;
    num[idx] = 0;
    ne[idx] = -1 ;  
}
1
2
3
4
5

• 在头部插入一个数据元素

假设在没有插入前，链表如下图所示。除了头节点外，链表中有一个节点。ne[0]为1表示头节点的下一个结点时索引为1的节点。ne[ne[0]]为-1，表示这个节点是链表中最后一个节点。

要实现插入一个元素就要新建立一个结点，这里通过索引来表示结点，将数据元素存入num数组中，再将元素插入链表的头部。插入过程本质是链的链接，这里就是ne[idx] = ne[0];ne[0] = idx;下图表示在头部插入完成后的结果，可以对比前一幅图找到两个数组的区别。

void insert_head(int x){
    idx++;
    num[idx] = x;
    ne[idx] = ne[0];
    ne[0] = idx;
}
1
2
3
4
5
6
7

• 在第k个插入元素之后插入一个元素
  这里与头插法相同，首先将结点元素存入num数组，在修改ne数组的值，将其链接到链表中即可。注意，因为链表建立过程中没增加一个结点。索引idx都会自增1，这里第k个插入的数对应索引就是k。num[k]就是第k个插入的元素的大小，ne[k]就是第k个插入的数的下一个结点。

//在第k个插入数后面插入一个数
void insert_k(int k, int x){
    idx++;
    num[idx] = x;
    ne[idx] = ne[k];
    ne[k] = idx ;
}
1
2
3
4
5
6
7

• 删除第k个插入的元素
  由于是数组存储链表的结点，数组是开辟的一块连续的空间，这里的删除不是释放内存，只要遍历链表找不到这个结点就可以认为是成功删除，所以只需修改当前结点ne数组中的值，让其变为下个节点的下一个结点的索引。

void del(int k){
    ne[k] = ne[ne[k]];
}
1
2
3

• 测试程序

#include<iostream>
using namespace std;
const int N = 100010;
int num[N],ne[N],idx ;
//规定-1表示空指针 头节点的索引为0
void init(){
    idx =0 ;
    num[idx] = 0;
    ne[idx] = -1 ;  
}

void insert_head(int x){
    idx++;
    num[idx] = x;
    ne[idx] = ne[0];
    ne[0] = idx;
}

//删除第k个插入的数后面的数，第k个插入的数索引是k
void del(int k){
    ne[k] = ne[ne[k]];
}

//在第k个插入数后面插入一个数
void insert_k(int k, int x){
    idx++;
    num[idx] = x;
    ne[idx] = ne[k];
    ne[k] = idx ;
}

void printList(){
    //通过ne数组找到下一个结点
    for(int i = ne[0] ; i != -1 ; i = ne[i]){
        cout<<num[i]<<" ";
    }
}

int main(){
    int m;
    cin>>m;
    init();
    while(m--){
        char op;
        cin>>op;
        if(op == 'H'){
            int x;
            cin>>x;
            insert_head(x);
        }
        else if(op == 'D'){
            int k;
            cin>>k;
            del(k);
        }
        else{
            int k,x;
            cin>>k>>x;
            insert_k(k,x);
        }
    }
    printList();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

结构体实现单链表

当学会了数组实现单链表，打开leetcode中链表的题目，发现有这样一段注释，这就要求我们会用结构里的形式实现链表中的插入、删除、遍历等操作，要不然还是写不出来题。

• 在链表头部插入数据元素
  新建一个结点->连接到链表中

//建立一个哑结点，这样不用特判链表为空的情况
ListNode *dummy = new ListNode(0,head);
ListNode * p = new ListNode(x);
p->next = dummy->next;
dummy->next = p;
1
2
3
4
5

• 删除链表中的某一个结点
  为避免特殊处理头节点，添加哑结点，即创建一个新节点指向链表的头部，这样即使是删除头节点也不需要单独处理，最后返回哑节点的next域即可。

遍历找到待删除的结点的前一个结点pre，之后执行删除操作

//遍历找到前一个结点
ListNode *dummy = new ListNode(0,head);
ListNode * pre = dummy ;
ListNode * cur = head;
while(cur != NULL){
	//check()根据题目要求改变
	if(check(cur)){
		pre->next = cur->next;
	}
	else{
		pre = cur;
		cur = cur->next ;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

• 链表尾部插入一个元素
  遍历找到最后一个结点，用tail标识

ListNode * node = new ListNode(x);
node->next = nullptr;
tail->next = node;
1
2
3

Leetcode典型题目

206.反转链表

解题思路(头插法)

新建一个单链表，采用头插法的方式以此取出原链表的结点，插入到该链表中即可。

实现程序

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        //采用头插法实现，每次取出链表中的一个结点，插到链表的头部
        ListNode*dummy = new ListNode(0,head);
        dummy->next = nullptr;
        ListNode * p = head;
        while(p != nullptr){
            
            ListNode*cur = p;
            p = p->next ;
            cur->next = dummy->next;
            dummy->next = cur ;
        }
        return dummy->next;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

运行结果

160.相交链表

解题思路（双指针）

• 定义两个指针，分别从A B两个链表头部开始遍历。

• 一个指针先遍历A再遍历B 另一个指针先遍历B再遍历A 如果有公共结点，零个指针会同时指向同一个结点

实现程序

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {

        ListNode *p1 = headA;
        ListNode *p2 = headB;
        int flagA = 0;
        int flagB = 0;
        while(p1 != NULL && p2 != NULL){
            if(p1 == p2) return p1 ;
            else{
                if(p1->next == NULL && flagA == 0){
                    p1 = headB ;
                    flagA = 1;
                } 
                else p1 = p1->next ;
                if(p2->next == NULL && flagB == 0){
                    p2 = headA ;
                    flagB = 1;
                } 
                else p2 = p2->next ;
            }
        }
        return NULL;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

运行结果

237.删除链表中的结点

解题思路

• 这个题目不知道头节点，因此不同采用从头到尾遍历的方式找到待删除结点的前一个结点，并且题目中说明要删除结点的下一个结点一定不为空
• 我们将下一个结点内容复制过来，无需遍历，以O(1)时间复杂度就能实现。

实现程序

class Solution {
public:
    void deleteNode(ListNode* node) {
        //题目中提示了不是最后一个节点，因此node->next一定不为空
        ListNode*temp = node->next ;
        node->val = temp->val ;
        node->next = temp->next ;
        delete temp ;

    }
};
1
2
3
4
5
6
7
8
9
10
11

运行结果

21.合并两个有序链表

解题思路（尾插法）

• 非常典型的尾插法，每次取出两个链表中较小的元素，查到结果链表的尾部
• 注意判空，循环完后，如果还有链表不为空，应当拼接到结果链表后面

实现程序

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
        //建立一个新链表，每次都拿过来两个升序链表中的较小值插入到新链表尾部
        ListNode*dummy = new ListNode(0,nullptr);
        ListNode * p1 = list1;
        ListNode * p2 = list2;
        ListNode *p3 = dummy ;
        while(p1 != nullptr && p2 != nullptr){
            if(p1->val <= p2->val){
                ListNode *temp = p1 ;
                p1 = p1->next;
                p3->next = temp ;
                temp ->next = nullptr ;
                p3 = p3->next ;
               
            }
            else{
                ListNode *temp = p2 ;
                p2 = p2->next ;
                p3->next = temp ;
                temp ->next = nullptr ;
                p3 = p3->next ;
                
            }
        }
        if(p1 != nullptr) p3->next = p1;
        if(p2 != nullptr) p3->next = p2;
        return dummy->next;
        
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

运行结果