算法--合并两个有序链表

      有两种方法，迭代和递归。

      迭代：

//不带头结点
Node * Merge(Node *head1 , Node *head2){
	//判空
	if ( head1 == NULL)
		return head2 ;
	if ( head2 == NULL)
		return head1 ;

	//头结点
	Node *head = NULL ;

	//分别指向两个链表
	Node *p1 = NULL;
	Node *p2 = NULL;

	//head指向较小值的那个链表
	if ( head1->data < head2->data )
	{
		head = head1 ;
		p1 = head1->next;
		p2 = head2 ;
	}else{
		head = head2 ;
		p2 = head2->next ;
		p1 = head1 ;
	}

	//当前排序好的链表的末尾节点
	Node *pcurrent = head ;
	while ( p1 != NULL && p2 != NULL)
	{
		if ( p1->data <= p2->data )
		{
			pcurrent->next = p1 ;
			pcurrent = p1 ;
			p1 = p1->next ;
		}
		else
		{
			pcurrent->next = p2 ;
			pcurrent = p2 ;
			p2 = p2->next ;
		}
	}

	//还有一方没有遍历完的情况
	if ( p1 != NULL )
		pcurrent->next = p1 ;
	if ( p2 != NULL )
		pcurrent->next = p2 ;
	
	return head ;
}

时间复杂度：O(n+m)，m和n分别为两个链表的长度，因为两个链表都要遍历到

空间复杂度：O(1)

 

递归：

Node * MergeRecursive(Node *head1 , Node *head2){
	//判空
	if ( head1 == NULL )
		return head2 ;
	if ( head2 == NULL)
		return head1 ;
	
	Node *head = NULL ;
	if ( head1->data < head2->data ){
		head = head1 ;
		//每次递归都返回head->next,head表示当前节点,一个局部变量
		head->next = MergeRecursive(head1->next,head2);
	}else{
		head = head2 ;
		head->next = MergeRecursive(head1,head2->next);
	}
	return head ;
}

时间复杂度：O(n+m)，每个节点都要遍历到

空间复杂度：O(n+m)，递归需要消耗栈空间，大小就是m+n

 

力扣的迭代代码更为简洁

ListNode* mergeTwoLists(ListNode *a, ListNode *b) {
    if ((!a) || (!b)) return a ? a : b;
    ListNode head, *tail = &head, *aPtr = a, *bPtr = b;
    while (aPtr && bPtr) {
        if (aPtr->val < bPtr->val) {
            tail->next = aPtr; aPtr = aPtr->next;
        } else {
            tail->next = bPtr; bPtr = bPtr->next;
        }
        tail = tail->next;
    }
    tail->next = (aPtr ? aPtr : bPtr);
    return head.next;
}

 

代码地址：https://www.cnblogs.com/fangyukuan/archive/2010/09/18/1829871.html