链表bate1.0

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <algorithm>
using namespace std;

typedef int ElemType;
typedef struct Node
{
    ElemType data;
    struct Node *next;
} Node, *LinkList;

LinkList CreateList(LinkList &h)
{
    LinkList p,q;
    ElemType x;
    h = (LinkList)malloc(sizeof(Node));
    p = h;
    while(cin>>x&&x)
    {
        q = (LinkList)malloc(sizeof(Node));
        q->data = x;
        p->next = q;
        p = q;
    }
    p->next = NULL;
    return h;
}

void Display(LinkList l)
{
    LinkList p ;
    p = l->next;
    while(p!=NULL)
    {
        cout<<p->data<<" ";
        p = p->next;
    }
    cout<<endl;
}

void Reverse(LinkList &l)
{
    LinkList p,q;
    p = l->next;
    l->next = NULL;
    while(p!=NULL)
    {
        q = p;
        p = p->next;
        q->next = l->next;
        l->next = q;
    }
}

void Del_Ou(LinkList &l)
{
    LinkList p;
    p = l->next;
    int i=1;
    while(p->next!=NULL)
    {
        i++;
        if(i%2)
            p=p->next;
        else
        {
            LinkList q = p->next;
            p->next = p->next->next;
            free(q);
        }
    }
}

void Insert(LinkList &l,ElemType x)
{
    LinkList p,q;
    p = l->next;
    while(p->next!=NULL)
    {
        if(p->next->data<x)
        {
            p = p->next;
        }
        else
        {
            //cout<<x<<endl;
            q = new Node;
            q->data = x;
            q->next = p->next;
            p->next = q;
            break;
        }
    }
}

LinkList MergeList(LinkList &h,LinkList &l,LinkList &A)
{
    LinkList p,q,r;
    p = h->next;
    q = l->next;
    A = r = h;//init
    while(p!=NULL&&q!=NULL)
    {
        if(p->data <= q->data)
        {
            r->next = p;
            r = p;
            p = p->next;
        }
        else
        {
            r->next = q;
            r = q;
            q = q->next;
        }
    }
    r->next = p?p:q;
    delete l;
    return A;
}

void TakeApart(LinkList &h)
{
    LinkList L1,L2;
    LinkList p;
    p = h->next;
    //L1 = h;
    //L2 = h;
    L1->next = NULL;
    L2->next = NULL;
    while(p!=NULL)
    {
        cout<<p->data;
        if(p->data%2==1)
        {
            L1->data = p->data;
            L1 = L1->next;
        }
        else
        {
            L2->data = p->data;
            L2 = L2->next;
        }
        p = p->next;
    }
    L1->next = NULL;
    L2->next = NULL;
    Display(L1);
    Display(L2);
}

void DisCreate(LinkList &A)
{
    //将表A中结点按序号的奇偶性分解到表A或表B中
    int i=0;  //i记录表A中结点的序号
    LinkList B= (LinkList) malloc (sizeof (Node) );  //创建 B 表表头
    B->next=NULL;  //B 表的初始化
    Node *ra = A, *rb=B;  //ra和rb将分别指向将创建的A表和B表的尾结点
    LinkList p=A->next;  //p为链表工作指针，指向待分解的结点
    A->next=NULL;  //置空新的 A 表
    while (p!=NULL)
    {
        i++;  //序号加 1
        if (i%2==0)    //处理序号为偶数的链表结点
        {
            rb->next=p;  // 若B表尾描入新结点
            rb=p;  //rb指向新的尾结点
        }
        else      //处理原序号为奇数的结点
        {
            ra->next=p;  //在A表尾插入新结点
            ra=p;
        }
        p=p->next;  //将p恢复为指向新的待处理结点
    }  //while 结束
    ra->next=NULL;
    rb->next=NULL;
    //return B;
    Display(A);
    Display(B);
}

int main()
{
    // 1 2 3 4 5 6 7 8 9 10 0
    LinkList head;
    CreateList(head);//建立链表
    Display(head);//遍历链表

    //Reverse(head);//反转链表
    //Display(head);

    //Del_Ou(head);//删除偶数下标元素
    //Display(head);

    //int x;
    //cin>>x;//要插入的数
    //Insert(head,x);//插入元素，并为非递减序列
    //Display(head);

    //建立两个非递减有序单向链表，然后合并成一个非递减链表。
    //LinkList list2;
    //CreateList(list2);//建立链表二
    //Display(head);
    //Display(list2);
    //LinkList AfterMerge;
    //Display(MergeList(head,list2,AfterMerge));

    //利用算法1建立的链表，实现将其分解成两个链表，
    //其中一个全部为奇数，另一个全部为偶数（尽量利用已知的存储空间）。
    //TakeApart(head);
    //Display(DisCreate(head));
    //Display(head);
    DisCreate(head);
    return 0;
}