合并两个有序链表

1.非递归方式

  1 #include "stdafx.h"
  2 #include <iostream>
  3 using namespace std;
  4 
  5 struct ListNode
  6 {
  7 int m_nValue;
  8 ListNode *m_pNext;
  9 };
 10 
 11 //合并两个有序链表,非递归方法
 12 ListNode *MergeTwoList(ListNode *pListOneHead, ListNode *pListTwoHead)
 13 {
 14 if (pListOneHead == NULL)
 15 {
 16 return pListTwoHead;
 17 }
 18 
 19 if (pListTwoHead == NULL)
 20 {
 21 return pListOneHead;
 22 }
 23 
 24 ListNode *pNode1 = pListOneHead;
 25 ListNode *pNode2 = pListTwoHead;
 26 ListNode *pMergeListHead = NULL;
 27 ListNode *pCurLastNode = NULL;
 28 
 29 if (pNode1->m_nValue < pNode2->m_nValue)
 30 {    
 31 pMergeListHead = pListOneHead;
 32 pNode1 = pNode1->m_pNext;
 33 pCurLastNode = pMergeListHead;
 34 }
 35 else
 36 {
 37 pMergeListHead = pListTwoHead;
 38 pNode2 = pNode2->m_pNext;
 39 pCurLastNode = pMergeListHead;
 40 }
 41 
 42 while (pNode1 != NULL && pNode2 != NULL)
 43 {
 44 if (pNode1->m_nValue < pNode2->m_nValue)
 45 {    
 46 pCurLastNode->m_pNext = pNode1;
 47 pCurLastNode = pNode1;
 48 pNode1 = pNode1->m_pNext;    
 49 }
 50 else
 51 {
 52 pCurLastNode->m_pNext = pNode2;
 53 pCurLastNode = pNode2;
 54 pNode2 = pNode2->m_pNext;    
 55 }
 56 
 57 if (pNode1 == NULL)
 58 {
 59 pCurLastNode->m_pNext = pNode2;    
 60 }
 61 
 62 if (pNode2 == NULL)
 63 {
 64 pCurLastNode->m_pNext = pNode1;    
 65 }
 66 }
 67 
 68 return pMergeListHead;
 69 }
 70 
 71 //创建一个链表，输入从头到尾结点的值，输入-1表示结束
 72 void CreateList(ListNode *& pHead)
 73 {    
 74 ListNode *pListNode = NULL;
 75 ListNode *pCurLastNode = NULL;
 76 bool isHead = true;
 77 
 78 while (1)
 79 {
 80 if (isHead)
 81 {    
 82 pHead = new ListNode();
 83 cin >> pHead->m_nValue;
 84 if (pHead->m_nValue == -1)
 85 {
 86 pHead = NULL;
 87 break;
 88 }
 89 pHead->m_pNext = NULL;
 90 isHead = false;
 91 pCurLastNode = pHead;
 92 }
 93 else
 94 {
 95 pListNode = new ListNode();
 96 cin >> pListNode->m_nValue;
 97 if (pListNode->m_nValue == -1)
 98 {
 99 break;
100 }
101 pListNode->m_pNext = NULL;
102 pCurLastNode->m_pNext = pListNode;
103 pCurLastNode = pListNode;    
104 }    
105 }
106 }
107 
108 //从头到尾打印链表
109 void PrintList(ListNode *&pHead)
110 {
111 if (pHead != NULL)
112 {
113 ListNode *pCur = pHead;
114 while (pCur != NULL)
115 {
116 cout << pCur->m_nValue << " ";
117 pCur = pCur->m_pNext;
118 }
119 cout << endl;
120 }
121 else
122 {
123 cout << "链表为空！" << endl;
124 }
125 }
126 
127 int _tmain(int argc, _TCHAR* argv[])
128 {
129 ListNode *pList1Head = NULL;
130 CreateList(pList1Head);
131 PrintList(pList1Head);
132 
133 ListNode *pList2Head = NULL;
134 CreateList(pList2Head);
135 PrintList(pList2Head);
136 
137 ListNode *pMergeListHead = MergeTwoList(pList1Head, pList2Head);
138 if (pMergeListHead != NULL)
139 {
140 cout << pMergeListHead->m_nValue << endl;
141 }    
142 PrintList(pMergeListHead);
143 
144 system("pause");
145 return 0;
146 }
147 
148

递归方式：

#include "stdafx.h"
#include <iostream>
using namespace std;

struct ListNode
{
    int m_nValue;
    ListNode *m_pNext;
};

//合并两个有序链表,递归方法
ListNode *MergeTwoList(ListNode *pListOneHead, ListNode *pListTwoHead)
{
    if (pListOneHead == NULL)
    {
        return pListTwoHead;
    }

    if (pListTwoHead == NULL)
    {
        return pListOneHead;
    }

    ListNode *pMergeListHead = NULL;

    if (pListOneHead->m_nValue < pListTwoHead->m_nValue)
    {
        pMergeListHead = pListOneHead;
        pMergeListHead->m_pNext = MergeTwoList(pMergeListHead->m_pNext, pListTwoHead);
    }
    else
    {
        pMergeListHead = pListTwoHead;
        pMergeListHead->m_pNext = MergeTwoList(pListOneHead, pMergeListHead->m_pNext);
    }

    return pMergeListHead;
}

//创建一个链表，输入从头到尾结点的值，输入-1表示结束
void CreateList(ListNode *& pHead)
{    
    ListNode *pListNode = NULL;
    ListNode *pCurLastNode = NULL;
    bool isHead = true;

    while (1)
    {
        if (isHead)
        {    
            pHead = new ListNode();
            cin >> pHead->m_nValue;
            if (pHead->m_nValue == -1)
            {
                pHead = NULL;
                break;
            }
            pHead->m_pNext = NULL;
            isHead = false;
            pCurLastNode = pHead;
        }
        else
        {
            pListNode = new ListNode();
            cin >> pListNode->m_nValue;
            if (pListNode->m_nValue == -1)
            {
                break;
            }
            pListNode->m_pNext = NULL;
            pCurLastNode->m_pNext = pListNode;
            pCurLastNode = pListNode;    
        }            
    }
}

//从头到尾打印链表
void PrintList(ListNode *&pHead)
{
    if (pHead != NULL)
    {
        ListNode *pCur = pHead;
        while (pCur != NULL)
        {
            cout << pCur->m_nValue << " ";
            pCur = pCur->m_pNext;
        }
        cout << endl;
    }
    else
    {
        cout << "链表为空！" << endl;
    }
}

int _tmain(int argc, _TCHAR* argv[])
{
    ListNode *pList1Head = NULL;
    CreateList(pList1Head);
    PrintList(pList1Head);

    ListNode *pList2Head = NULL;
    CreateList(pList2Head);
    PrintList(pList2Head);

    ListNode *pMergeListHead = MergeTwoList(pList1Head, pList2Head);
    if (pMergeListHead != NULL)
    {
        cout << pMergeListHead->m_nValue << endl;
    }    
    PrintList(pMergeListHead);

    system("pause");
    return 0;
}

 

posted on 2014-01-02 18:54  realmeh  阅读(76)  评论(0)    收藏  举报

导航