单链表基础

#include<bits/stdc++.h>
using namespace std;

//定义
typedef struct LNode{
    int data;
    LNode *next;
}LNode,*LinkList;

//头插
void LinkHeadInsert(LinkList &L)
{
    L=(LinkList)malloc(sizeof(LNode));
    L->next=NULL;
    int x;
    LNode *s;
    cin>>x;
    while(x!=9999)
    {
        s=(LNode*)malloc(sizeof(LNode));
        s->data=x;
        s->next=L->next;
        L->next=s;
        cin>>x;
    }
}

//尾插
void LinkTailInsert(LinkList &L)
{
    L=(LinkList)malloc(sizeof(LNode));
    L->next=NULL;
    int x;
    LNode *s,*r=L;
    cin>>x;
    while(x!=9999)
    {
        s=(LNode*)malloc(sizeof(LNode));
        s->data=x;
        r->next=s;
        r=s;
        cin>>x;
    }
    r->next=NULL;
}

//头插不带头节点,把next去掉即可
void LinkHeadInsert2(LinkList &L)
{
    L=(LinkList)malloc(sizeof(LNode));
    L=NULL;
    int x;
    cin>>x;
    LNode *s;
    while(x!=9999)
    {
        s=(LNode*)malloc(sizeof(LNode));
        s->data=x;
        s->next=L;
        L=s;
        cin>>x;
    }
}

//尾插不带头节点，判断是否是第一个节点即可
void LinkTailInsert2(LinkList &L)
{
    L=(LinkList)malloc(sizeof(LNode));
    L=NULL;
    int x;
    cin>>x;
    LNode *s,*r=L;
    while(x!=9999)
    {
        s=(LNode*)malloc(sizeof(LNode));
        s->data=x;
        if(L==NULL)
        {
            L=s;
        }
        else
        {
            r->next=s;
        }
        r=s;
        cin>>x;
    }
    r->next=NULL;
}

//打印
void print(LinkList &L)
{
    LNode *p=L->next;
    while(p!=NULL)
    {
        cout<<p->data<<" ";
        p=p->next;
    }
    cout<<endl;
}

//按序号查找
LNode *FindById(LinkList &L,int id)
{
    int i=1;
    LNode *p=L->next;
    if(id==0)
    {
        return L;
    }
    if(id<1)
    {
        return NULL;
    }
    while(p!=NULL&&i<id)
    {
        p=p->next;
        i++;
    }
    return p;
}

//按值查找
LNode *FindByVal(LinkList &L,int x)
{
    LNode *p=L->next;
    while(p!=NULL&&p->data!=x)
    {
        p=p->next;
    }
    return p;
}

//插入
void Insert(LinkList &L,int id,int x)
{
    LNode *p=FindById(L,id-1);
    LNode *s=(LNode*)malloc(sizeof(LNode));
    s->data=x;
    s->next=p->next;
    p->next=s;
}

//删除
void Delete(LinkList &L,int id)
{
     LNode *p=FindById(L,id-1);
     LNode *q=p->next;
     p->next=q->next;
     free(q);
}

//逆置,摘链+头插
void Reverse(LinkList &L)
{
    LNode *p=L->next,*r;
    L->next=NULL;
    while(p)
    {
        r=p->next;//暂存
        p->next=L->next;
        L->next=p;
        p=r;//把暂存的还给p
    }
}

//逆序输出
void ReverseOutput(LinkList L)
{
    LNode *p=L->next;
    if(p->next!=NULL)
    {
        ReverseOutput(L->next);
    }
    if(p!=NULL)
    {
        cout<<p->data<<" ";
    }
}

//删除所有值为x的节点
void Deletex(LinkList &L,int x)
{
    LNode *p=L->next,*pre=L,*q;
    while(p!=NULL)
    {
        if(p->data==x)
        {
            q=p;
            p=p->next;
            pre->next=p;
            free(q);
        }
        else
        {
            pre=p;
            p=p->next;
        }
    }
}

