校招算法笔面试 | 华为机试-从单向链表中删除指定值的节点

题目

题目链接

解题思路

1. 首先需要构建一个单向链表，根据输入的数据进行节点插入
2. 链表的构建过程：
   • 第一个数表示节点总数 $n$
   • 第二个数表示头节点的值
   • 之后每两个数为一组，表示在值为 $a$ 的节点后插入值为 $b$ 的节点
3. 构建完链表后，删除指定值的节点
4. 最后按顺序输出链表中的所有节点值

---

代码

#include <iostream>
#include <map>
using namespace std;

struct ListNode {
    int val;
    ListNode* next;
    ListNode(int x) : val(x), next(nullptr) {}
};

int main() {
    int n, head_val, val;
    cin >> n >> head_val;
    
    // 创建头节点
    ListNode* head = new ListNode(head_val);
    map<int, ListNode*> nodeMap;  // 用map存储节点值到节点的映射
    nodeMap[head_val] = head;
    
    // 构建链表
    for (int i = 0; i < n - 1; i++) {
        int after_val, insert_val;
        cin >> insert_val >> after_val;
        
        ListNode* newNode = new ListNode(insert_val);
        nodeMap[insert_val] = newNode;
        
        // 在after_val后插入新节点
        ListNode* afterNode = nodeMap[after_val];
        newNode->next = afterNode->next;
        afterNode->next = newNode;
    }
    
    // 读取要删除的节点值
    cin >> val;
    
    // 如果要删除的是头节点
    if (head->val == val) {
        head = head->next;
    } else {
        // 删除其他节点
        ListNode* curr = head;
        while (curr->next != nullptr) {
            if (curr->next->val == val) {
                curr->next = curr->next->next;
                break;
            }
            curr = curr->next;
        }
    }
    
    // 输出结果
    ListNode* curr = head;
    while (curr != nullptr) {
        cout << curr->val << " ";
        curr = curr->next;
    }
    
    return 0;
}

import java.util.*;

public class Main {
    static class ListNode {
        int val;
        ListNode next;
        ListNode(int val) {
            this.val = val;
        }
    }
    
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int headVal = sc.nextInt();
        
        // 创建头节点
        ListNode head = new ListNode(headVal);
        Map<Integer, ListNode> nodeMap = new HashMap<>();
        nodeMap.put(headVal, head);
        
        // 构建链表
        for (int i = 0; i < n - 1; i++) {
            int insertVal = sc.nextInt();
            int afterVal = sc.nextInt();
            
            ListNode newNode = new ListNode(insertVal);
            nodeMap.put(insertVal, newNode);
            
            ListNode afterNode = nodeMap.get(afterVal);
            newNode.next = afterNode.next;
            afterNode.next = newNode;
        }
        
        // 读取要删除的节点值
        int deleteVal = sc.nextInt();
        
        // 如果要删除的是头节点
        if (head.val == deleteVal) {
            head = head.next;
        } else {
            // 删除其他节点
            ListNode curr = head;
            while (curr.next != null) {
                if (curr.next.val == deleteVal) {
                    curr.next = curr.next.next;
                    break;
                }
                curr = curr.next;
            }
        }
        
        // 输出结果
        ListNode curr = head;
        while (curr != null) {
            System.out.print(curr.val + " ");
            curr = curr.next;
        }
    }
}

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

# 读取输入
inp = list(map(int, input().split()))
n, head_val = inp[0], inp[1]

# 创建头节点
head = ListNode(head_val)
node_map = {head_val: head}  # 用字典存储节点值到节点的映射

# 构建链表
idx = 2
for _ in range(n - 1):
    insert_val, after_val = inp[idx], inp[idx + 1]
    idx += 2
    
    new_node = ListNode(insert_val)
    node_map[insert_val] = new_node
    
    after_node = node_map[after_val]
    new_node.next = after_node.next
    after_node.next = new_node

# 读取要删除的节点值
delete_val = inp[-1]

# 如果要删除的是头节点
if head.val == delete_val:
    head = head.next
else:
    # 删除其他节点
    curr = head
    while curr.next:
        if curr.next.val == delete_val:
            curr.next = curr.next.next
            break
        curr = curr.next

# 输出结果
curr = head
while curr:
    print(curr.val, end=' ')
    curr = curr.next

---

算法及复杂度

• 算法：链表的构建和删除操作
• 时间复杂度：$\mathcal{O}(n)$ - 需要遍历链表进行节点插入和删除操作
• 空间复杂度：$\mathcal{O}(n)$ - 需要使用哈希表存储节点映射关系