有序链表(或无序链表)的合并

最近博主离职找工作了，正好赶上最美离职信。呵呵，小伙伴纷纷借着这个东风给予鼓励。在此表示无限次的感谢ing。

其实离职，对于非计算机科班出身，过了30岁，有了家庭，还有了小孩，还要还房货。压力是可想而知的。不管压力多大，是不是能坚持到黎明，看见曙光；还是要走出去试一试。看一看。现在有一部分公司，对技术过于不认可。老板和领导经常说，你不要跟我讲技术，我只关心这个软件或项目有没有亮点，能不能挣钱。只有你有亮点，能挣钱，技术不是问题。

唉，这种想法试问一下，造时速5000公里的动车能挣钱，还有亮点，国家还有政策支持，那也得有这个技术实力才行对吧。现在流行大数据，云时代，假设给我们1000万条数据，我们如何加工成客户需要的，如果没有这个实力，还是先修炼内功。把技术做好吧。

世界那么大，我想找一个稍微看得起技术的环境。扯远了，回到正题了。

上次在写链表逆序的时候，收了一个园友的回复说，递归要比while循环看着直观。本人感谢这位园友的回复，其实个人觉得递归代码简单，逻辑性较好，代码跟踪与调试要求较高。

但在生产过程中，结合一定的业务逻辑进行处理时，给维护增加了一些复杂度。写个while死循环倒也是简单明了。呵呵，关于是不是用递归，何时用递归这是一个无解的问题。望大家勿喷。

上代码了：qt,c语言。

代码里面包含了递归和非递归的对比。以及链表的排序，插入、随机key值的生成等。本代码中，递归合并节点的关键是要记录前一个节点，同时再比较两个链表的头节点，节点pPrev的next指针，指向key值小的节点。同时将key值小的链表头向后移动一个位置，然后再进行下一次的递归合并。直到其中的一个链表为空。

#include <QCoreApplication>
#include <time.h>

const int MAX_CHAR = 30;
const int MAX_VALUE = 100;
//类型
enum lsType{
    Composite,
    Prime
};

//节点
typedef struct Node{
    int key;
    char value[MAX_CHAR];
    struct Node *next;
}NodeList;

//生成链表
Node* generateList(lsType type, int num);
//生成链表(按递归方式)
Node* generateListByRecursion(lsType type, int num);

//链表的合并
Node* mergeList(Node *list1, Node* list2);
//链表的递归合并
Node* recursionMergeList(Node* pPrev, NodeList *list1, NodeList* list2);
//打印链表
void printList(Node *pNode);
//判断一个数是否为质数
bool isPrime(unsigned long n);
//获得随机质数
int getRandPrime(int Max);
//释放链表
void freeList(Node *pList);
//链表的插入(while循环)
Node* InsertNode(NodeList* list, Node *pNode);
//链表的插入(递归入口)
Node* InsertNodeRecMain(NodeList* list, Node *pNode);
//链表的插入(递归体)
Node* InsertNodeByRecursion(Node* list, Node* pInsert, Node* pPrev);


