考试提纲---草我是菜鸡

不会真的不会

SqList

1. init

/*
    SqList{
        ElemType* elem;
        int len;
        int size;
    }
 */
Status InitList(SqList &l){
    l.elem = (ElemType*)malloc(sizeof(ElemType) * INIT_VALUE);
    if(!l.elem) return ERR;
    l.len = 0;
    l.size = INIT_VALUE;
    return OK;
}

2. insert

Status Insert(SqList &l,int i,ElemType e){
    if (i < 1 || i >l.len + 1)return ERR;
    if(l.len > l.size){
        newbase = (ElemType*)realloc(l.elem,(l.size*2)*sizeof(ElemType));// *2 extend
    }
    if (!newbase)return ERR;
    l.elem = newbase;
    l.size = l.len*2;

    ins_pos = &l.elem[i-1];
    for(p=&(l.elem[l.len-1]); p >= ins_pos;--p){
        *(p+1) = *p;// move
    }
    *ins_pos = e;
    ++l.len;
    return OK;
}

3. delete

Status Delete(SqList &l,int i,ElemType &e){
    if (i<1||i>l.len)return ERR;

    del_pos = &(l.elem[i-1]);

    e = *del_pos;

    q = l.elem + l.len - 1;// the last pos

    for(++del_pos;del_pos < q;++del_pos){
        *(p-1) = *p;
    } 
    --l.len;
    return OK;
}

4. getelem

int LocateElem(SqList l,ElemType e,Status(*cmp)(ElemType,ElemType)){
    i = 1;
    p= l.elem;
    while(i <= l.len && !(*cmp)(*p++,e)){
        ++i;
    }
    if(i <= l.len)return i;
    else return -1;
}

linkedlist

1. get

/*
    typedef struct LNode{
        ElemType data;
        struct LNode *next;
    }LNode,*LinkList; 
*/
Status GetElem(LinkList l,int i,ElemType &e){
    p = l->next;
    j = 1;
    while(p&&j<i){
        p=p->next;
        ++j;
    }
    if (!p || j>i)return ERR;
    e = l->data;
    return OK;
}

2. insert

Status Insert(LinkList &l,int i,ElemType e){
    p = l;
    j = 0;
    while(p && j < i-1){
        p=p->next;
        ++j;
    }
    if(!p||p>i-1)return ERR;
    tmp=(LinkList)malloc(sizeof(LNode));
    tmp->data = e;
    tmp->next = p->next;
    p->next = tmp;
    return OK;
}

3. delete

Staus Delete(LinkList &l,int i,ElemType &e){
    p=l;
    j=0;
    while(p->next&&j<i-1){
        p=p->next;
        ++j;
    }
    if(!p||j>i-1)return ERR;
    to_del=p->next;
    p->next = to_del->next;
    e = to_del->data;
    free(to_del);
    return OK;
}

stack

1. ops

/*
typedef struct Stack{
    ElemType *base;
    ElemType *top;
    int size;
}SqStack;
*/
Status Init(SqStack &s){
    s.base = (ElemType*)malloc(INIT_VALUE * sizeof(ElemType));
    if(!s.base)return ERR;
    s.top = s.base;
    s.size = INIT_VALUE;
    return OK;
}

Status GetTop(SqStack s,ElemType &e){
    if(s.top == s.base)return ERR;
    e = *(s.top-1);
    return OK;
}

Status Push(SqStack &s,ElemType e){
    if(s.top-s.base >= s.size){
        s.base = (ElemType*)realloc(s.base,sizeof(ElemType)*s.size*2);// x 2
        if(!s.base)return ERR;
        s.top = s.base + s.size;
        s.size = s.size * 2;   
    }
    *s.top++ = e;// assign then ++
    return OK;
}
Status Pop(SqStack &s,ElemType &e){
    if(s.top == s.base)return ERR;
    e = *--s.top;
    return OK;
}

queue

1. ops

