链表

#include
#include
using namespace std;

#define ElemType int
// 单链表
// 单链表节点类型
typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;

// 头插法建立单链表
LinkList List_HeadInsert(LinkList &L){  // 逆向建立单链表
    LNode *s;
    int x;
    L=(LinkList)malloc(sizeof(LNode));
    L->next=NULL;
    cin>>x;
    while(x!=9999){
        s=(LNode*)malloc(sizeof(LNode));
        s->data=x;
        s->next=L->next;
        L->next=s;
        cin>>x;
    }
    return L;
}

// 尾插法建立单链表
LinkList List_TailInsert(LinkList &L){  //正向建立单链表
    int x;
    L=(LinkList)malloc(sizeof(LNode));
    LNode *s,*r=L;                      //r为表尾指针
    cin>>x;
    while(x!=9999){
        s=(LNode*)malloc(sizeof(LNode));
        s->data=x;
        r->next=s;
        r=s;
        cin>>x;
    }
    r->next=NULL;
    return L;
}

// 顺序输出单链表
void List_Output(LinkList L){
    if(L->next==NULL){
        cout<<"LinkList is NULL"<<endl;
    }
    L=L->next;
    while(L!=NULL){
        cout<<L->data<<" ";
        L=L->next;
    }cout<<endl;
}

// 按序号查找节点值
LNode *GetElem(LinkList L,int i){
    int t = 1;
    LNode *p=L->next;
    if(i==0)
        return L;
    if(i<1)
        return NULL;
    while(p&&t<i){
        p=p->next;
        t++;
    }
    return p;
}

// 按值查找表节点
LNode *LocateElem(LinkList L,ElemType e){
    LNode *p=L->next;
    while(p!=NULL && p->data!=e)
        p=p->next;
    return p;
}

// 插入节点操作
void Insert_PreLNode(LinkList &L,ElemType i,LNode *e){  // 后插
    LNode *p;
    p = GetElem(L,i-1);
    e->next = p->next;
    p->next = e;
}

void Insert_LastLNode(LinkList &L,ElemType i,LNode *e){  // 前插
    LNode *p;
    p = GetElem(L,i);
    e->next = p->next;
    p->next = e;
    swap(e->data,p->data);  //前插+交换数据域
}

// 删除节点操作
void Delete_NowLNode(LinkList &L,ElemType i){ // 直接删除目标节点
    LNode *p,*q;
    p = GetElem(L,i-1);
    q = p->next;
    p->next=q->next;
    free(q);
}

void Delete_LastLNode(LinkList &L,ElemType i){ // 将后继节点的值赋给目标节点，删除后继节点
    LNode *p,*q;
    p = GetElem(L,i);
    q = p->next;
    p->data = q->data;
    p->next = q->next;
    free(q);
}


// 双链表
// 双链表的节点类型
typedef struct DNode{
    ElemType data;
    struct DNode *prior,*next;
}DNode,*DLinkList;

// 双链表的插入操作
void Insert_DNode(DLinkList &L,DNode *e){
    // 步骤4一定在步骤1，2前面
    DNode *p;
    e->next=p->next;        // 1
    p->next->prior=e;       // 2
    e->prior=p;             // 3
    p->next=e;              // 4
}

// 双链表的删除操作
void Delete_DNode(DLinkList &L,DNode *e){
    DNode *p,*q;
    p->next = q->next;
    q->next->prior = p;
    free(q);
}

// 循环链表


// 循环双链表


// 静态链表
// 静态链表的结构类型
#define Maxsize 50
typedef struct{
    ElemType data;
    int next;
}SLinkList[Maxsize];

int main()
{
    /*// 单链表
    LinkList L;
    LNode *e=(LNode*)malloc(sizeof(LNode));
    e->data = 0;
    // List_HeadInsert(L);     //头插法建立单链表
    List_TailInsert(L);     //尾插法建立单链表
    // Insert_PreLNode(L,3,e);  // 前插法插入节点
    // Insert_LastLNode(L,3,e);     //后插法插入节点
    // Delete_NowLNode(L,3);
    Delete_LastLNode(L,3);
    List_Output(L);
    // cout<<"asdf"<
    
    // 双链表

    return 0;
}