合并两个有序链表--实现1+2+3+....+n,时间复杂度为O（1）

1、合并两个有序链表，合并以后的链表依旧有效
C语言实现
链表结点定义如下：

typedef int DataType;
typedef struct Node
{
    DataType _data;
    struct Node* _pNext;
}Node,*PNode;

实现代码:

void InitList(PNode* pHead) //初始化单链表
{
    assert(pHead);
    //printf("%x\n",&pHead);
    *pHead=NULL;
}
Node* BuyNode(DataType data)  //创建新结点
{
    Node *pNewNode=(Node*)malloc(sizeof(Node));
    if(NULL!=pNewNode)
    {
        pNewNode->_data=data; 
        pNewNode->_pNext=NULL;
    }
    return pNewNode;
}
void PushBack(PNode* pHead,DataType data)  //插入新结点
{
    assert(pHead);
    if(NULL==*pHead)
    {
        *pHead=BuyNode(data);
    }
    else
    {
        Node* pTailNode=*pHead;
        while(pTailNode->_pNext)
        {
            pTailNode=pTailNode->_pNext ;
        }
        pTailNode->_pNext=BuyNode(data);
    }
}
void PrintList(PNode pHead)  //打印单链表
{
    Node* pCurNode=pHead;
    while(pCurNode)
    {
        printf("%d->",pCurNode->_data); 
        pCurNode=pCurNode->_pNext;
    }
    printf("NULL\n");
}
PNode MergeList(PNode pHead1, PNode pHead2)  //合并两个单链表
{
    PNode pL1=pHead1;
    PNode pL2=pHead2;
    PNode pNewHead=NULL;
    PNode pTailNode=NULL;
    if(pHead1==NULL)
        return pHead2;
    if(pHead2==NULL)
        return pHead1;
    pL1=pHead1;
    pL2=pHead2;
    if(pL1->_data <=pL2->_data)
    {
        pNewHead=pL1;
        pTailNode=pL1;
        pL1=pL1->_pNext;
    }
    else
    {
        pNewHead=pL2;
        pTailNode=pL2;
        pL2=pL2->_pNext;


    }
    while(pL1&&pL2)
    {
        if(pL1->_data<=pL2->_data)
        {
            pTailNode->_pNext=pL1;
            pL1=pL1->_pNext;
        }
        else
        {
            pTailNode->_pNext=pL2;
            pL2=pL2->_pNext;
        }
        pTailNode=pTailNode->_pNext;
    }
    if(NULL!=pL1)
    {
        pTailNode->_pNext =pL1;
    }
    if(NULL!=pL2)
    {
        pTailNode->_pNext=pL2;
    }
    return pNewHead;
}
void FunTest()
{
    Node *pHead1,*pHead2;
    InitList(&pHead1);
    PushBack(&pHead1,1);
    PushBack(&pHead1,3);
    PushBack(&pHead1,4);
    PushBack(&pHead1,5);
    PushBack(&pHead1,6);
    PrintList(pHead1);
    InitList(&pHead2);
    PushBack(&pHead2,2);
    PushBack(&pHead2,4);
    PushBack(&pHead2,6);
    PushBack(&pHead2,7);
    PushBack(&pHead2,8);
    PrintList(pHead2);
    pHead1=MergeList(pHead1,pHead2);
    PrintList(pHead1);
}

链表合并以后的结果：

2、实现1+2+3+….+n,时间复杂度为O（1），要求不能使用乘除法，循环，条件判断，选择相关的关键字

 //1.利用构造函数求解--一次创建N个对象，将累加的算法放到构造函数中
class Sort
{
public:
     Sort()
    {
        N++;
        Sum += N;
    }
     static void Reset()
     {
         N = 0;
         Sum = 0;
     }
     static  int Get()
     {
         return Sum;
     }
private:
    static  int N;
    static  int Sum;
};

  int Sort::N = 0;
  int Sort::Sum = 0;

 int Sum_Solution1(int n)
{
    Sort::Reset();
    Sort* a = new Sort[n];
    delete a;
    a = NULL;
    return Sort::Get();
}