2-线性表 链式存储-单链表

想起大二笨笨的，很仔细地扣每个代码每个函数的细节，精确到用‘&’还是用‘*’

把所有自己不明白的函数都搜了一遍

硬着头皮去看，自己也没有学多好。

链表刚学的时候弄了自己两三天

明明是很简单的内容

我大概太笨，理解能力不好，学习方法也不好

但昨晚居然一个小时内哼哧哼哧写出来了

也许是很微小的事情，很微小的细节

也许第二次重新做的时候比第一次快了只有几分钟 至少真的进步了

加油，硬着头皮干，大家都是这么过来的

1、单链表基本功能的实现

#include<iostream>
#include<cstdlib>
using namespace std;
#define ture 1
#define false 0
#define maxsize 50
#define listincreament 10
#define ok 1
#define error -3
#define overflow -2
typedef int Status;
typedef int ElemType;
typedef struct LNode
{
    ElemType data;
    struct LNode *next;
} LNode,*LinkList;
//头插法建单链表
void CreatList_head(LinkList &L,int length)//头插法
{
    LNode *s;
    int x;
    L=(LinkList)malloc(sizeof(LNode));
    L->next=NULL;//创建头结点
    while(length--)
    {
        cin>>x;
        s=(LNode *)malloc(sizeof(LNode));
        s->data=x;
        s->next=L->next;
        L->next=s;
    }

}
void CreatList_tail(LinkList &L,int length)//尾插法
{
    LNode *p,*s;
    int x;
    L=(LinkList)malloc(sizeof(LNode));
    L->next=NULL;
    p=L;
    while(length--)
    {
        cin>>x;
        s=(LNode *)malloc(sizeof(LNode));
        s->data=x;
        p->next=s;
        s->next=NULL;
        p=p->next;
    }
}

LNode* GetElem_order(LinkList &L,int n)//按序号查找节点
{
    LNode *p=L;
    while(p!=NULL&&n>0)
    {
        p=p->next;
        n--;
    }
    return p;
}
LNode* GetElem_data(LinkList &L,ElemType e)//按值查找节点
{
    LNode *p=L;
    while(p!=NULL&&p->data!=e)
        p=p->next;
    return p;
}
void InsertLNode(LinkList &L,ElemType elem,int pos)
{
    LNode *p=L,*s;
    pos--;
    while(pos>0)
    {
        p=p->next;
        pos--;
    }
    s=(LNode *)malloc(sizeof(LNode));
    s->data=elem;
    s->next=p->next;
    p->next=s;
}
void InsertLNode2(LinkList &L,ElemType elem,int pos)
{
    LNode *p=L,*s;
    while(pos>0)
    {
        p=p->next;
        pos--;
    }
    s=(LNode *)malloc(sizeof(LNode));
    s->data=elem;
    s->next=p->next;
    p->next=s;
    swap(p->data,s->data);
}
//书上介绍的一种方法，将s直接插入到第pos个节点的后面，再交换两个值。。
void DeleteList_order(LinkList &L,int pos)//删除指定序号的节点
{
    LNode *p=GetElem_order(L,pos-1);
    LNode *q=p->next;
    p->next=q->next;
    free(q);
}
void DeleteList_data(LinkList &L,ElemType elem)//删除指定值的节点
{
    LNode *p=GetElem_data(L,elem);
    if(p->next!=NULL)//如果p不是最后一个节点，交换p和p下一个节点的值，删除p的下一个节点（逻辑上等同于删除p
    {
        LNode *q=p->next;
        swap(q->data,p->data);
        p->next=q->next;
        free(q);
    }
    else free(p);//如果p是最后一个节点，那么可以直接删除p。
}
int showlength(LinkList L)//求表长。
{
    int length=0;
    while(L->next!=NULL)
    {
        length++;
        L=L->next;
    }
    return length;
}
void showList(LinkList &L)
{
    LNode *p=L->next;
    while(p!=NULL)
    {
        cout<<p->data;
        if(!(p->next==NULL))
        {
            cout<<' ';
        }
        p=p->next;
    }
    cout<<endl;
}
void showpoint(LNode *p)//展示特定节点的信息
{
    if(p!=NULL)
        cout<<p->data<<endl;
    else cout<<"not found."<<endl;
}

//注意：因为生成链表的时候第一个节点是跟在L的后面，即L本身是不存储信息的。
//故在按照链表的顺序输出元素值的时候，工作指针p一开始应该指向第一个节点（即L->next)
int main()
{
    LNode *L1,*L2,*pos;
    CreatList_head(L1,10);
    CreatList_tail(L2,7);
    showList(L1);
    showList(L2);
    pos=GetElem_order(L2,4);
    showpoint(pos);
    pos=GetElem_data(L2,99);
    showpoint(pos);
    InsertLNode(L1,10,6);
    InsertLNode2(L2,100,5);
    showList(L1);
    showList(L2);

    DeleteList_order(L1,2);
    DeleteList_data(L2,100);
    cout<<"After delete some elem:"<<endl;
    showList(L1);
    showList(L2);
    cout<<"Show the length of linklist:L1 is "<<showlength(L1)<<",while L2 is "<<showlength(L2)<<"."<<endl;
}

 2、单链表的一些小功能算法实现：

