青岛大学数据结构王卓笔记（每天有空会更新）

#include<iostream>
using namespace std;
#define MAXSIZE 100
#define true 1
#define false 0
#define OK 1
#define ERROR -1
#define OVERFLOW -2
#define return exit
typedef int Status;
typedef char ElemType ;

typedef struct{
    ElemType *elem;
    int Length;
}SqList;
Status InitList_Sq(SqList &L)
{
    L.elem=new ElemType[MAXSIZE];
    if(!L.elem)
    exit OVERFLOW;
    L.Length=0;
    return OK;
}
void DestroyList(SqList &L)
{
    if(L.elem)
    delete L.elem;
}
void ClearList (SqList &L)
{
    L.Length=0;
}
int IsEmpty(SqList L)
{
    if(L.Length==0)
    return 1;
    
    return 0; 
}
int GetElem(SqList L,int i,ElemType &e)
{
    if(i<1||i>L.Length)
    return ERROR;
    e=L.elem[i-1];
    return OK;
    //算法复杂度O(1) 
}
int LocateElem(SqList L,ElemType e)
{
    for(int i=0;i<L.Length;i++)
    {
        if(L.elem[i]==e)
        return i+1;
        return 0;
    }
    //算法复杂度O(n) 
    //ASL 算法平均复杂度     
}
Status ListInsert_Sq(SqList &L,int i,ElemType e)
{
    if(i<1||i>L.Length+1)
    return ERROR;
    if(L.Length==MAXSIZE)
    return ERROR;//当前存储空间已满
    for(int j=L.Length-1;j>=i-1;j--)
    {
        L.elem[j+1]=L.elem[j];
        
     } 
    L.elem[i-1]=e;
 } 
Status ListDelete_Sq(SqList &L,int i)
{
    if(i<1||(i>L.Length))
    return ERROR;
    for(int j=i;j<=L.Length-1;j++)
    {
        L.elem[j-1]=L.elem[j];
        
    }
    L.Length--;
    return OK;    
    //算法复杂度 O(n) 
}
//typedef struct Lnode
//{
//    ElemType data;
//    struct Lnode *next;
//}Lnode,*LinkList;
//LinkList为指向结构体Lnode的指针类型
//定义链表L：LinkList L;
//定义结点指针p：LNode *p 或者 LinkList p;
//typedef struct student
//{
//    char num[8];
//    char name[8];
//    int score;
//}ElemType;
typedef struct Lnode
{
    ElemType data;
     struct Lnode *next;
}Lnode,*LinkList;
Status InitList_L (LinkList &L)
{
    L=new Lnode;
    L->next=NULL;
    return OK;
}
int ListEmpty(LinkList &L)
{
    if(L->next)
    return 0;
    
    return 1;
}
Status DestroyList_L (LinkList &L)
{
    Lnode *p;
    while(L)
    {
        p=L;
        L=L->next;
        delete p;
    }
}
Status ClearList(LinkList &L)
{
    Lnode *p,*q;
    p=L->next;
    while(p)
    {
        q=p->next;
        delete p;
        p=q;
    }
    L->next=NULL;//头节点指针域为空 
    return OK;
}
int  ListLength_L(LinkList L)
{
    LinkList p;
    p=L->next;
    int i=0;
    while(p)
    {
        i++;
        p=p->next;
    }
}
Status GetElem_L(LinkList L,int i,ElemType &e)
{
    LinkList p;
    p=L->next;
    int j=1;
    while(p&&j<i)
    {
        p=p->next;
        ++j;
        
    }
    if(!p||j>i)
    return ERROR;
    e=p->data;
    return OK;
    
}
Lnode *LocateElem_L(LinkList L,ElemType e)
{
    Lnode* p;
    p=L->next;
    while(p&&p->data!=e)
    p=p->next;
    return p;
}//O(n)
Status ListInsert_L(LinkList &L,int i,ElemType e)
{
    Lnode *p;
    p=L;
    int j=0;
    while(p&&j<i-1)
    {
        p=p->next;
        ++j;
        
    }
    if(!p||j>i-1)
    {
        return ERROR;
    }
    Lnode* s=new Lnode;
    s->data=e;
    s->next=p->next;
    p->next=s;
    return OK;    
} //O(n)
Status ListDelete_L(LinkList &L,int i,ElemType &e)
{
    Lnode* p=L;
    Lnode* q;
    
    int j=0;
    while(p->next&&j<i-1)
    {
        p=p->next;
        ++j;
    }
    if(!(p->next)||j>i-1)
    return ERROR;
    q=p->next;
    p->next=q->next;
    e=q->data;
    delete q;
    return OK;
}//O(n)
void CreateList_H(LinkList &L,int n)
{
    L=new Lnode;
    L->next=NULL;
    for(int i=n;i>0;i--)
    {
        Lnode *p=new Lnode;
        cin>>p->data;
        p->next=L->next;
        L->next=p;
        
    }
}//头插法
void CreateList_R(LinkList &L,int n)
{
    L=new Lnode;
    L->next=NULL;
    Lnode*r=L;
    for(int i=0;i<n;++i)
    {
        Lnode *p=new Lnode;
        cin>>p->data;
        p->next=NULL;
        r->next=p;
        r=p;
    }
}//尾插法 

