数据结构-线性表

算法

顺序表的初始化

Status InitList(SqList &L) ///构造一个空的顺序表L{    L.elem = new ElemType[MAXSIZE]; ///为顺序表分配一个大小为MAXSIZE的数组空间    if(!L.elem) exit(OVERFLOW); ///存储分配失败退出    L.length = 0; ///空表长度为0    return OK;}

顺序表的取值

Status GetElem(SqList L, int i, ElemType &e){    if(i<1 || i>L.length) return ERROR; ///判断i值是否合理，若不合理，返回ERROR    e = L.elem[i-1]; ///elem[i-1]单元存储第i个数据元素    return OK;}

顺序表的查找

int LocateElem(SqList L, ElemType e) ///在顺序表L中查找值为e的数据元素，返回其序号{    for(i = 0; i<L.length; i++)        if(L.elem[i] == e) return i+1; ///查找成功，返回i+1    return 0; ///查找失败，返回0}

顺序表的插入

Status ListInsert(SqList &L,int i,ElemType e) ///在顺序表L中第i个位置插入新的元素e，i值得合法范围是1<=i<=L.length+1{    if((i<1)||(i>L.length+1)) return ERROR; ///i值不合法    if(L.length==MAXSIZE) return ERROR; ///当前存储空间已满    for(j=L.length-1;j>=i-1;j--) L.elem[j+1]=L.elem[j]; ///插入位置及之后的元素后移    L.elem[i-1]=e; ///将新元素e放入第i个位置    ++L.length; ///表长加1    return OK;}

顺序表的删除

Status ListDelete(SqList &L,int i) ///在顺序表L中删除第i个元素，i值的合法范围是1<=i<=L.length{    if((i<1)||(i>L.length)) return ERROR; ///i值不合法    for(j=i;j<=L.length-1;j++) L.elem[j-1]=L.elem[j]; ///被删除元素之后的元素前移    --L.length; ///表长减1    return OK;}

单链表的初始化

Status InitList(LinkList &L) ///构造一个空的单链表L{    L=new LNode; ///生成新结点作为头结点，用头指针L指向头结点    L->next=NULL; ///头结点的指针域置空    return OK;}

单链表的取值

Status GetElem(LinkList L,int i,ElemType &e) ///在带头结点的单链表L中根据序号i获取元素的值，用e返回L中第i个数据元素的值{    p=L->next; j=1; ///初始化，p指向首元结点，计数器j初值赋为1    while(p&&j<i) ///顺链域向后扫描，直到p为空或p指向第i个元素    {        p=p->next; ///p指向下一个结点        ++j; ///计数器j相应加1    }    if(!p || j>i)        return ERROR; ///i值不合法i>n或i<=0    e=p->data; ///取第i个结点的数据域    return OK;}

单链表的按值查找

LNode *LocateElem(LinkList L,ElemType e) ///在带头结点的单链表L中查找值为e的元素{    p=L->next; ///初始化，p指向首元结点    while(p&&p->data!=e) ///顺链域向后扫描，直到p为空或p所指结点的数据域等于e        p=p->next; ///p指向下一个结点    return p; ///查找成功返回值为e的结点地址p，查找失败p为NULL}

单链表的插入

Status ListInsert(LinkList &L,int i,ElemType e) ///在带头结点的单链表L中第i个位置插入值为e的新结点{    p=L;j=0;    while(p&&(j<i-1)) ///查找第i-1个结点，p指向该结点    {        p=p->next; ++j;    }    if(!p||j>i-1) return ERROE; ///i>n+1或者i<1    s=new LNode; ///生成新结点*s    s->data=e; ///将结点*s的数据域置为e    s->next=p->next; ///将结点*s的指针域指向结点ai    p->next=s; ///将结点*p的指针域指向结点*s    return OK;}

单链表的删除

Status ListDelete(LinkList &L,int i) ///在带头结点的单链表L中，删除第i个元素{    p=L;j=0;    while((p->next)&&(j<i-1)) ///查找第i-1个结点，p指向该结点    {        p=p->next; ++j;    }    if(!(p->next)||(j>i-1)) return ERROR; ///当i>n或i<1时，删除位置不合适    q=p->next; ///临时保存被删结点的地址以备释放    p->next=q->next; ///改变删除结点前驱结点的指针域    delete q; ///释放删除结点的空间    return OK;}

前插法创建单链表

void CreateList_H(LinkList &L,int n) ///逆位序输入n个元素的值，建立带表头结点的单链表L{    L=new LNode;    L->next=NULL; ///先建立一个带头结点的空链表    for(i=0;i<n;++i)    {        p=new LNode; ///生成新结点*p        cin>>p->data; ///输入元素值赋给新结点*p的数据域        p->next=L->next; L->next=p; ///将新结点*p插入到头结点之后    }}

后插法创建单链表

void CreateList_R(LinkList &L,int n) ///正位序输入n个元素的值，建立带表头结点的单链表L{    L=new LNode; L->next=NULL; ///先建立一个带头结点的空链表    r=L; ///尾指针r指向头结点    for(i=0;i<n;++i)    {        p=new LNode; ///生成新结点        cin>>p->data; ///输入元素值赋给新结点*p的数据域        p->next=NULL; r->next=p; ///将新结点*p插入尾结点*r之后        r=p; ///r指向新的尾结点*p    }}

双向链表的插入

Status ListInsert_DuL(DuLinkList &L,int i,ElemType e) ///在带头结点的双向链表L中第i个位置之前插入元素e{    if(!(p=GetElem_DuL(L,i))) ///在L中确定第i个元素的位置指针p        return ERROR; ///p为NULL时，第i个元素不存在    s=new DuLNode; ///生成新结点*s    s->data=e; ///将结点*s数据域置为e    s->piror=p->prior; ///将结点*s插入L中，    s->prior->next=s;    s->next=p;    p->prior=s;    return OK;}

双向链表的删除

Status ListDelete_DuL(DuLinkList &L,int i) ///删除带头结点的双向链表L中的第i个元素{    if(!(p=GetElem_DuL(L,i))) ///在L中确定第i个元素的位置指针p        return ERROR; ///p为NULL时，第i个元素不存在    p->prior->next=p->next; ///修改被删除结点的前驱结点的后继指针，    p->next->prior=p->prior; ///修改被删结点的后继结点的前驱指针，    delete p; ///释放被删结点的空间    return OK;}

线性表的合并

void MergeList(List &LA, List LB){//将所有在线性表LB中但不在LA中的数据元素插入到LA中    m = ListLength(LA); n = ListLength(LB);//求线性表的长度    for(i=1; i<=n; i++)    {        GetElem(LB, i, e);//取LB中第i个数据元素赋给e        if(!LocateElem(LA, e)) //LA中不存在和e相同的数据元素            ListInsert(LA, ++m, e);//将e插在LA的最后    }}

顺序有序表的合并

void MergeList_Sq(SqList LA, SqList LB, SqList &LC){//已知顺序有序表LA和LB的元素按值非递减排列 //归并LA和LB得到新的顺序有序表LC，LC的元素也按值非递减排列    LC.length = LA.length + LB.length;//新表长度为待合并两表的长度之和    LC.elem = new ElemType[LC.length];//为合并后的新表分配一个数组空间    pc = LC.elem;//指针pc指向新表的第一个元素    pa = LA.elem; pb = LB.elem;//指针pa和pb的初值分别指向两个表的第一个元素    pa_last = LA.elem + LA.length - 1;//指针pa_last指向LA的最后一个元素    pb_last = LB.elem + LB.length - 1;//指针pb_last指向LB的最后一个元素    while(pa<=pa_last && pb<=pb_last) //LA和LB均未到达表尾    {        if(*pa <= *pb) *pc ++= *pa++;//依次“摘取”两表中值较小的结点插入到LC的最后        else *pc ++= *pb++;    }    while(pa <= pa_last) *pc ++= *pa++;//LB已到达表尾，依次将LA的剩余元素插入LC的最后    while(pb <= pb_last) *pc ++= *pb++;//LA已到达表尾，依次将LB的剩余元素插入LC的最后}

链式有序表的合并

void MergeList_L(LinkList &LA, LinkList &LB, LinkList &LC){//已知单链表LA和LB的元素按值非递减排列 //归并LA和LB得到新的单链表LC，LC的元素也按值非递减排列     pa = LA->next; pb = LB->next;//pa和pb的初值分别指向两个表的第一个结点     LC = LA;//用LA的头结点作为LC的头结点     pc = LC;//pc的初值指向LC的头结点     while(pa && pb)     {//LA和LB均未到达表尾，依次“摘取”两表中值较小的结点插入到LC的最后         if(pa->data <= pb->data) //“摘取”pa所指结点         {             pc->next = pa;//将pa所指结点链接到pc所指结点之后             pc = pa;//pc指向pa             pa = pa->next;//pa指向下一个结点         }         else //“摘取”pb所指结点         {             pc->next = pb;//将pb所指结点链接到pc所指结点之后             pc = pb;//pc指向pb             pb = pb->next;//pb指向下一个结点         }     }//while      pc->next = pa?pa:pb;//将非空表的剩余段插入到pc所指结点之后      delete LB;//释放LB的头结点}

多项式的创建

void CreatePolyn(Polynomial &P, int n){//输入n项的系数和指数，建立表示多项式的有序链表P    P = new PNode;    P->next = NULL;//先建立一个带头结点的单链表    for(i=1; i<=n; ++i) //依次输入n个非零项    {        s = new PNode;//生成新结点        cin>>s->coef>>s->expn;//输入系数和指数        pre = P;//pre用于保存q的前驱，初值为头结点        q = P->next;//q初始化，指向首元结点        while(q && q->expn < s->expn) //通过比较指数找到第一个大于输入项指数的项*q        {            pre = q;            q = q->next;        }//while        s->next = q;//将输入项s插入到q和其前驱结点pre之间        pre->next = s;    }//for}

多项式的相加

void AddPolyn(Polynomial &Pa, Polynomial &Pb){//多项式加法：Pa = Pa + Pb，利用两个多项式的结点构成“和多项式”    p1 = Pa->next; p2 = Pb->next;//p1和p2初值分别指向Pa和Pb的首元结点    p3 = Pa;//p3指向和多项式的当前结点，初值为Pa    while(p1 && p2) //p1和p2均非空    {        if(p1->expn == p2->expn) //指数相等        {            sum = p1->coef + p2->coef;//sum保存两项的系数和            if(sum!=0) //系数和不为0            {                p1->coef = sum;//修改Pa当前结点的系数值为两项系数的和                p3->next = p1; p3 = p1;//将修改后的Pa当前结点链在p3之后，p3指向p1                p1 = p1->next;//p1指向后一项                r = p2; p2 = p2->next; delete r;//删除Pb当前结点，p2指向后一项            }            else //系数和为0            {                r = p1; p1 = p1->next; delete r;//删除Pa当前结点，p1指向后一项                r = p2; p2 = p2->next; delete r;//删除Pb当前结点，p2指向后一项            }        }        else if(p1->expn < p2->expn) //Pa当前结点的指数值小        {            p3->next = p1;//将p1链在p3之后            p3 = p1;//p3指向p1            p1 = p1->next;//p1指向后一项        }        else //Pb当前结点的指数值小        {            p3->next = p2;//将p2链在p3之后            p3 = p2;//p3指向p2            p2 = p2->next;//p2指向后一项        }    }//while    p3->next = p1?p1:p2;//插入非空多项式的剩余段    delete Pb;//释放Pb的头结点} 

算法设计题

（1）将两个递增的有序链表合并为一个递增的有序链表。要求结果链表扔使用原来两个链表的存储空间，不另外占用其他的存储空间。表中不允许有重复的数据。

（2）将两个非递减的有序链表合并为一个非递增的有序链表。要求结果链表扔使用原来两个链表的存储空间，不另外占用其他的存储空间，表中允许有重复的数据。