//删除一个最小值
void DeleteMin(LinkList &L)
{
    LNode *p=L->next,*pre=L;
    LNode *minp=p,*minpre=pre;
    while(p!=NULL)
    {
        if(minp->data>p->data)
        {
            minp=p;
            minpre=pre;
        }
        pre=p;
        p=p->next;
    }
    minpre->next=minp->next;
    free(minp);
}

//递增排序
void Sort(LinkList &L)
{
    LNode *p=L->next,*pre;
    LNode *r=p->next;//保存第二个节点
    p->next=NULL;//L只剩下头节点和第一个节点
    p=r;//p指向第二个节点
    while(p!=NULL)
    {
        r=p->next;//防止断链
        pre=L;
        while(pre->next!=NULL&&pre->next->data<p->data)
        {
            pre=pre->next;
        }
        p->next=pre->next;//将p插入pre之后
        pre->next=p;
        p=r;
    }
}

//单链表长度
int Length(LinkList &L)
{
    LNode *p=L->next;
    int length=0;
    while(p!=NULL)
    {
        p=p->next;
        length++;
    }
    return length;
}
//寻找公共节点
LinkList FindCommen(LinkList La,LinkList Lb)
{
    int len1=Length(La),len2=Length(Lb);
    LinkList longlist,shortlist;
    int dist;
    if(len1>len2)
    {
        longlist=La->next;
        shortlist=Lb->next;
        dist=len1-len2;
    }
    else
    {
        longlist=Lb->next;
        shortlist=La->next;
        dist=len2-len1;
    }
    while(dist--)
    {
        longlist=longlist->next;
    }
    while(longlist!=NULL)
    {
        if(longlist==shortlist)
        {
            return longlist;
        }
        else
        {
            longlist=longlist->next;
            shortlist=shortlist->next;
        }
    }
    return NULL;
}

//递增次序输出元素
void SortOutput(LinkList &L)
{
    while(L->next!=NULL)//循环到只剩头节点
    {
       LNode *p=L->next,*pre=L;
       LNode *minp=p,*minpre=pre;
       while(p!=NULL)
       {
           if(p->data<minp->data)
           {
               minp=p;
               minpre=pre;
           }
           pre=p;
           p=p->next;
       }
      cout<<minp->data<<" ";
      minpre->next=minp->next;
      free(minp);
    }
}

//分解链表
void DisCreate(LinkList &La)
{
    int i=0;
    LinkList Lb=(LinkList)malloc(sizeof(LNode));
    Lb->next=NULL;
    LNode *ra=La,*rb=Lb;
    LNode *p=La->next;
    La->next==NULL;
    while(p!=NULL)
    {
        i++;
        if(i%2==0)
        {
            rb->next=p;
            rb=p;
        }
        else
        {
            ra->next=p;
            ra=p;
        }
        p=p->next;
    }
    ra->next=NULL;
    rb->next=NULL;
}

//有序链表删除相同元素
void DeleteSame(LinkList &L)
{
    LNode *p=L->next,*q;
    while(p->next!=NULL)
    {
        q=p->next;
        if(p->data==q->data)
        {
            p->next=q->next;
            free(q);
        }
        else
        {
            p=p->next;
        }
    }
}

//判断Lb是不是La的子序列
bool Judge(LinkList &La,LinkList &Lb)
{
    LNode *p=La->next,*q=Lb->next,*pre=p;
    while(p!=NULL&&q!=NULL)
    {
        if(p->data==q->data)
        {
            p=p->next;
            q=q->next;
        }
        else
        {
            pre=pre->next;
            p=pre;
            q=Lb->next;
        }
    }
    if(q==NULL)
        return true;
    else
        return false;
}
int main()
{
    LinkList l;
    LinkTailInsert(l);
    print(l);
    DeleteSame(l);
    print(l);
}