LinkList Connect (LinkList Ta,LinkList Tb)
{
    p=Ta->next;//p存表头结点 
    Ta->next=Tb->next->next;//Tb表头连结Ta表尾 
    delete Tb->next;//释放Tb表头结点 
    Tb->next=p;//修改指针 
    return Tb;
}//带尾指针循环链表的合并
typedef struct DuLNode{
    ElemType data;
    struct DuLNode *prior,*next;
    
}DuLNode,*DuLinkList;
void ListInsert_DuL(DuLinkList &L,int i.ElemType e)
{
    if(!(P=GetElemP_DuL(L,i)))
    return ERROOR;
    s=new DuLNode;
    s->data=e;
    s->prior=p->prior;
    p->prior->next=s;
    s->next=p;
    p->prior=s;
    return OK;
}//双向链表的插入
 void ListDelte_DuL(DuLink &L,int i,ElemType &e)
 {
     if(!(p=GetElemP_DuL(L,i)))
     return ERROR;
     e=p->data;
     p->prior->next=p->next;
     p->next->prior=p->prior;
     free(p);
     return OK;
 }//双向链表的删除
 void union(List &La,List Lb)
 {
     La_len=ListLength(La);
     Lb_len=ListLength(Lb);
     for(i=1;i<=Lb_len;i++)    
     {
         GetElem(Lb,i,e);
         if(!(LocateElem(La,e)))
         ListInsert(&La,++La_len,e);
     }
     
  } 
void MergeList_Sq(SqList LA,SqList Lb,SqList &LC)
{
    pa=LA.elem;
    pb=LB.elem;//指针pa,pb初值分别指向两个表的第一个元素 
    LC.length=LA.length+LB.length;
    LC.elem=new ElemTYpe[LC.Length];
    pc=LC.elem;//指针pc指向新表的第一个元素 
    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)
    {
        if(*pa<=*pb)
        *pc++=*pa++;    
    }
    while(pa<=pa_last)
    *pc++=*pa++;
    while(pb<=pb_last)
    *pc++=*pb++;
}
void MergeList_L(LinkList &La,LinkList &Lb,LinkList &Lc)
{
    pa=La->next;
    pb=Lb->next;
    pc=Lc=La;
    while(pa&&pb)
    {
        if(pa->data<=pb->data)
        {
            pc->next=pa;
            pc=pa;
            pa=pa->next;
        }
        else
        {
            pc->next=pb;
            pc=pb;
            pb=pb->next;
        }
        
    }
    pc->next=pa?pa:pb;
    delete Lb;
}
void CreatePolyn(Polynomial &P,int n)
{
    P=new PNode;
    P->next=NULL;
    for(i=1;i<=n;++i)
    {
        s=new PNode;
        cin>>s->coef>>s->expn;
        pre=P;
        q=P->next;
        while(q&&q->expn<s->expn)
        {
            pre=q;
            q=q->next;
        }
        s->next=q;
        pre->next=s;
    }
}
#define MAXSIZE 1000
typedef struct{
    SElemType *base;
    SElemType *top;
    int stacksize;
}SqStack;
Status InitStack(SqStack &S)
{
    S.base=new SElemType[MAXSIZE];
    if(!S.base)
    exit(OVERFLOW);
    S.top=S.base;
    S.stacksize=MAXSIZE;
    return OK;
}
Status StackEmpty(SqStack S)
{
    if(S.top==S.base)
    return TRUE;
    else
    return FALSE;
}
int StackLength(SqStack S)
{
    return S.top-S.base;
}
Status ClearStack(SqStack S)
{
    if(S.base)
    S.top=S.base;
    return OK;    
}
Status DestroyStack(SqStack &S)
{
    if(S.base)
    {
        delete S.base;
        S.stacksize=0;
        S.base=S.top=NULL;
    }
    return OK;
}
Status Push (SqStack &S,SElemType e)
{
    if(S.top-S.base==S.stacksize)
    return     ERROR;
    *S.top++=e;
    return OK;
}
Status Pop (SqStack &S,SElemType &e)
{
    if(S.top==S.base)
    {
        return ERROR;
    }
    e=*--S.top;
    return OK;
}
typedef struct StackNode{
    SElemType data;
    struct StsckNode *next;
}stackNode,*LinkStack;//链栈 
LinkStack S;
void InitStack(LinkStack &S)
{
    S=NULL;
    return OK;
 } 