typedef struct QNode{
    ElemType data;
    struct QNode *next;
}QNode,*QueuePtr;
typedef struct {
    QueuePtr f;
    QueuePtr r;
}LinkQueue;

Status Init(LinkQueue &q){
    q.f = q.r = (QueuePtr)malloc(sizeof(QNode));
    if(!q.f)return ERR;
    q.f->next = NULL;
    return OK;
}

Status Destory(LinkQueue &q){
    while(q.f){
        q.r = q.f->next;
        free(q.f);
        q.f = q.r;
    }
    return OK;
}

Status Enq(LinkQueue &l,ElemType e){
    p=(QueuePtr)malloc(sizeof(QNode));
    if(!p)return ERR;

    p->data = e;
    p->next = NULL;
    q.r->next = p;// add to rear next
    q.r = p;// q.r ptr to p
    return OK:
}

Status Deq(LinkQueue &q,ElemType &e){
    if(q.f==q.r)return ERR;

    to_del = q.f->next;
    e = to_del->data;
    q.f->next = to_del->next;
    if(q.r == to_del){
        q.r = to_del.f;
    }
    free(q);
    return OK;
}

2. ops SqQueue

typedef struct {
    ElemType *base;
    int f;
    int r;
}SqQueue;
Status Init(SqQueue &q){
    q.base = (ElemType*)malloc(INIT_VALUE * sizeof(ElemType));
    if !q.base {
        return ERR;
    }

    q.f = q.r = 0;
    return OK:
}

Status Enq(SqQueue &q,ElemType e){
    if(q.r + 1) % INIT_VALUE == q.f {
        return ERR;
    }

    q.base[q.r] = e;
    q.r = (q.r + 1)%INIT_VALUE;// ops on q.r when enq
    return OK;
}


Status Deq(SqQueue &q,ElemType &e){
    if q.f == q.r {
        return ERR;
    }
    e = q.base[q.f];
    q.f = (q.f+1)%INIT_VALUE;// ops on q.f when deq
    return OK;
}

bin tree

1. ops for traverse

Status PreOrder(BiTree t, Status (*visit)(ElemType e))
{
    Status Print_Elem(ElemType e)
    {
        printf(e);
        return OK;
    }

    if (t)
    {
        if (visit(t->data))
        {
            if (PreOrder(t->lchild, visit))
            {

                if (PreOrder(t->rchild, visit))
                {
                    return OK;
                }
            }
        }
        return ERR;
    }
    else
        return OK;
}

Status Inorder_no_recur(BiTree t, Status (*visit)(ElemType e))
{
    InitStack(s);
    Push(s, t);

    while (!StackEmpty(s))
    {
        while (GetTop(s, p) && p)
        {
            Push(s, p->lchild);
        }
        Pop(s, p); // once push to stack , make pop
        if (!StackEmpty(s))
        {
            Pop(s, p);
            if (!visit(p->data))
            {
                return ERR;
            }
            Push(s, p->rchild);
        }
    }
}
return OK;

DFS BFS

查找

• BST

BiTre SearchBST(BiTree t,target)
{
    if(!t){
        EQ(target,t->data.key)return t;
    }else if LT(target,t->data.key) return SearchBST(t.lchild,target);// to find the left side
    else return SearchBST(t.rchild,target);
}

排序

• quick sort

int Partition(SqList &l,int low,int high){
    l.r[0] = l.r[low];
    standard = l.r[low].key;// value of standard
    while(low < high){
        while(low < high && l.r[high].key >= standard){
            --high;
        }
        while(low < high && l.r[low].key <= standard){
            ++low;
        }
        l.r[high] = l.r[low];
    }
    l.r[low] = l.r[0];
    return low;
}

void QSort(SqList &l,int low,int high){
    if(low<high){
        standard_loc = Partition(l,low,high);
        QSort(l,low,standard_loc - 1);
        QSort(l,standard_loc+1,high);
    }
}

• insert sort
• heap sort