用c语言编写程序：输入若干正整数，按从小到大次序建立1个带头结点单链表，设计一个实现单链表分离算法的Split函数，将原单链表中值为偶数的结点分离出来形成一个新单链表，新单链表中头结点重新申请，其余结点来自原链表，分离后，原链表中只剩非偶数值所在结点，最后显示2个单链表，在程序退出前销毁单链表。要求Split算法时间复杂性达到O（n）,程序不可存在内存泄漏。

以下是用 C 语言编写的程序，实现了上述要求：

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

// 定义链表节点结构体
typedef struct ListNode {
    int val; // 节点值
    struct ListNode *next; // 指向下一个节点的指针
} ListNode;

// 创建一个带头结点的空链表
ListNode *createList() {
    ListNode *head = (ListNode *) malloc(sizeof(ListNode));
    head->next = NULL;
    return head;
}

// 在链表末尾插入一个节点
void insertNode(ListNode *head, int val) {
    ListNode *newNode = (ListNode *) malloc(sizeof(ListNode));
    newNode->val = val;
    newNode->next = NULL;
    
    ListNode *p = head;
    while (p->next != NULL) {
        p = p->next;
    }
    p->next = newNode;
}

// 销毁链表
void destroyList(ListNode *head) {
    ListNode *p = head;
    while (p != NULL) {
        ListNode *q = p->next;
        free(p);
        p = q;
    }
}

// 分离偶数节点，返回新链表
ListNode *splitEvenNodes(ListNode *head) {
    ListNode *newHead = createList(); // 创建新链表的头结点
    ListNode *p = head->next; // p 指向第一个节点
    ListNode *q = newHead; // q 指向新链表的头结点
    
    while (p != NULL) {
        if (p->val % 2 == 0) { // 如果是偶数节点
            q->next = p; // 插入到新链表中
            q = p;
        } else {
            // 在原链表中删除该节点
            ListNode *tmp = p;
            p = p->next;
            free(tmp);
        }
    }
    q->next = NULL; // 新链表末尾置空
    
    return newHead;
}

int main() {
    ListNode *head = createList(); // 创建原链表
    int val;
    printf("请输入若干正整数：\n");
    while (scanf("%d", &val) != EOF) {
        insertNode(head, val); // 在链表末尾插入节点
    }
    
    ListNode *newHead = splitEvenNodes(head); // 分离偶数节点
    printf("原链表：\n");
    ListNode *p = head->next;
    while (p != NULL) {
        printf("%d ", p->val);
        p = p->next;
    }
    printf("\n");
    
    printf("新链表：\n");
    p = newHead->next;
    while (p != NULL) {
        printf("%d ", p->val);
        p = p->next;
    }
    printf("\n");
    
    destroyList(head); // 销毁原链表
    destroyList(newHead); // 销毁新链表
    
    return 0;
}

上述程序的时间复杂度达到了 O(n)，并且在程序退出前会销毁链表，不存在内存泄漏问题。