《数据结构（C语言）》苏小红课本案例

期末了，赶紧复习一波，手打一份书上的代码以便随时查阅

第二章：

//顺序表存储结构
#define MAXSIZE 100
typedef struct
{
    Elemtype *elemt;
    int   length;
}Sqlist;
Status InitList(Sqlist &L)
{
    L.elemt=new Elemtype[MAXSIZE];
    if(!L.elemt) exit(OVERFLOW);
//    L.length=MAXQSIZE;
    L.length=0;
    return OK;
}
Status GetElemt(Sqlist &L,int i,Elemtype &e)
{
    if(i<1||i>L.length) return ERROR;
//    [错了]e=L->elemt[i];
    e=L->elemt[i-1];
    return OK;
}
Status LocateElem(Sqlist &L,Elemtype e)
{
    for(i=0;i<L.length;++i)
    {
        if(L.elemt[i]==e) return i+1;
    }
    return 0;

}
//Status SearchElemt(Sqlist &L,int &j,Elemtype e)
//{
//    if(j<1||j>L.length) return ERROR;
//    for(int i=0;i<L.length;++i)
//        if(L.elemt[i]==e)
//        {
//            j=i+1;
//            return OK;
//        }
//    return ERROR;
//}
Status ListInsert(Sqlist &L ,int i,Elemtype e)
{
    if(i<1||i>L.length) return ERROR;//忘记了
    if(L.length==MAXSIZE)return ERROR;//又忘记了
    for(j=L.length-1;j>=i-1;--j)
    {
        L.elemt[j+1]=L.elemt[j];
    }
    L.elemt[i-1]=e;
    L.length++;
    return OK;
}

Status ListDelete(Sqlist &L,int i)
{
    if(i<1||i>L.length) return ERROR;//忘了
//    for(j=i-1;j<L.length-1;++j)
//    {
//        L.elemt[j]=L.elemt[j+1];
//    }
    for(j=i;j<=L.length-1;++j)
        L.elemt[j-1]=L.elemt[j];
    L.length--;
    return OK;
}
//单链表的存储
typedef struct LNode
{
    ElemType data;
    struct LNode * next;
}LNode,*Linklist;

Status InitLink(Linklist &L)
{
    L=new LNode;
//    if(!L) exit(OVERFLOW);
    L->next=NULL;
    return OK;
}
//单链表的取值
Status GetElemt(Linklist &L,int i,Elemtype &e)
{
    p=L->next;
    j=1;
    while(p&&j<i)
    {
        p=p->next;++j;
    }
    if(!p||j>i) return ERROR;
    e=p->data;
    return OK;
}
//单链表的按值查找
LNode LocateElem(Linklist &L,Elemtype e)
{
    p=L->next;j=1;
//    while(p->data!=e)
//    {
//        p=p->next;
//    }
//    return p;
    while(p&&p->data!=e)
        p=p->next;
    return p;
}
//单链表的插入
Status ListInsert(Linklist &L,int i,Elemtype e)
{
//    p=L->next;j=1;
    p=L;j=0;
    while(p&&j<i-1)
    {
        p=p->next;++j;
    }
    if(!p||j>i-1) return ERROR;
    s=new LNode;
    s->data=e;
    s->next=p->next;
    p->next=s;
    return OK;
}
//删除
Status DeleteElemt(Linklist &L,int i)
{
    p=L;j=0;
    while(p->next&&j<i-1)
    {
        p=p->next;++j;
    }
    if(!p->next||j>i-1) return ERROR;
    s=p->next;
    p->next=s->next;
    delete s;
    return OK;
}
//单链表的创建--前插
void CreateList_H(Linklist &L,int n)
{
    L=new LNode;
    L->next=NULL;
    for(i=-0;i<n;++i)
    {
        p=new LNode;
        cin>>p->data;
        p->next=L->next;
        L->next=p;
    }
}
//单链表的创建——尾插
void CreateList_T(Linklist &L,int n)
{
    L=new LNode;
    L->next=NULL;
    r=L;
    for(i=0;i<n;i++)
    {
        p=new LNode;
        cin>>p->data;
        p->next=NULL;
        r->next=p;
        r=p;
    }
}
//双向链表
typedef struct DuLNode
{
    Elemtype data;
    struct DuLNode *ptr;
    struct DuLNode *next;
}DulNode,*DuLinkList;
//双向链表的插入
Status ListInsert_Dul(DuLinkList &L，int i,Elemtype e)
{

//    p=L;j=1;
//    while(p&&j<i-1)
//    {
//       p=p->next;++j;
//    }
//    if(!p||j>i-1) return ERROR;
//
//    s=new DulNode;
//    s->data=e;
//    s->next=p->next;
//    s->ptr=p->ptr;
//    p->next->ptr=s;
//    p->next=s;
    if(!(p=GetElem_Dul(L,i)))
        return ERROR;
    s=new LNode;
    s->data=e;
    s->ptr=p->ptr;
    s->next=p;
    p->ptr->next=s;
    p->ptr=s;
    return OK;
}
//双向链表的删除
Status ListDelete_Dul(Linklist &L,int i)
{
    if(!(p=GetElemt_Dul(L,i)))
        return ERROR;
    p->next->ptr=p->ptr;
    p->ptr->next=p->next;
    delete p;
    return OK;
}

