c语言实现线性表的应用算法：构造一个递增有序的正整数链表，实现链表分解为一个奇数表和一个偶数表，之后再将两个链表合并一个递减链表。

在C语言中，我们可以利用链表的数据结构来实现这个功能。首先，我们需要定义一个节点结构体，包含一个整数值和指向下一个节点的指针。以下是步骤：

1. **构造递增有序的正整数链表**：
- 创建一个`Node`结构体：`typedef struct Node {int value; struct Node* next;} Node;`
- 使用循环或递归的方式添加数字到链表，保证每次插入都比前一个大。

void insert_sorted(Node** head, int num) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->value = num;
    newNode->next = NULL;

    if (*head == NULL || (*head)->value > num) {
        *head = newNode;
    } else {
        Node* current = *head;
        while (current->next != NULL && current->next->value < num) {
            current = current->next;
        }
        newNode->next = current->next;
        current->next = newNode;
    }
}

2. **链表分解为奇数表和偶数表**：
- 分别创建两个新的头节点，并遍历原链表。

void split_list(Node* head, Node** oddHead, Node** evenHead) {
    Node* oddCurr = *oddHead = NULL;
    Node* evenCurr = *evenHead = NULL;
    
    while (head != NULL) {
        if (head->value % 2 == 0) {
            evenCurr->next = head;
            evenCurr = evenCurr->next;
        } else {
            oddCurr->next = head;
            oddCurr = oddCurr->next;
        }
        head = head->next;
    }
    oddCurr->next = NULL;
    evenCurr->next = NULL;
}

3. **合并两个链表为递减链表**：
- 将两个链表按奇偶顺序依次连接起来，然后逆序整个链表。

void merge_and_sort(Node** resultHead, Node* oddHead, Node* evenHead) {
    Node* temp = *resultHead = NULL;
    Node* oddTail = oddHead;
    Node* evenTail = evenHead;

    while (oddTail != NULL && evenTail != NULL) {
        if (oddTail->value >= evenTail->value) {
            temp->next = oddTail;
            temp = temp->next;
            oddTail = oddTail->next;
        } else {
            temp->next = evenTail;
            temp = temp->next;
            evenTail = evenTail->next;
        }
    }

    // 如果其中一个链表还有剩余元素，则直接追加
    if (oddTail != NULL) {
        temp->next = oddTail;
    } else {
        temp->next = evenTail;
    }

    reverse_list(*resultHead);
}

// 反转链表函数
void reverse_list(Node** head) {
    Node* prev = NULL;
    Node* curr = *head;
    Node* next = NULL;

    while (curr != NULL) {
        next = curr->next;
        curr->next = prev;
        prev = curr;
        curr = next;
    }
    *head = prev;
}

现在，你应该有了完整的算法来构建、分割并合并链表。注意处理内存分配和释放。在实际应用中，记得为链表的结束设置一个特殊的值或NULL指针。