Status StackEmpty(LinkStack S)
{
    if(S==NULL)
    {
        return TRUE;
    }
    else
    return FALSE;
}
Status Push(LinkStack &S,SElemType e)
{
    p=new StackNode;
    p->data=e;
    p->next=S;
    S=p;
    return OK;
}
Status Pop(LinkStack &S,SElemType &e)
{
    if(S==NULL)
    return ERROR;
    e=S->data;
    p=S;
    S=S->next;
    delete p;
    return OK;
}
SElemType GetTop(LinkStack S)
{
    if(S!=NULL)
    {
        return S->data;
    }
}
#define MAXQSIZE 100
typedef struct{
    QElemType *base;
    int front;
    int rear;
}SqQueue;
Status InitQueue(SqQueue &Q)
{
    Q.base=new QElemType[MAXQSIZE];
    if(!Q.base)
    exit(OVERFLOW);
    Q.front=Q.rear=0;
    return OK;
}
int QueueLength(SqQueue Q)
{
    return ((Q.rear-Q.front+MAXSIZE)%MAXSIZE);
}
Status EnQueue(SqQueue &Q,QElemType e)
{
    if((Q.rear+1)%MAXSIZE==Q.front)
    return ERROR;
    Q.base[Q.rear]=e;
    Q.rear=(Q.rear+1)%MAXSIZE;
    return OK;
}//循环队列入队
 Status DeQueue(SqQueue &Q,QElemmType &e)
 {
     if(Q.front==Q.rear)
     return ERROR;
     e=Q.base[Q.front];
     Q.front=(Q.front+1)%MAXSIZE;
     return     OK;
     
 }
 SElemType GetHead(SqQueue Q)
 {
     if(Q.front!=Q.rear)
     return Q.base[Q.front];
 }
 #define MAXSIZE 100
 typedef struct Qnode{
QElemType data;
struct Qnode *next;
 }QNode,*QueuePtr;
 typedef struct{
     QueuePtr front;
     QueuePtr rear;
 }LinkQueue;
 Status InitQueue(LinkQueue &Q)
 {
     Q.front=Q.rear=new Qnode;
     
 }
Status DestroyQueue(LinkQueue &Q)
{
    while(Q.front)
    {
        p=Q.front->next;
        free(Q.front);
        Q.front=p;
        //Q.rear=Q.front->next;free(Q.front);Q.front=Q.rear;
    }
    return OK;
}
Status EnQueue(LinkQueue &Q,QElemType e)
{
    p=(QueuePtr)malloc(sizeof(QNode));
    if(!p)
    exit(OVERFLOW);
    p->data=e;
    p->next=NULL;
    Q.rear->next=p;
    Q.rear=p;
    return     OK;
}
Status DeQueue(LinkQueue &Q,QElemType &e){
    if(Q.front==Q.rear)
    return ERROR;
    p=Q.front->next;
    e=p->next;
    Q.front->next=p->next;
    if(Q.rear==p)
    Q.rear=Q.front;
    delete p;
    return OK;
    
}
Status GetHead(LinkQueue Q,QElemType &e)
{
    if(Q.front==Q.rear)
    return ERROR;
    e=Q.front->next->data;
    return OK;
}