编写函数，实现输入一组元素，建立一个带头结点的单链表；对该链表进行非递减排序；实现在非递减有序链表中删除值为x的结点；

可以按照以下步骤编写函数：

1. 定义一个结构体表示链表的节点，包含一个数据域和一个指向下一个节点的指针。
2. 定义一个函数用于创建带头结点的单链表，该函数接受一个数组作为参数，返回一个指向头结点的指针。
3. 定义一个函数用于对链表进行非递减排序，该函数接受一个指向头结点的指针作为参数，返回排序后的链表。
4. 定义一个函数用于在非递减有序链表中删除值为x的结点，该函数接受一个指向头结点的指针和要删除的值x作为参数，返回删除后的链表。

具体实现可以参考以下代码：

#include <stdio.h>
#include <stdlib.h>

// 定义链表节点结构体
typedef struct Node {
    int data;           // 数据域
    struct Node *next;  // 指向下一个节点的指针
} Node;

// 创建带头结点的单链表
Node *createList(int arr[], int n) {
    Node *head = (Node *)malloc(sizeof(Node));  // 创建头结点
    head->next = NULL;  // 头结点的next指针初始化为NULL
    Node *tail = head;  // 定义尾指针，初始指向头结点

    // 循环创建节点并插入链表尾部
    for (int i = ; i < n; i++) {
        Node *node = (Node *)malloc(sizeof(Node));  // 创建新节点
        node->data = arr[i];  // 节点数据域赋值
        node->next = NULL;    // 新节点的next指针初始化为NULL
        tail->next = node;    // 将新节点插入链表尾部
        tail = node;          // 尾指针指向新节点
    }

    return head;  // 返回头结点指针
}

// 对链表进行非递减排序
Node *sortList(Node *head) {
    if (head == NULL || head->next == NULL) {
        return head;  // 链表为空或只有一个节点，直接返回
    }

    Node *p = head->next;  // 定义指针p指向第一个节点
    Node *q = p->next;     // 定义指针q指向第二个节点
    p->next = NULL;        // 将第一个节点作为新链表的头结点

    while (q != NULL) {
        Node *r = q->next;  // 定义指针r指向下一个节点
        if (q->data < p->data) {
            q->next = p;  // 将q插入新链表头部
            p = q;
        } else {
            Node *s = p;  // 定义指针s指向新链表中第一个大于q的节点
            while (s->next != NULL && s->next->data < q->data) {
                s = s->next;
            }
            q->next = s->next;  // 将q插入s之后
            s->next = q;
        }
        q = r;  // q指向下一个节点
    }

    head->next = p;  // 头结点指向新链表的第一个节点
    return head;
}

// 在非递减有序链表中删除值为x的结点
Node *deleteNode(Node *head, int x) {
    Node *p = head->next;  // 定义指针p指向第一个节点
    Node *pre = head;      // 定义指针pre指向p的前一个节点

    while (p != NULL && p->data <= x) {
        if (p->data == x) {
            pre->next = p->next;  // 删除节点p
            free(p);
            p = pre->next;  // p指向下一个节点
        } else {
            pre = p;
            p = p->next;
        }
    }

    return head;
}

int main() {
    int arr[] = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5};
    int n = sizeof(arr) / sizeof(int);

    Node *head = createList(arr, n);
    printf("原始链表：");
    Node *p = head->next;
    while (p != NULL) {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");

    head = sortList(head);
    printf("排序后的链表：");
    p = head->next;
    while (p != NULL) {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");

    head = deleteNode(head, 5);
    printf("删除5后的链表：");
    p = head->next;
    while (p != NULL) {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");

    return ;
}