DS单链表--合并

题目描述

假定两个单链表是递增有序，定义并实现以下函数，完成两个单链表的合并，继续保持递增有序

int LL_merge(ListNode *La, ListNode *Lb)

输入

第1行先输入n表示有n个数据，接着输入n个数据

第2行先输入m表示有M个数据，接着输入m个数据

输出

输出合并后的单链表数据，数据之间用空格隔开

输入样例1	输出样例1
3 11 33 55 4 22 44 66 88	11 22 33 44 55 66 88 \n

#include<iostream>

using namespace std;

class Lnode{
    int data;
    Lnode *next;

public:

    Lnode(){
        data = NULL;
        next = NULL;
    }

    void Lcreat(Lnode *head){

        int t;
        cin>>t;
        Lnode *end = head;
        while(t--){

            Lnode *p = new Lnode ;
            cin>> p->data;
            p->next = NULL;
            end->next = p ;
            end = p ;

        }

    }

    int LL_merge(Lnode *La , Lnode *Lb)
    {

        Lnode *p = La->next;
        while(p->next&&p->data)
        {

            p = p->next;

        }
        p->next = Lb->next;

        return 0;

    }

    void Sort(Lnode *head){//不该用数组思想的冒泡的，链表应该直接插入

        for( Lnode *p1 = head ; p1->next&&p1->next->data ; p1 = p1->next ){

            for( Lnode *p2 = p1->next ; p2&&p2->next ; p2 = p2->next ){

                if( p2->next->data < p1->next->data )
                {
//                    cout<<"now: "<<p2->next->data<<" and "<<p1->next->data<<endl;

                    if(p1->next == p2)
                    {
                        if(p2->next->next )
                        {
                            Lnode * k = p2->next->next;
                            Lnode * k2 = p2->next;
                            p2->next->next = p1->next;
                            p1->next->next = k;
                            p1->next = k2;
                        }
                        else
                        {
                            Lnode * k2 = p2->next;
                            p2->next->next = p1->next;
                            p1->next->next = NULL;
                            p1->next = k2;

//                            break;
                        }
//                        print(head);

                    }
                    else
                    {

                        if(p2->next->next)
                        {
//                            print(head);
                            Lnode *k = p1->next->next ;
                            p1->next->next = p2->next->next ;
//                            print(p1);
                            p2->next->next = k;

                            Lnode *k2 = p1->next;
                            p1->next = p2->next;
                            p2->next = k2;
//                            print(p2);

                        }
                        else
                        {

//                            print(head);
                            Lnode *k = p1->next->next ;
                            p1->next->next = NULL;
//                            print(p1);
                            p2->next->next = k;

                            Lnode *k2 = p1->next;
                            p1->next = p2->next;
                            p2->next = k2;
//                            print(p2);

                        }


                    }


                }


            }

        }
        print(head);

    }

    void print(Lnode *head){

        for( Lnode *p = head->next; p ; p=p->next )
        {

            cout<<p->data<<" ";

        }

        cout<<endl;

    }

};

int main(){

    Lnode *h1 = new Lnode;
    Lnode *h2 = new Lnode;
    h1->Lcreat(h1);
    h2->Lcreat(h2);

    h1->LL_merge(h1,h2);
    h1->Sort(h1);

    return 0;
}

感悟：该题的有序排列部分，本人仍沿用了数组思想的冒泡排列，但做到一半突然发现链表有自己的存储数据的特征：那就是并非依靠内存位置顺序排列，而是摆脱了内存顺序限制的；

那么就是说链表的排列可以只用插入，而非数组思维的交换；

关于该题的排列部分：

链表优点：不受内存限制，（并非一个人动了其他人就要挪窝，动的只是相对位置），所以一般情况下可以只移动一个。

数组缺点：受内存限制，（内存位置是固定的，一个人想动，其他人就得跟着动，或者交换位置，因为有空位才能放东西），所以一次冒泡，要交换至少两个元素位置。

链表缺点：内存权限上的自由，带来的就是野指针的滋生，内存上减少的约束需要在变动过程中时刻关注内存空间的利用（添加if分流约束或在for（；...；）中添加约束条件），代码量会比较大。

数组优点：内存保护性够强，所以相对不容易内存泄露 或者较为准确的说 内存泄漏容易察觉，代码量较少。

如有疑问或指教，敬请留言。