已知两个非降序链表序列s1与s2，设计函数构造出s1与s2合并后的新的非降序链表s3。 要求s3中没有重复元素。

### 回答1：
可以使用双指针法，分别遍历s1和s2，将较小的元素加入到s3中，直到其中一个链表遍历完毕。然后将另一个链表中剩余的元素加入到s3中。最后再去重即可得到s3。

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

class ListNode:
    def __init__(self, val=, next=None):
        self.val = val
        self.next = next

def merge(s1: ListNode, s2: ListNode) -> ListNode:
    dummy = ListNode()
    cur = dummy
    while s1 and s2:
        if s1.val < s2.val:
            cur.next = s1
            s1 = s1.next
        elif s1.val > s2.val:
            cur.next = s2
            s2 = s2.next
        else:
            cur.next = s1
            s1 = s1.next
            s2 = s2.next
        cur = cur.next
    cur.next = s1 if s1 else s2
    return dummy.next

def remove_duplicates(s: ListNode) -> ListNode:
    cur = s
    while cur and cur.next:
        if cur.val == cur.next.val:
            cur.next = cur.next.next
        else:
            cur = cur.next
    return s

def merge_and_remove_duplicates(s1: ListNode, s2: ListNode) -> ListNode:
    s3 = merge(s1, s2)
    s3 = remove_duplicates(s3)
    return s3

其中，merge函数用于将s1和s2合并成s3；remove_duplicates函数用于去除s3中的重复元素；merge_and_remove_duplicates函数用于将两个链表合并并去重。

### 回答2：
首先，我们可以先初始化一个新的链表s3，然后同时遍历s1和s2，比较两个链表当前节点的大小，将较小的节点加入s3中，并且移动指针到下一个节点。在遍历的过程中，如果发现有相同元素，则只将一个节点加入s3中，跳过另一个节点。最后，返回s3即为合并后的非降序链表，其中没有重复元素。

具体实现细节如下：

1. 定义三个指针p1、p2和p3，分别指向s1、s2和s3的头节点。
2. 比较p1和p2节点的大小，将较小的节点加入s3中，如果节点相同，则只将一个节点加入s3中。
3. 如果p1或p2已经到达链表末尾，则将另一个链表剩余节点依次加入s3中。
4. 移动相应的指针到下一个节点，重复2和3步，直到两个链表全部遍历结束。
5. 返回s3即为合并后的非降序链表，其中没有重复元素。

代码实现如下：

struct ListNode* merge(struct ListNode* s1, struct ListNode* s2) {
    struct ListNode *s3 = NULL;
    struct ListNode **pp = &s3;
    while (s1 && s2) {
        if (s1->val < s2->val) {
            *pp = s1;
            s1 = s1->next;
        } else if (s1->val > s2->val) {
            *pp = s2;
            s2 = s2->next;
        } else {
            *pp = s1;
            s1 = s1->next;
            s2 = s2->next;
        }
        pp = &((*pp)->next);
    }
    *pp = s1 ? s1 : s2;
    return s3;
}

细节说明：

1. s3需要初始化为空，同时需要使用双重指针pp，以便能够改变s3头节点的指针值。
2. 在比较s1和s2节点时，如果节点相等需要同时移动p1和p2指针，跳过重复节点。
3. 最后需要检查哪个链表还有剩余节点，将剩余节点加入s3中即可。

时间复杂度为O(m+n)，其中m和n分别为两个链表的长度。

### 回答3：
首先，在理解题目要求之前，需要明确什么是非降序链表。非降序链表指的是链表中节点的值是按照非降序排列的，即前一个节点的值不大于后一个节点的值。例如，一个非降序链表可以是：1→2→3→3→4→5→5→6→6。

接下来，我们来看如何将两个非降序链表合并成一个新的非降序链表，并且保证新的链表中没有重复元素。这个可以用指针的方式来实现。

具体来说，可以先定义一个头节点，然后用指针遍历两个非降序链表。当遇到两个链表中有相同的节点时，只需要添加一个节点到新的非降序链表中去即可。在遍历的过程中，用一个指针指向新的非降序链表的最后一个节点，保证每次都加在最后一个节点的后面。最后返回头节点即可。

代码如下：

struct ListNode* merge(struct ListNode* s1, struct ListNode* s2) {
struct ListNode *dummy = (struct ListNode *)malloc(sizeof(struct ListNode));
dummy->next = NULL;
struct ListNode *cur = dummy;
while (s1 != NULL && s2 != NULL) {
if (s1->val < s2->val) {
cur->next = s1;
s1 = s1->next;
} else if (s1->val > s2->val) {
cur->next = s2;
s2 = s2->next;
} else {
cur->next = s1;
s1 = s1->next;
s2 = s2->next;
}
cur = cur->next;
cur->next = NULL;
}
if (s1 != NULL) {
cur->next = s1;
} else {
cur->next = s2;
}
struct ListNode *res = dummy->next;
free(dummy);
return res;
}

以上就是将两个非降序链表合并成一个新的非降序链表的全部过程和代码了。