（1）【来源】王道书本题1~7

/*-----------------算法设计-----------------*/
/*递归算法，删除不带头结点的单链表x中所有值为x的节点*/
/*终止条件：L为空表，不作任何事*/
/*递归主体：如果L->data为x ~ delete_X(L->next,x)*/
void delete_X(LinkList &L,ElemType x)
{
    LNode *p;
    if(L==NULL) return ;
    if(L->data==x)
    {
        p=L;
        L=L->next;
        free(p);
        delete_X(L,x);
    }
    else delete_X(L->next,x);
}
/*带头结点的单链表中删除所有值为x的节点，释放空间。*/
/*做法1：直接删除值为x的节点*/
void delete_allX(LinkList &L,ElemType x)
{
    LNode *p=L->next,*q,*r=L;
    while(p!=NULL)
    {
        if(p->data==x)
        {
            q=p;
            r->next=p->next;
            p=p->next;
            free(q);
        }
        else
        {
            p=p->next;
            r=r->next;
        }
    }
}
/*做法2：通过尾插法把data值非x的节点接入r->next*/
void delelet_allX2(LinkList &L,ElemType x)
{
    LNode *p=L->next,*r=L,*q;
    while(p!=NULL)
    {
        if(p->data!=x)
        {
            r->next=p;
            r=p;
            p=p->next;
        }
        else
        {
            q=p;
            p=p->next;
            free(q);
        }
    }
}

/*逆向输出链表的元素值*/
/*用递归的思路实现*/
void reverse_print(LinkList L)
{
    if(L->next!=NULL) reverse_print(L->next);
    cout<<L->data<<' ';
}
//注：调用的时候，如果链表有头结点，调用的时候应该如此调用：reverse_print(L1->next);

/*编写删除带头结点链表中值为最小的节点的高效算法*/
void delete_mindata(LinkList &L)
{
    LNode *p=L->next,*r=L;
    LNode *minr=r,*minp=p;
    while(p!=NULL)
    {
        if(p->data<minp->data)
        {
            minr=r;
            minp=p;
        }
        r=r->next;
        p=p->next;
    }
    minr->next=minp->next;
    free(minp);
}
/*逆置单链表，空间复杂度为O（1）*/
/*头插法*/
void reverse_LinkList(LinkList &L)
{
    LNode *p=L->next,*r=L;
    L->next=NULL;
    while(p!=NULL)
    {
        r=p->next;
        p->next=L->next;
        L->next=p;
        p=r;
    }
}
/*指针翻转法*/
/*用笔模拟一下就很好理解了*/
void Reverse_LinkList2(LinkList &L)
{
    LNode *r,*p=L->next,*q=p->next;
    p->next=NULL;
    while(q!=NULL)
    {
        r=p;
        p=q;
        q=q->next;
        p->next=r;
    }
    L->next=p;
}

/*对于带头链表L排序使之递增有序*/
/*头插法：找到第一个大于它的节点，用头插法插入链表*/
void sortLinkList(LinkList &L)
{
    LNode *p,*q,*r;
    p=L->next;
    q=p->next;
    p->next=NULL;
    p=q;
    while(p!=NULL)
    {
        q=q->next;
        r=L;
        while(r->next!=NULL&&r->next->data<p->data) r=r->next;

        //头插法插入链表L
        p->next=r->next;
        r->next=p;
        p=q;
    }
}
/*删除代表头节点的链表中值于给定两个元素之间的节点*/
int delete_lotsofe(LinkList &L,int a,int b)
{
    if(b<a) return error;//a要>b
    LNode *p=L->next,*r=L,*q;
    while(p!=NULL)
    {
        if(p->data<b&&p->data>a)
        {
            q=p;
            r->next=p->next;
            p=p->next;
            free(q);
        }
        else{
            p=p->next;
            r=r->next;
        }
    }
}

【注】

1、单链表运用头插法递增排序示意图

（2）【来源】王道书本题8~15

啊啊啊弄了一下午，美好下午就没有了！！！！！蓝瘦！！！！！！

我的线代复习大业啊！！

其中那个就地算法拆分线性表的还不好使，我要思考一下到底是啥问题……要是有大神知道了请告诉我orz

