线性表

栈&队列

串

二叉树

持续更新中，尽请期待！！！

300多行，码字不易，点个赞吧！！！

#include <bits/stdc++.h>
using namespace std;
#define ElemType int
#define Status int

typedef struct LNode{
   
    ElemType data;
    struct LNode *next;
} * Link, *Position;

typedef struct{
   
    Link head, tail;
    int len;
} LinkList;

Status MakeNode(Link &p, ElemType e){
   
    //分配一个p指向的值为e的节点，并返回OK；如果分配失败，则error
    p = new LNode;
    p->data = e;
    if(p)
        return 1;
    else
        return 0;
}

void FreeNode(Link &p){
   
    //释放p指向的节点
    delete p;
    p = NULL;
}

Status InitList(LinkList &L){
   
    //初始化一个已经声明链表L
    L.head = new LNode;
    L.head->next = NULL;
    L.tail = L.head;
    L.len = 0;
    if(L.head){
   
        cout << "初始化成功"<<endl;
        return 1;
    }else
        return 0;
}

Status DestroyList(LinkList &L){
   
    //销毁一个链表L
    ClearList(L);
    delete L.head;
    L.head = NULL;
    L.tail = NULL;
    if(!L.head)
        return 1;
    else
        return 0;
}

Status ClearList(LinkList &L){
   
    //将当前链表L清空，变成一个初始状态的链表
    Link p = L.head->next;
    while(p){
   
        L.head->next = p->next;
        delete p;
        p = NULL;
        L.len--;
        p = L.head->next;
    }
    if(L.head->next==NULL){
   
        return 1;
    }else
        return 0;
}

Status InsFirst(Link h, Link s){
   
    //在头节点位置插入一个新的节点,h指向头，s指向新的节点
    s->next = h->next;
    h->next = s;
    return 1;
}
Status DelFirst(Link h, Link &q){
   
    //将头节点删除
    q = h->next;
    if(q){
   
        h->next = q->next;
        return 1;
    }else
        return 0;
}
Status Append(LinkList &L, Link s){
   
    //向链表内插入数据，s以后的一个或若干个节点插入链表的尾部
    //并修改链表的tail指针
    L.tail->next = s;
    while (L.tail->next!=NULL){
   
        L.len++;
        L.tail = L.tail->next;
    }
    return 1;
}
Status Remove(LinkList &L, Link &q){
   
    //删除链表尾节点元素，由q返回
    if(!L.head){
   
        cout << "线性链表不存在" << endl;
        return 0;
	}
    q = L.head;
    while(q->next!=L.tail){
   
        q = q->next;
    }
    L.tail = q;
    q = q->next;
    L.tail->next = NULL;
    L.len--;
	delete q;
    q = NULL;
    return 1;
}
Status InsBefore(LinkList &L, Link &p, Link s){
   
    //将元素插入由p指定的位置的前一个位置,并修改p指向新的节点
    Link q = L.head;
    if(!L.head){
   
        cout << "线性链表不存在" << endl;
        return 0;
    }
	while(q->next!=p){
   
        q = q->next;
    }
    q->next = s;
    s->next = p;
    p = s;
    L.len++;
	return 1;
}
Status InsAfter(LinkList &L, Link &p, Link s){
   
    //将元素插入由p指定位置的下一个位置，并修改p指向新节点
    if(!L.head){
   
        cout << "线性链表不存在" << endl;
        return 0;
    }
    s->next = p->next;
    p->next = s;
    if(p==L.tail)
        L.tail = L.tail->next;
    p = s;
    L.len++;
	return 1;
}
Status SetCurElm(Link &p, ElemType e){
   
    //修改当前指针p指向的元素的数据域的值为e
    p->data = e;
    return 1;
}
ElemType GetCurElem(Link p){
   
    //获取当前指针p指向的元素的数据域的值，以e返回
    return p->data;
}
Status ListEmpty(LinkList L){
   
    if(!L.head){
   
        cout << "线性链表不存在" << endl;
        return 0;
    }
    if(L.head->next==NULL)
        return 1;
    else
        return 0;
}
int ListLength(LinkList L){
   
    if(!L.head){
   
        cout << "线性链表不存在" << endl;
        return 0;
	}
	return L.len;
}
Position GetHead(LinkList L)
{
   
    //返回链表当中头节点的位置
    if(!L.head){
   
        cout << "线性链表不存在" << endl;
        return 0;
	}
	return L.head;
}
Position GetLast(LinkList L)
{
   
    //返回链表当中最后一个节点的位置
    if(!L.head){
   
        cout << "线性链表不存在" << endl;
        return 0;
    }
	return L.tail;

}
Position PriorPos(LinkList L, Link p)
{
   
    //由当前p指向的位置，查找p的邻接前一个节点的位置
    Link q = L.head;
    if(!L.head){
   
        cout << "线性链表不存在" << endl;
        return 0;
	}
	if(p==L.head)
		return NULL;
	while(q->next!=p){
   
        q = q->next;
    }
	return q;
}
Position NextPos(LinkList L, Link p)
{
   
    //由当前p指向的位置，查找p的下一个邻接元素的位置
    if(!L.head){
   
        cout << "线性链表不存在" << endl;
        return 0;
    }
	if(p==L.tail)
		return NULL;
    return p->next;
}
Status LocatePos(LinkList L,int i,Link &p)
{
   
    //获取当前链表内第i个元素的位置，如果i不存在，则ERROR
    int j = 0;
    Link pt = L.head;
    while(pt&&j<i)
	{
   
        pt = pt->next;
        j++;
	}
	if(!pt||j>i)
		return 0;
	else{
   
		p=pt;
		return 1;
    }
}

Status compare(ElemType x,ElemType y)
{
   
	if(x==y)
		return 1;
	else
		return 0;
}
Position LocateElem(LinkList L,ElemType e,Status (*compare)(ElemType,ElemType)){
   
    Link q = L.head->next;
    while(q->next!=NULL)
	{
   
		if(compare(q->data,e))
			return q;
        q = q->next;
    }
	return NULL;
}

Status visit(ElemType x)
{
   
    cout << x << " ";
    return 1;
}
Status ListTraverse(LinkList L,Status(*visit)(ElemType))
{
   
    Link q = L.head->next;
    while(q)
	{
   
		if(visit(q->data))
            q = q->next;
        else
			return 0;
	}
    return 1;
}


//算法2.20
Status ListInsert_L(LinkList &L,int i,ElemType e){
   
    Link h,s;
    if(!LocatePos(L,i-1,h))
        return 0;
    if(!MakeNode(s,e))
        return 0;
    InsFirst(h, s);
    return 1;
}

//算法2.21
Status MergeList_L(LinkList &La,LinkList &Lb,LinkList &Lc,int (*compare)(ElemType,ElemType)){
   
    if(!InitList(Lc))
        return 0;
    Link ha, hb, pa, pb, q;
    ha = GetHead(La);
    hb = GetHead(Lb);
    pa = NextPos(La, ha);
    pb = NextPos(Lb, hb);
    while(pa&&pb){
   
        ElemType a, b;
        a = GetCurElem(pa);
        b = GetCurElem(pb);
        if((*compare)(a,b)<=0){
   
            DelFirst(ha, q);
            Append(Lc, q);
            pa = NextPos(La, ha);
        }else{
   
            DelFirst(hb, q);
            Append(Lc, q);
            pa = NextPos(Lb, hb);
        }
    }
    if(pa)
        Append(Lc, pa);
    else
        Append(Lc, pb);
    FreeNode(ha);
    FreeNode(hb);
    return 1;
}