这是微软书面测试期间提出的编程问题之一。我提出了我想出的问题和答案。事情虽然看起来很全面（至少对我来说），但我觉得可以减少行数。它在C中被问到我是一个Java人，但我设法编写它（我的答案可能包含太多类似Java的语法）
好的，这是问题。
您已经有两个列表 排序后，你必须合并它们 返回一个没有任何新额外的新列表 节点。返回的列表应该是 也排序。
方法签名是，
Node* MergeLists(Node* list1, Node* list2);
struct Node{
int data;
Node *next;
}
以下是我提出的解决方案，
Node* MergeLists(Node* list1, Node* list2){
Node* mergedList;
if(list1 == null && list2 ==null){//if both are null, return null
return null;
}
if(list1 == null){//if list1 is null, simply return list2
return list2;
}
if(list2 == null){//if list2 is null, simply return list1
return list1;
}
if(list1.data < list2.data){//initialize mergedList pointer to list1 if list1's data is lesser
mergedList = list1;
}else{//initialize mergedList pointer to list2 if list2's data is lesser or equal
mergedList = list2;
}
while(list1!=null && list2!=null){
if(list1.data < list2.data){
mergedList->next = list1;
list1 = list1->next;
}else{
mergedList->next = list2;
list2 = list2->next;
}
}
if(list1 == null){//remaining nodes of list2 appended to mergedList when list1 has reached its end.
mergedList->next = list2;
}else{//remaining nodes of list1 appended to mergedList when list2 has reached its end
mergedList->next = list1;
}
return mergedList;
}
我非常有信心可以加强这一点。请帮我查一下我添加的冗余行。请随意批评我的语法错误和逻辑。
谢谢！
答案 0 :(得分：19)
最明显的错误是在你的循环中，你继续覆盖mergedList-＆gt;接下来，丢失之前添加的节点。也就是说，无论输入是什么，您返回的列表将永远不会包含两个以上的节点...
我做了C已经有一段时间了，但我会这样做：
Node* merge(Node* list1, Node* list2) {
Node* merged = null;
Node** tail = &merged;
while (list1 && list2) {
if (list1->data < list2->data) {
*tail = list1;
list1 = list1->next;
} else {
*tail = list2;
list2 = list2->next;
}
tail = &((*tail)->next);
}
*tail = list1 ? list1 : list2;
return merged;
}
答案 1 :(得分：13)
您的代码超载了if - 为了处理“特殊”案例而插入，这会使它大量膨胀并使其难以阅读。当您决定“通过代码”处理特殊情况而不是找到“按数据”处理它们的方法时，通常会发生这种情况。 David Wheeler的一份声明说：“计算机科学中的所有问题都可以通过另一层次的间接解决”。 “额外的间接级别”通常可以很好地与列表一起使用，有助于显着减少if创建的混乱。
为了说明上述内容，这是我的代码的样子
#define SWAP_PTRS(a, b) do { void *t = (a); (a) = (b); (b) = t; } while (0)
Node* MergeLists(Node* list1, Node* list2)
{
Node *list = NULL, **pnext = &list;
if (list2 == NULL)
return list1;
while (list1 != NULL)
{
if (list1->data > list2->data)
SWAP_PTRS(list1, list2);
*pnext = list1;
pnext = &list1->next;
list1 = *pnext;
}
*pnext = list2;
return list;
}
有些人可能认为在pnext指针中使用额外的间接级别实际上会使代码更难以阅读。我同意，对于一个新手来说，这种方法可能会带来一些困难，但对于一个有经验的程序员来说，这应该很容易理解为成语。
答案 2 :(得分：9)
到目前为止，所有答案都很有趣并且做得很好。这个可能更像是一个采访者希望看到的，包括DRY / DIE和TDD。 ： - ）
#include <stdio.h>
typedef struct ns {
int data;
struct ns *next;
} Node;
Node l1[] = {
{ 1, &l1[1] },
{ 3, &l1[2] },
{ 5, &l1[3] },
{ 7, &l1[4] },
{ 9, &l1[5] },
{11, 0 },
};
Node l2[] = {
{ 2, &l2[1] },
{ 4, &l2[2] },
{ 6, 0 },
};
Node* MergeLists(Node* list1, Node* list2) {
Node *t, **xt;
for(xt = &t; list1 || list2;) {
Node **z = list1 == NULL ? &list2 :
list2 == NULL ? &list1 :
list1->data < list2->data ? &list1 : &list2;
*xt = *z;
xt = &(*z)->next;
*z = *xt;
}
*xt = NULL;
return t;
}
int main(void) {
for(Node *t = MergeLists(l1, l2); t; t = t->next)
printf("%d\n", t->data);
return 0;
}
答案 3 :(得分：5)
它没有比这更优雅了：
Node* merge2(Node* n1, Node* n2) {
n1->next = merge(n1->next, n2);
return n1;
}
Node* merge(Node* n1, Node* n2) {
return (n1 == null) ? n2 :
(n2 == null) ? n1 :
(n1->data < n2->data) ?
merge2(n1, n2) :
merge2(n2, n1);
}
假设你理解递归，那就很明显了。
我应该指出，这只适用于面试答案（可能表明思想的清晰度比简单地表明你知道如何编写程序更有影响力）。实际上，您不希望以这种方式合并，因为它使用O(n)堆栈深度，这可能会导致堆栈溢出。此外，它不是尾递归，因此它不是编译器可优化的。
答案 4 :(得分：4)
Divide et Impera
（即MergeSort）
答案 5 :(得分：2)
因此，我们得到了以下材料来合并polygen：
Node* merge(Node* n1, Node* n2) {
return (n1 == null) ? n2 :
(n2 == null) ? n1 :
(n1->data < n2->data) ?
(n1->next = merge(n1->next, n2), n1) :
(n2->next = merge(n2->next, n1), n2)}
我不能声称这个，但它是最简洁的，并显示两个参数之间的对称性，不会引入任何晦涩的帮助函数。我不确定优化编译器会在这里看到尾递归，但我确实如此。缩进是最后一步。
答案 6 :(得分：2)
使用递归。代码如下：
ListNode* mergeTwoSortedLists(ListNode* pHead1, ListNode* pHead2)
{
if(pHead1 == NULL)
return pHead2;
else if(pHead2 == NULL)
return pHead1;
ListNode* pMergedHead = NULL;
if(pHead1->m_nValue < pHead2->m_nValue)
{
pMergedHead = pHead1;
pMergedHead->m_pNext = mergeTwoSortedLists(pHead1->m_pNext, pHead2);
}
else
{
pMergedHead = pHead2;
pMergedHead->m_pNext = mergeTwoSortedLists(pHead1, pHead2->m_pNext);
}
return pMergedHead;
}
答案 7 :(得分：0)
public void Merge(LinkList list1, LinkList list2) {
if (list1.head == null && list2.head == null) {
System.out.println("Empty list"); //Check if lists are empty
}
if (list1.head == null) { //If list1 is empty print list2
list2.printList();
}
if (list2.head == null) { //If list2 is empty print list1
list1.printList();
}
LinkList list3 = new LinkList(); //create a new LinkList object for merging
Node a = list1.head; //Beginning of list1
Node b = list2.head; //Beginning of list2
while (a != null && b != null) { //Until list ends
if (a.value <= b.value) { //Compare values of list1 against list2
list3.insert(a.value); //Insert values to new list
a = a.next;
} else if (a.value >= b.value) {
list3.insert(b.value);
b = b.next;
} else if (a.value == b.value){ //Insert only unique values and discard repeated values
list3.insert(a.value);
a = a.next;
b = b.next;
}
}
if (a == null) {
while (b != null) {
list3.insert(b.value); //If list1 becomes empty, attach rest of the list2 to list3
b = b.next;
}
}
if (b == null) {
while (a != null) {
list3.insert(a.value);
a = a.next;
}
}
list3.printList(); //print merged list
}
}
PS：我无法为C中使用指针的上面列出的程序提供Java解决方案。
答案 8 :(得分：0)
这是我的看法。与其他解决方案不同，它识别并跳过一个列表上的连续节点，这些节点小于或等于另一个列表的头节点。另一个列表的头部附加在这样的序列的末尾，并且在切换角色之后重复该过程。 这种方法最大限度地减少了Node.next的赋值次数，同时将NULL测试限制为每次迭代中的单次检查。
Node * merge(Node *list1, Node *list2)
{
if (!list1) return list2;
if (!list2) return list1;
Node *tmp;
// compare head nodes and swap lists to guarantee list1 has the smallest node
if (list1->val > list2->val) {
tmp = list2;
list2 = list1;
list1 = tmp;
}
Node *tail = list1;
do {
// Advance the tail pointer skipping over all the elements in the result
// which have smaller or equal value than the first node on list2
while (tail->next && (tail->next->val <= list2->val)) {
tail = tail->next;
}
// concat list2 at tail of result and make the rest after tail list2
tmp = tail->next;
tail->next = list2;
tail = list2;
list2 = tmp;
} while (list2);
return list1;
}
答案 9 :(得分：0)
#include<stdio.h>
typedef struct NODE
{
int data;
struct NODE * next;
}NODE;
NODE * func(NODE*,NODE*);
int main()
{
int i;
int size;
int value;
NODE * head1,*head2,*newNode,*ptr,*final;
printf("\nPlease enter the number of elements\n");
scanf("%d",&size);
for(i=0;i<size;i++)
{
printf("List 1\n");
printf("Please enter the value number %d \n",i+1);
scanf("%d",&value);
newNode=(NODE*)malloc(sizeof(NODE));
newNode->data=value;
newNode->next=NULL;
if(i!=0)
{
ptr->next=newNode;
ptr=ptr->next;
}
if(i==0)
{
head1=newNode;
ptr=newNode;
}
}
for(i=0;i<size;i++)
{
printf("\n\nList 2\n");
printf("Please enter the value number %d \n",i+1);
scanf("%d",&value);
newNode=(NODE*)malloc(sizeof(NODE));
newNode->data=value;
newNode->next=NULL;
if(i!=0)
{
ptr->next=newNode;
ptr=ptr->next;
}
if(i==0)
{
head2=newNode;
ptr=newNode;
}
}
final=func(head1,head2);
printf("\n\n");
while (final!=NULL)
{
printf("%d -->",final->data);
final=final->next;
}
printf("NULL
");
return 0;
}
NODE* func(NODE* list1, NODE* list2)
{
NODE* mergedList,*mergeHead=NULL;
if(list1 == NULL && list2 ==NULL){//if both are NULL, return NULL
return NULL;
}
if(list1 == NULL){//if list1 is NULL, simply return list2
return list2;
}
if(list2 == NULL){//if list2 is NULL, simply return list1
return list1;
}
mergedList = (NODE*)malloc(sizeof(NODE));
if(list1->data < list2->data){//initialize mergedList pointer to list1 if list1's data is lesser
mergedList->data=list1->data;
mergedList->next=NULL;
list1 = list1->next;
}else{//initialize mergedList pointer to list2 if list2's data is lesser or equal
mergedList->data=list2->data;
mergedList->next=NULL;
list2 = list2->next;
}
mergeHead=mergedList;
while(list1!=NULL && list2!=NULL){
if(list1->data < list2->data){
mergedList->next = (NODE*)malloc(sizeof(NODE));
mergedList=mergedList->next;
mergedList->data=list1->data;
mergedList->next=NULL;
list1 = list1->next;
}else{
mergedList->next = (NODE*)malloc(sizeof(NODE));
mergedList=mergedList->next;
mergedList->data=list2->data;
mergedList->next=NULL;
list2 = list2->next;
}
}
if(list1 == NULL){//remaining nodes of list2 appended to mergedList when list1 has reached its end.
while(list2!=NULL)
{
mergedList->next = (NODE*)malloc(sizeof(NODE));
mergedList=mergedList->next;
mergedList->data=list2->data;
mergedList->next=NULL;
list2 = list2->next;
}
}else{//remaining nodes of list1 appended to mergedList when list2 has reached its end
mergedList->next = (NODE*)malloc(sizeof(NODE));
mergedList=mergedList->next;
mergedList->data=list1->data;
mergedList->next=NULL;
list1 = list1->next;
}
return mergeHead;
}
答案 10 :(得分：0)
我为它创建了递归函数。 这是我的解决方案：
Node* merge_recursion(Node* l1, Node* l2)
{
if (!l1)
return l2;
if (!l2)
return l1;
if (l1->data < l2->data) {
l1->next = merge_recursion(l1->next, l2);
return l1;
} else {
l2->next = merge_recursion(l1, l2->next);
return l2;
}
}
将返回指针存储到新的指针变量（在main（）/调用函数中）并遍历新指针上的链接列表以打印数据，它将导致已合并的链接列表。
答案 11 :(得分：0)
您可以使用递归：
Node* MergeLists(Node *headA, Node* headB)
{
if(headA==NULL){
return headB;
}else if(headB ==NULL){
return headA;
}
Node* head = NULL;
if(headA->data <= headB->data){
head= headA;
head->next = MergeLists(headA->next,headB);
}else{
head= headB;
head->next = MergeLists(headA,headB->next);
}
return head;
}
答案 12 :(得分：0)
您可以使用Java 8，Stream API进行合并，获得Distinct和排序。 下面是使用Integer元素排序和合并两个列表的示例代码
List<Integer> list1= Arrays.asList(2,3,5,8);
List<Integer> list2 = Arrays.asList(3,6,8);
List<Integer> finalList = new ArrayList<>();
finalList.addAll(list1);
finalList.addAll(list2);
List<Integer> mergeSortedList =
finalList.stream()
.distinct()
.sorted()
.collect(Collectors.toList());
System.out.println(mergeSortedList);
答案 13 :(得分：0)
合并两个排序链表的迭代解决方案：
class ListNode:
def __init__(self, val=0, next=None):
self.val = val
self.next = next
class Solution:
def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
head = ListNode(-200)
prev = head
while l1 and l2:
if l1.val <=l2.val:
prev.next = l1
l1 = l1.next
else:
prev.next = l2
l2 = l2.next
prev = prev.next
prev.next = l1 if l1 is not None else l2
return head.next
答案 14 :(得分：-1)
device_id S percentile_S
28 6 0.00
54 10 33.33
97 20 55.55
14 11 44.44
21 9 22.22
23 7 11.11