已知带头结点单链表L中存储一组整数，编写算法删除表中所有值大于x的结点。

以下是删除表中所有值大于x的结点的算法：

void deleteNodesGreaterThanX(ListNode* head, int x) {
    ListNode* current = head->next;
    ListNode* previous = head;
    while (current != nullptr) {
        if (current->val > x) {
            previous->next = current->next;
            delete current;
            current = previous->next;
        } else {
            previous = current;
            current = current->next;
        }
    }
}

其中，ListNode 是单链表的结点类型，head 是头结点，val 是结点存储的整数值。

相关问题

已知带头结点的动态单链表L中的结点是按整数值递增排列的，试写一算法将值为X的结点插入表L中，使L任然有序

为了将值为 X 的新节点插入已排序的动态单链表 L 中，保持其有序性，我们可以遵循以下步骤：

1. **初始化**：
- 创建一个新的节点 Node，设其值为 X。
- 初始化 Node 的 next 指针为 NULL。

2. **遍历链表**：
- 设置两个指针，p 和 q，分别指向链表的头结点和当前查找位置。
- 如果链表为空或者 p 的值小于 X，说明应该将新节点放在首位，直接将 p 指向的新 Node 设置为链表头结点。

3. **查找插入位置**：
- 遍历链表，如果找到一个节点 p 其值大于等于 X，则 p 就是插入位置。
- 当 q 指针到达链表尾部时，表示找不到更大的节点，此时也将新节点添加到尾部。

4. **插入操作**：
- 更新新节点的 next 指针，使其指向 q 的下一个节点。
- 调整 q 的 next 指针，使之指向新插入的节点。

5. **结束循环**：
- 返回链表的头结点，表示插入完成。

以下是该算法的伪代码描述：

function insertSortedList(L, X):
    newNode = createNode(X)  // 新节点
    if L is empty or L.head.value < X:
        newNode.next = L.head
        L.head = newNode
    else:
        current = L.head
        while current.next and current.next.value >= X:
            current = current.next
        newNode.next = current.next
        if current.next:
            current.next = newNode
        else:
            current.next = newNode

function createNode(value):
    node = {}
    node.value = value
    node.next = None
    return node

已知带头结点的动态单链表L中的结点是按整数值递增排列的，试写一算法将值为X的结点插入表L中，使L任然有序C语言编程

为了在已排序的动态单链表L中按整数值递增插入一个值为X的新节点，你可以采用以下步骤：

1. 创建新节点：首先，创建一个新的链表节点，将其数据域设为X，并设置其指针prev为NULL，因为这是第一个需要插入的位置。

typedef struct Node {
    int data;
    struct Node* next;
} Node;

2. 遍历链表：从头节点开始遍历链表，找到合适的位置插入新节点。如果当前节点的数据小于X，则新节点应该插入当前节点之后。

Node* insert(Node* head, int x) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = x;

    // 新节点作为头节点
    if (!head || head->data >= x) {
        newNode->next = head;
        head = newNode;
        return head;
    }

    // 找到插入位置
    Node* prev = head;
    Node* curr = head->next;
    while (curr && curr->data < x) {
        prev = curr;
        curr = curr->next;
    }

    // 插入新节点
    newNode->next = curr;
    prev->next = newNode;
    return head;
}

3. 插入完成：最后返回头节点，这样就保证了链表在插入新元素后仍然保持有序。

**相关问题--:**
1. 如果链表为空，这个函数会怎么处理？
2. 插入过程是如何判断是否找到合适位置的？
3. 如果X已经存在于链表中，这个函数会怎样处理？