int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    //随机数的种子值
    srand((unsigned)time(NULL));
    //普通生成方式
    //Node* pList1 = generateList(Composite, 10);
    //Node* pList2 = generateList(Prime, 10);
    printf("节点列表1(插入过程进行排序)
");
    //递归生成方式
    Node* pList1 = generateListByRecursion(Composite, 5);
    Node* pList2 = generateListByRecursion(Prime, 5);
    printList(pList1);    
    printf("节点列表2(插入过程进行排序)
");
    printList(pList2);
    Node* pList3 = mergeList(pList1, pList2);
    printf("合并后的节点列表为：
");
    printList(pList3);
    return a.exec();
}

/**
  * @函数名：generateList
  * @参数：type:根据不同的状态码，生成对应的链表
  *       num:链表的个数
  * @返回值：生成的链表
  * @用途： 生成链表
  * @作者：yangfy
  */
Node* generateList(lsType type, int num)
{
    int nrand;
    //下一节点
    Node* pHead = NULL, *pPrev = NULL;
    if(type == Composite){
        //生成头节点
        pHead = (Node*)malloc(sizeof(struct Node));
        nrand = rand() % MAX_VALUE + 2;
        pHead->key = nrand % 2 ? nrand - 1 : nrand;
        snprintf(pHead->value, MAX_CHAR - 1, "值为：%c元素", 65);
        pHead->next = NULL;
        pPrev = pHead;
        //生成数组
        for(int i = 1; i < num; i++){
            Node* pNode = (Node*)malloc(sizeof(struct Node));
            pNode->next = NULL;
            //100以内的合数
            nrand = rand() % MAX_VALUE + 2;
            pNode->key = nrand % 2 ? nrand - 1 : nrand;            
            snprintf(pNode->value, MAX_CHAR - 1, "值为：%c元素", 65 + i);
            pHead = InsertNode(pHead, pNode);
            //next节点的指定
            pPrev->next = pNode;
            pPrev = pNode;
        }
        return pHead;

    } else if(type == Prime){
        //生成头节点
        pHead = (Node*)malloc(sizeof(struct Node));
        pHead->key = getRandPrime(MAX_VALUE);
        pHead->next = NULL;
        snprintf(pHead->value, MAX_CHAR - 1, "值为：%c元素", 65);
        pPrev = pHead;
        //生成数组
        for(int i =1; i < num; i++){
            Node* pNode = (Node*)malloc(sizeof(struct Node));
            pNode->next = NULL;
            //获得质数
            pNode->key = getRandPrime(MAX_VALUE);
            snprintf(pNode->value, MAX_CHAR - 1, "值为：%c元素", 65 + i);
            pHead = InsertNode(pHead, pNode);
            //next节点的指定
            pPrev->next = pNode;
            pPrev = pNode;
        }
        return pHead;
    }
    return NULL;
}

/**
  * @函数名：generateListByRecursion
  * @参数：type 生成类型(质数、合数之分)
  *       num 节点数量
  * @返回值：生成的链表
  * @用途：生成指定数量、指定用途的链表
  * @作者：yangfy
  */
Node* generateListByRecursion(lsType type, int num)
{
    int nrand;
    //下一节点
    Node* pHead = NULL;
    if(type == Composite){
        //生成头节点
        pHead = (Node*)malloc(sizeof(struct Node));
        nrand = rand() % MAX_VALUE + 2;
        pHead->key = nrand % 2 ? nrand - 1 : nrand;
        snprintf(pHead->value, MAX_CHAR - 1, "值为：%c1元素", 65);
        pHead->next = NULL;
        //生成数组
        for(int i = 1; i < num; i++){
            Node* pNode = (Node*)malloc(sizeof(struct Node));
            pNode->next = NULL;
            //100以内的合数
            nrand = rand() % MAX_VALUE + 2;
            pNode->key = nrand % 2 ? nrand - 1 : nrand;
            snprintf(pNode->value, MAX_CHAR - 1, "值为：%c1元素", 65 + i);
            pHead = InsertNodeRecMain(pHead, pNode);
        }
        return pHead;

    } else if(type == Prime){
        //生成头节点
        pHead = (Node*)malloc(sizeof(struct Node));
        pHead->key = getRandPrime(MAX_VALUE);
        snprintf(pHead->value, MAX_CHAR - 1, "值为：%c2元素", 65);
        pHead->next = NULL;
        //生成数组
        for(int i =1; i < num; i++){
            Node* pNode = (Node*)malloc(sizeof(struct Node));
            pNode->next = NULL;
            //获得质数
            pNode->key = getRandPrime(MAX_VALUE);
            snprintf(pNode->value, MAX_CHAR - 1, "值为：%c2元素", 65 + i);
            pHead = InsertNodeRecMain(pHead, pNode);
        }
        return pHead;
    }
    return NULL;
}

/**
  * @函数名：isPrime
  * @参数：n:要判断的数
  * @返回值：是否为质数
  * @用途：判断一个数是否为质数
  * @作者：yangfy
  */
bool isPrime(unsigned long n)
{
    if (n <= 3){
        return n > 1;
    } else if (n % 2 == 0 || n % 3 == 0) {
        return false;
    } else {
        for (unsigned short i = 5; i * i <= n; i += 6) {
            if (n % i == 0 || n % (i + 2) == 0) {
                return false;
            }
        }
        return true;
    }
}
/**
  * @函数名：getRandPrime
  * @参数：nMax:随机的最大数
  * @返回值：随机生成的质数
  * @用途：随机生成MAX以内的质数
  * @作者：yangfy
  */
int getRandPrime(int Max)
{
    int nRand;
    while (1) {
        //获取100以内的质数
        nRand = rand() % Max + 1;
        if (isPrime(nRand))
            return nRand;
    }
}

/**
  * @函数名：InsertNode
  * @参数：list要插入节点的链表
  *       pNode要插入的节点
  * @返回值：插入完成后的链表
  * @用途：将指定节点插入到链表中
  * @作者：yangfy
  */
Node* InsertNode(NodeList* list, Node *pNode)
{
    Node* pHead = list;
    //异常判断
    if(list == NULL)
        return NULL;
    if(pNode == NULL)
        return pHead;
    //头节点处理
    if(pHead->key > pNode->key){
        pNode->next = pHead;
        return pNode;
    }
    //节点插入
    while (true) {
        if(pHead == NULL){
            break;
        }
        //尾节点
        if(pHead->next == NULL){
            pHead->next = pNode;
            break;
        }
        else if(pHead->next->key > pNode->key){
           pNode->next = pHead->next;
           pHead->next = pNode;
           break;
        }
        pHead = pHead->next;
    }
    return list;
}

/**
  * @函数名：InsertNodeRecMain
  * @参数：list要插入节点的链表
  *       pNode要插入的节点
  * @返回值：插入完成后的链表
  * @用途：通过递归方式将节点插入链表
  *       将递归中不通用的部分分离出来，递归链表的通用部分
  * @作者：yangfy
  */
Node* InsertNodeRecMain(NodeList *list, Node *pNode)
{
    //节点判断
    if(list == NULL) return pNode;
    if(pNode == NULL) return list;
    if(list->key > pNode->key){
        pNode->next = list;
        return pNode;
    }
    return InsertNodeByRecursion(list, pNode, NULL);
}
/**
  * @函数名：InsertNodeByRecursion
  * @参数：list要插入节点的链表
  *       pInsert:要插入的节点
  *       pPrev:插入位置的前一个节点(要把本节点next指向为插入节点)
  * @返回值：插入成功的链表
  * @用途：递归查找可以插入的节点位置，插入节点
  * @作者：yangfy
  */
Node* InsertNodeByRecursion(Node *list, Node *pInsert, Node *pPrev)
{
    Node* pResult = list;
    if(list != NULL){
        if(list->key > pInsert->key){
            pInsert->next = list;
            pPrev->next = pInsert;
        }
        else{
            InsertNodeByRecursion(list->next, pInsert, list);
        }
    } else{
        if(pPrev != NULL){
            pPrev->next = pInsert;
        }
    }
    return pResult;
}
/**
  * @函数名：mergeList
  * @参数：list1:要合并的链表1
  *       list2:要合并的链表2
  * @返回值：合并成功的链表
  * @用途：确定链表合并的开始位置(合理)，是不是可以理解为确定始基
  *       调用递归函数合并节点
  * @作者：yangfy
  */
Node* mergeList(Node *list1, Node* list2){
    Node* pPrev = NULL;
    if(list1->key < list2->key){
        pPrev = list1;
        list1 = list1->next;
    }else{
        pPrev = list2;
        list2 = list2->next;
    }
    return recursionMergeList(pPrev, list1, list2);
}
/**
  * @函数名：recursionMergeList
  * @参数：pPrev:要合并的前一个节点
  *       list1：链表1
  *       list2：链表2
  * @返回值：前一个节点
  * @用途：递归调用进行链表的合并
  * @作者：yangfy
  */
Node* recursionMergeList(Node *pPrev, NodeList *list1, NodeList *list2)
{
    if(list1 == NULL){
        pPrev->next = list2;
        return pPrev;
    }
    if(list2 == NULL){
        pPrev->next = list1;
        return pPrev;
    }
    if(list1->key < list2->key){
        pPrev->next = list1;
        list1 = list1->next;
        recursionMergeList(pPrev->next, list1, list2);
    } else {
        pPrev->next = list2;
        list2 = list2->next;
        recursionMergeList(pPrev->next, list1, list2);
    }
    return pPrev;
}
/**
  * @函数名：printList
  * @参数：pNode：要打印的链表头
  * @返回值：无
  * @用途：打印链表
  * @作者：yangfy
  */
void printList(Node *pNode)
{
    while (pNode != NULL) {
        if (pNode->next != NULL)
            printf("当前节点key为：%d, -->%s; (下一节点key为%d, -->%s)
", pNode->key, pNode->value, pNode->next->key, pNode->next->value);
        else
            printf("当前节点key为：%d, -->%s; 下一节点为NULL
", pNode->key, pNode->value);
        pNode = pNode->next;
    }
}
/**
  * @函数名：freeList
  * @参数：pList：要释放的链表
  * @返回值：无
  * @用途：释放链表
  * @作者：yangfy
  */
void freeList(Node *pList)
{
    Node *pNode = NULL;
    while (pList != NULL) {
        pNode = pList;
        pList = pList->next;
        free(pNode);
        pNode = NULL;
    }
}

运行结果如下图：