/*寻找两个单链表的共同结点*/
/*按自己的想法写了一下，让链表长度比较长的链表工作指针往后走到剩余长度与较短链表想同*/
/*然后同时工作指针后移，找到第一个相同的结点（由于链表指针后序唯一性，剩下的结点肯定是一样的）*/
LinkList Search_commonLNode(LinkList &a,LinkList &b)
{
    LNode *p=a,*q=b;
    int numa=showlength(a),numb=showlength(b);
    if(numa>numb)
    {
        while(numa!=numb)
        {
            p=p->next;
            numa--;
        }
    }
    else if(numb>numb)
    {
        while(numb!=numa)
        {
            q=q->next;
            numb--;
        }
    }
    while(q!=p)
    {
        q=q->next;
        p=p->next;
    }
    return q;
}
/*不使用数组作为辅助空间，递增输出链表元素值并且输出同时释放链表结点*/
void print_increase(LinkList &L)
{
    LNode *p,*q,*r;
    while(L->next!=NULL)
    {
        q=L;
        p=L->next;
        while(p->next!=NULL)//参考点为后继元素，这里要用p->next
        {
            if(p->next->data<q->next->data)//每一次对比指向最小元素的前驱
                q=p;
            p=p->next;
        }
        cout<<q->next->data<<" ";
        r=q->next;
        q->next=q->next->next;
        free(r);
    }
    //最后别忘记释放头结点
    free(L);
}
/*给定一个带头结点的单链表A，分解为两个带头结点的单链表A和B
使得表A中含有原来序号为奇数的元素，表B含有原来序号为偶数的元素*/
LinkList Discreate_1(LinkList &A)
{
    int flag=1;
    LNode *B;
    B=(LinkList)malloc(sizeof(LNode));
    B->next=NULL;
    LNode *b,*a=A->next,*pb=B,*pa=A;
    A->next=NULL;
    while(a!=NULL)//原来想试着不使用flag标志，直接一次处理两个结点。后来捣鼓了半小时还是不对，敢情要针对A表长度奇偶性写两种情况……
        //为了赶时间还是放弃那么写了，还是这个直接断开A链表，重装A、B的方法逻辑上更简单粗暴
    {
        if(flag)
        {
            pa->next=a;
            pa=pa->next;
            flag=!flag;
        }
        else
        {
            pb->next=a;
            pb=pb->next;
            flag=!flag;
        }
        a=a->next;
    }
    pa->next=NULL;
    pb->next=NULL;
    return B;
}
/*设计一个就地算法把一个链表拆成两个线性表(a和b)*/
/*c:a1,b1,a2,b2..*/
/*卧槽，原来这个就是我所想的一次处理两元素……刚刚到底是哪里出错了啊啊！*/
/*采用头插法插入结点后，p的指针域会改变，必须设置一个变量保存p的后继结点，不然会产生断链的问题！*/
LinkList Discreate_2(LinkList &C)
{
    LinkList B=(LinkList)malloc(sizeof(LNode));
    B->next=NULL;
    LNode *p=C->next;
    LNode *q,*c=C;
    while(p!=NULL)
    {
        c->next=p;
        c=p;
        p=p->next;
        q=p->next;//用q保存p的后继结点。
        p->next=B->next;
        B->next=p;
        p=q;
    }
    c->next=NULL;
    return B;
}
/*还是出错，这是为啥 这是为啥！！先跳过了*/

/*递增有序链表去掉元素相同的结点*/
void delete_same(LinkList &L)
{
    LNode *p=L->next,*pre=p,*q;
    while(p->next!=NULL)
    {
        q=p->next;
        if(p->data==q->data)
        {
            p->next=q->next;
            free(q);
        }
        else p=p->next;
    }
}
/*两个递增次序排列的线性表以单链表存储
试把两个单链表归并成一个按照元素值递减次序排列的单链表
存放在原来的结点
*/
void mergeList_bydesc(LinkList &A,LinkList &B)
{
    LNode *pa=A->next,*pb=B->next,*r;
    A->next=NULL;
    while(pa&&pb)
    {
        if(pa->data<pb->data)
        {
            r=pa->next;
            pa->next=A->next;
            A->next=pa;
            pa=r;
        }
        else
        {
            r=pb->next;
            pb->next=A->next;
            A->next=pb;
            pb=r;
        }
    }
    if(pa)
        pb=pa;
    while(pb)
    {
        r=pb->next;
        pb->next=A->next;
        A->next=pb;
        pb=r;
    }
}
/*在不破坏A、B链表结点的情况下（递增有序）,用公共元素生成新的单链表C*/
LinkList new_Cwithcommon_elem(LinkList &A,LinkList &B)
{
    LNode *C,*pa=A->next,*pb=B->next,*r,*s;
    C=(LinkList)malloc(sizeof(LNode));
    r=C;
    while(pa&&pb)
    {
        if(pa->data<pb->data)
            pa=pa->next;
        else if(pb->data<pa->data)
            pb=pb->next;
        else
        {
            s=(LNode *)malloc(sizeof(LNode));
            s->data=pb->data;
            r->next=s;
            r=r->next;
            pa=pa->next;
            pb=pb->next;
        }
    }
    r->next=NULL;
    return C;
}
/*求AB链表的交集存于A中*/
/*思想其实是和上一个算法是基本一致的！但是别忘了用完了要把剩下的非空链表也释放空间*/
LinkList inersection(LinkList &A,LinkList &B)
{
    LNode *pa=A->next,*pb=B->next,*r,*s;
    r=A;
    A->next=NULL;
    while(pa&&pb)
    {
        if(pa->data<pb->data)
        {
            s=pa;
            pa=pa->next;
            free(s);
        }
        else if(pb->data<pa->data)

        {
            s=pb;
            pb=pb->next;
            free(s);
        }
        else
        {
            r->next=pa;
            r=r->next;
            pa=pa->next;
            s=pb;
            pb=pb->next;
            free(s);
        }
    }
    if(pa)
        pb=pa;
    while(pb)
    {
        s=pb;
        pb=pb->next;
        free(s);
    }
    r->next=NULL;
    return A;
}

 （8）【来源】王道书本题16~21（除去19题 19写在循环单链表里了。）