　　第三章：

#define MAXSIZE
typedef struct
{
    SElemtTpye *base;
    SElemtTpye *top;
    int stacksize;
}SqStack ;

Status InitStack(SqStack &S)
{
    S.base=new SElemtTpye[MAXSIZE];
    // [危阻]if(!S.basa)return ERROR;
    if(!S.base) exit(OVERFLOW);
    S.top=S.base;
    S.stacksize=MAXSIZE;
    return OK;
}

Status Push(SqStack &S,SElemtTpye e)
{
    if(S.top-S.base==S.stacksize) return ERROR;
    *S.top=e;
    S.top++;
    // S.stacksize++;
    return OK;
}

Status Pop(SqStack &S,SElemtTpye &e)
{
    if(S.top==S.base) return ERROR;
    S.top--;
    e=*S.top;
    // S.stacksize--;
    return Ok;
}

SElemtTpye GetTop(SqStack &S)
{
    if(S.top==S.base) return ERROR;
    // S.top--;
    // return *S.top;
    return *(S.top-1);
}
//全媚

typedef struct StackNode
{
    struct StackNode *next;
    ElemtTpye data;
}StackNode,*LinkStack;

Status InitStack(LinkStack &S)
{
    S=NULL;
    return OK;
    // S=new StackNode;
    // if(!S) return ERROR;
    // S.next=NULL;
    // return OK;
}
Status Push(LinkStack &S,ElemtTpye e)
{
    p=new StackNode;
    if(!p) return ERROR;
    p->data=e;
    p->next=S;
    S=p;
    return OK;
}

Status Pop(LinkStack &S,ElemtTpye &e)
{
    if(!S)return ERROR;
    e=S.data;
    p=S;
    S=S->next;
    delete p;//梨芝瞥慧阻
    return OK;
}

ElemtTpye GetTop(LinkStack &S)
{
    if(!S) return ERROR;
    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;
}
Status EnQueue(SqQueue &Q,Elemtype e)
{
    if((Q.rear+1)%MAXQSIZE==Q.front) return ERROR;
    Q.base[Q.rear]=e;
    Q.rear=(Q.rear+1)%MAXQSIZE;
    return OK;
}

Status DeQueue(SqQueue &Q,Elemtype &e)
{
    if(Q.rear==Q.front) return ERROR;
    e=Q.base[Q.front];
    Q.front=(Q.front+1)%MAXQSIZE;
    return OK;
}

Elemtype GetTop(SqQueue &Q)
{
    if(Q.front==Q.base) return ERROR;
    return Q.base[Q.front];
}
//全錦
typedef struct QNode
{
    Elemtype data;
    struct QNode *next;
}QNode,*QueuePtr;
typedef struct
{
    QueuPtr front;
    QueuePtr rear;
}*LinkQueue;

Status InitQueue(LinkQueue &Q)
{
    Q.front=Q.rear=new QNode;
    Q.front->next=NULL;
    return OK;
}

Status EnQueue(LinkQueue &Q,Elemtype e)
{
    p=new QNode;
    p->data=e;
    p->next=NULL;
    Q.rear->next=p;
    Q.rear=p;
    return OK;
}
Status DeQueue(LinkQueue &Q,Elemtype &e)
{
    if(Q.front==Q.rear)return ERROR;
    p=Q.front->next;
    e=p->data;
    Q.front->next=p->next;
    if(p==Q.rear) Q.rear=Q.front;
    delete p;
    return OK;
}

　　第四章：

//串的顺序定义
#define MAXSIZE 100
typedef struct
{
    char ch[MAXSIZE];
    int length;
}SString;
//串的链式定义--完全没记住Orz
//typedef struct a
//{
//    char ch[MAXQSIZE];
//    int length;
//    struct a * next;
//}*c;
//typedef struct
//{
//    c
//}LString;
#define CHUNKSIZE 100
typedef struct Chunk
{
    char ch[CHUNKSIZE];
    struct Chunk * next;
}Chunk;
typedef struct
{
    Chunk *head,*tail;
    int length;

}LString;

《数据结构（C语言）》苏小红 课本案例

第二章：

第三章：

第四章：

猜你喜欢

《数据结构（C语言）》苏小红课本案例

　　第三章：

　　第四章：