函数insertlist将tmp指向的一个node结点插入一个按成员num从小到大排序单向链表中，并返回新链表。完成该函数的编写。

### 回答1：
函数insertlist的作用是将一个指向node结点的指针tmp插入一个按照num成员从小到大排序的单向链表中，并返回新链表。

具体实现可以按照以下步骤：

1. 如果链表为空，直接将tmp作为新链表的头结点，并返回新链表。

2. 如果链表不为空，需要找到tmp应该插入的位置。可以从头结点开始遍历链表，找到第一个num大于等于tmp->num的结点，将tmp插入到该结点之前。

3. 如果遍历到链表末尾都没有找到合适的位置，说明tmp应该插入到链表末尾。

4. 插入完成后，返回新链表的头结点。

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

struct node* insertlist(struct node* head, struct node* tmp) {
    if (head == NULL) { // 链表为空，直接将tmp作为新链表的头结点
        head = tmp;
        tmp->next = NULL;
        return head;
    }
    if (tmp->num < head->num) { // tmp应该插入到链表头部
        tmp->next = head;
        head = tmp;
        return head;
    }
    struct node* p = head;
    while (p->next != NULL && p->next->num < tmp->num) { // 找到第一个num大于等于tmp->num的结点
        p = p->next;
    }
    tmp->next = p->next; // 将tmp插入到该结点之前
    p->next = tmp;
    return head;
}

### 回答2：
函数insertlist的作用是将一个按照成员num从小到大排序的单向链表中插入一个指针tmp指向的node结点，并返回新链表。为了完成这个函数的编写，我们需要考虑以下几个方面：

1.插入的node结点应该放在什么位置？

考虑到链表是按照num从小到大排序的，插入新结点的时候需要找到恰当的位置。可以从头结点开始遍历链表，直到找到一个大于等于插入结点num值的位置，将插入结点插入到该位置之前。

2.如何处理特殊情况（如链表为空，或插入的结点num值最小或最大）？

如果链表为空，则可以将新结点作为头结点。如果插入的结点num值比链表中所有结点的num值都小，则可以将新结点作为头结点，并让原来的头结点成为新结点的next指针。如果插入的结点num值比链表中所有结点的num值都大，则可以将新结点作为链表的尾结点。

3.如何更改链表的指针？

插入结点的过程包括三个步骤：找到待插入位置，更改插入结点next指针，更改插入位置前一个结点的next指针。具体过程可以写成如下代码：

Node *insertlist(Node *head, Node *tmp){
Node *p, *q;
p = head;
if(head == NULL){ //如果链表为空，则插入结点作为头结点
head = tmp;
tmp->next = NULL;
return head;
}
if(tmp->num < head->num){ //如果插入结点num值比所有结点的num值都小
tmp->next = head;
head = tmp;
return head;
}
while(p!=NULL && p->num<tmp->num){ //找到待插入位置
q = p;
p = p->next;
}
if(p == NULL){ //如果插入结点num值比所有结点的num值都大
q->next = tmp;
tmp->next = NULL;
}
else{
q->next = tmp;
tmp->next = p;
}
return head;
}

以上是关于函数insertlist的设计和编写过程，函数的完整代码需在包含node结构体和main函数的程序中实现。

### 回答3：
这道题要求我们完成一个函数insertlist的编写，该函数将一个按num从小到大排序的单向链表中插入一个node结点，并返回新链表。我们可以按照以下步骤来实现。

首先，我们要确定新链表的头结点。新插入的node结点可能会影响原有链表的头结点，所以我们需要进行判断。如果原链表为空或者插入的节点num比原链表头结点num小，则将node结点作为新的头结点，并返回新的头结点；否则，头结点不变。

接着，我们需要找到插入节点的位置。由于单向链表只能从头到尾遍历，我们需要从头开始遍历链表，直到找到第一个num大于插入节点num的结点。然后，将插入节点插入到该节点之前。

最后，我们需要注意代码的实现。插入节点之后，我们需要将插入节点的next指针指向下一个节点。而如果插入的节点是新的头结点，则需要将原头结点作为插入节点的next指针。

下面是代码实现的参考：

// 定义链表节点结构体
struct node {
    int num;
    node *next;
};

// 插入节点函数
node *insertlist(node *head, node *tmp) {
    // 如果链表为空或者插入节点num比头结点num小，则将插入节点作为新的头结点
    if (head == NULL || tmp->num < head->num) {
        tmp->next = head;
        return tmp;
    }
    
    // 找到插入节点的位置
    node *cur = head;
    while (cur->next != NULL && cur->next->num < tmp->num) {
        cur = cur->next;
    }
    
    // 在该位置插入节点
    tmp->next = cur->next;
    cur->next = tmp;
    
    return head;
}