/*两个整数序列a、b，判断b是否为a的子序列*/
/*两个链表从第一个结点开始后移指针，如果不等，a从上次比较的后继开始，b从第一个节点开始比较*/
/*如果A比较完了B没结束->失败*/

int Pattern(LinkList &A,LinkList &B)
{
    LNode *a=A->next,*pa=A,*b=B->next;
    while(a&&b)
    {
        if(a->data==b->data)
        {
            a=a->next;
            b=b->next;
        }
        else
        {
            pa=pa->next;
            a=pa->next;
            b=B->next;
        }
    }
    if(a==NULL&&b!=NULL)
        return 0;
    else return ok;
}
/*一带头结点循环单链表，节点值均为正数。设计一算法反复找出单链表中结点值最小的点，输出*/
/*直至单链表为空，最后删除头结点。*/
void del(LinkList &L)
{
    LNode *p,*pre,*pmin,*minpre;
    while(L->next!=L)
    {
        p=L->next;
        pre=L;
        minpre=L;
        pmin=p;
        while(p->next!=pre)
        {
            if(p->data<pmin->data)
            {
                pmin=p;
                minpre=pre;
            }
            pre=p;
            p=p->next;
        }
        //找到了 删除最小结点
        cout<<pmin->data<<' ';
        minpre->next=pmin->next;
        free(pmin);
    }
    free(L);
}

/*一带头结点非循环单链表，每个节点中除了pred next还有freq（访问频度）*/
/*链表启用前值均初始化为0，每链表Locate(L,x)一次，freq增一*/
/*设计算法使得链表节点保持按照访问频度递减顺序排列，最近访问节点排于同一个节点频度的前面*/
typedef struct LspNode
{
    int data,freg;/*一带头结点循环单链表，节点值均为正数。设计一算法反复找出单链表中结点值最小的点，输出*/
    /*直至单链表为空，最后删除头结点。*/
    struct LspNode *next,*prior;
} LspNode,*LinkspList;
LinkspList Locate(LinkspList &L,int x)
{
    LspNode *p,*q;
    while(p->data!=x&&p)
    {
        p=p->next;
    }
    if(!p)
    {cout<<"error"<<endl;exit(0);}//p不存在
    else
    {
        p->freg++;
        //漏掉了！把p摘掉还要对p前后结点进行处理，自己写的时候忘掉了

        q=p->prior;//递减排列，往前找第一个比他大的节点
        /*-----------*/
        p->next->prior=p->prior;
        p->prior->next=p->next;
        /*把p摘出来*/
        while(p->freg>q->freg&&q!=L)
            q=q->prior;
        //找到后插入到q的后面
        p->next=q->next;
        q->next->prior=p;
        p->prior=q;
        q->next=p;
    }
    return p;
}

/*在不改变链表前提下设计查找倒数第k个位置上的节点。查找成功输出data的值，返回1，否则返回0*/
/*一开始一起指向表头，p先移动k个结点，然后p、q一向前移动。当p到了最后一个结点时，q为倒数第k个节点。*/
/*ps:这个思路真是太聪明啦*/
int findthe_kthlast_elem(LinkList &L,int k)
{
    if(k>showlength(L)) return 0;
    LNode *p=L,*q=L;
    while(k--)
    {
        p=p->next;
    }//p先走k个结点
    while(p)
    {
        p=p->next;
        q=q->next;
    }//p走到最后的时候q为倒数第k个结点
    cout<<q->data<<endl;
    return 1;
}

链式存储的终于写完了 分了三天写

回头还是要看看 以后再来完善

写代码的时候常有“还有这种操作”的念头蹦出来

大概自己真是个鶸