17_7_13：合并两个有序链表。实现1+2+3+...+n,不使用常规方法

1.【基础题】–合并两个有序链表，合并以后的链表依旧有序。

2.【附加题】–实现1+2+3…+n，要求不能使用乘除法、循环、条件判断、选择相关的关键字。（这个题有多种解法，大家可以尽量去思考，这个题最优的解法时间复杂度是O(1），大家可以去尝试实现）

1，基础题：

#include <stdio.h>

typedef struct ListNode
{
int _val;
struct ListNode* _pNext;
}Node, *PNode;

//默认是从小到大排序
PNode MergeOrderList(PNode pNode_1, PNode pNode_2)
{
PNode pNew = NULL; //作为返回值
PNode pCur = NULL; //作为遍历中的指针

if (pNode_1 == NULL && pNode_2 == NULL) //两者都为空的情况
return NULL;
else if (pNode_1 == NULL)  //pNode_1为空，pNode_2不为空
return pNode_2;
else if (pNode_2 == NULL)  //pNode_2为空，pNode_1不为空
return pNode_1;

//给pCur赋初值，指向值最小的节点
//此时，pNode_1与pNode_2不为空
pCur = (Node* )malloc(sizeof(Node));
if (pNode_1->_val < pNode_2->_val)
{
pCur->_val = pNode_1->_val;
pNode_1 = pNode_1->_pNext;
}
else
{
pCur->_val = pNode_2->_val;
pNode_2 = pNode_2->_pNext;
}

pCur->_pNext = NULL;
pNew = pCur;

//通过两个指针一直循环比较
while (pNode_1 && pNode_2)
{
PNode pTemp = (PNode *)malloc(sizeof(PNode));

if (pNode_1->_val < pNode_2->_val)
{
pTemp->_val = pNode_1->_val;
pCur->_pNext = pTemp;
pNode_1 = pNode_1->_pNext;
}
else
{
pTemp->_val = pNode_2->_val;
pCur->_pNext = pTemp;
pNode_2 = pNode_2->_pNext;
}

pTemp->_pNext = NULL;
pCur = pCur->_pNext;
}

//比较还有链表有剩余元素没有比较的情况
if (pNode_1)
pCur->_pNext = pNode_1;
else
pCur->_pNext = pNode_2;

return pNew;
}

//打印链表函数
void PrintList(PNode pHead)
{
while (pHead)
{
printf("%d->", pHead->_val);
pHead = pHead->_pNext;
}
printf("NULL\n");
}

//销毁链表
void Destroy(PNode pHead)
{
PNode pTemp = pHead;
while (pHead)
{
pTemp = pHead;
pHead = pHead->_pNext;
free(pTemp);
pTemp = NULL:
}
}

2，附加题

既然不能使用常规手段，那么就需要利用一些语法特性了。

思前想后，本人，只想出来了两种方法。

a,

本来我是使用递归实现的

size_t Add1ToN(size_t n)
{
if (0 == n)
return 0;

return n+Add1ToN(n-1);
}

但是后来发现，有一个if判断，如何去掉这个判断n为0的特殊if语句呢。突然想到利用逻辑与&&的短路性质，第一个条件为假时，不再判断第二个条件。可以修改如下：

size_t Add1ToN(size_t n, size_t* sum)
{
n && Add1ToN(n-1, &sum);
*sum += n;

return sum;
}

b，第二种方法，我想既然是O(1)的时间复杂度。那么恐怕没有只有查表法了（下面当n从0到19时，表内事先存储的值）

size_t tables[20] = {0,1,3,6,10,15,21,28,36,45,
55,66,78,91,105,120,136,163,171,190};

虽然查表法的时间复杂度是O（1），但是使用空间换时间的做法。

当然，还有许多中方法去实现累计结果，推荐博
4000
文：http://blog.csdn.net/cxllyg/article/details/7583646