王道数据结构——线性表中链表的实现与应用

1、单链表

#include <cstdio>
#include <cstdlib> 
typedef struct LNode{
    int data;
    struct LNode *next;
}LNode, *LinkList;//定义结构体和结构体指针 

/*按值查找结点*/
int LocateElem(LinkList &L, int x){
    LNode *p = L -> next;
    int cnt = 1;
    while(p){
        if(p -> data == x)
            break;
        cnt++;
        p = p -> next;
    }
    return cnt;
} 
/*按序号查找结点值,序号从0开始*/
LNode *GetElem(LinkList &L, int i){
    LNode *p = L -> next;
    if(i == 0) return L;
    if(i < 1)  return NULL;
    
    int cnt = 1;
    while(p != NULL){
        if(cnt == i)
            break;
        cnt++;//千万要记得不等时，计数要增加1啊 
        p = p->next;
    } 
    return p;
} 
/*尾插法创建单链表，需要一个总是指向尾结点的指针
返回一个指向结构体类型的指针，即链表头 
*/
LinkList CreatList2(LinkList &L){
    L = (LinkList)malloc(sizeof(LNode));
    L -> next = NULL;
    LNode *s, *r = L;
    for(int i = 0; i < 7; i++){
        s = (LNode*)malloc(sizeof(LNode));
        s->data = i;
        
        r -> next = s;//将节点s接到尾巴后面，r指向新的尾结点 
        r = s;
    }  
    r -> next = NULL;//千万要记得将尾结点的指针域置空啊 
    return L; 
}
/*头插法创建单链表*/
LinkList CreatList1(LinkList &L){
    LNode *s;
    L = (LinkList)malloc(sizeof(LNode));//创建头结点 
    L->next = NULL;//指向空 
    
    for(int i = 0; i < 7; i++){
        s = (LNode*)malloc(sizeof(LNode));
        s->data = i;
        
        s->next = L->next;//先将L的next接到s的后面，然后接头结点 
        L -> next = s;
    } 
    return L; 
}
/*依次打印元素*/
void PrintList(LinkList &L){
    LNode *p = L->next;
    while(p != NULL){
        printf("%d ", p -> data);
        p = p->next;
    }
    puts("");
}
/*计算单链表长度*/
int Length(LinkList &L){
    LNode *p = L -> next;
    int cnt = 0;
    while(p != NULL){
        cnt++;
        p = p-> next;
    }
    return cnt;
}
/*插入结点操作，将s插入到第i个位置上，也即前插操作*/
void Insert(LinkList &L, LNode *s, int i){
    int Llength = Length(L); 
    if(i < 0 || i > Llength)
        return;
    
    LNode *pre = GetElem(L, i - 1);
    s -> next = pre -> next;
    pre -> next = s;
} 
/*后插结点操作，将s插入到第i个位置之后*/
void BackInsert(LinkList &L, LNode *s, int i){
    int Llength = Length(L); 
    printf("长度是%d
", Llength);
    if(i < 0 || i > Llength)
        return;
    
    LNode *p = GetElem(L, i);//一种方法是直接获取第i个结点，插入其后，另一种是不变，交换数据域 
    s -> next = p -> next;
    p -> next = s;  
    
    /*int temp = p->data;
    p -> data = s -> data;
    s -> data = temp;*/
} 
/*删除第i个结点*/
bool DelateElem(LinkList &L, int i){
    LNode *pre = GetElem(L, i - 1);
    LNode *p = pre -> next;//先指出p,便于之后释放内存 
    pre -> next = p->next;
    free(p);
} 
int main(){
    LinkList L1;
    CreatList1(L1);
    PrintList(L1);
    printf("该链表的长度是：%d
",Length(L1)); 
    
    LinkList L2;
    CreatList2(L2);
    PrintList(L2);
    printf("该链表的长度是：%d
",Length(L2));
    
    LNode *x;
    for(int i = 1; i < 7; i++){
        x = GetElem(L2, i);
        printf("第%d个元素是%d
",i, x->data);
    }
    for(int i = 2; i < 7; i++){
        printf("存在值为%d的元素，在第%d个位置上
",i, LocateElem(L2, i));
    }
    
    LNode *s = (LNode*)malloc(sizeof(LNode));
    s -> data = 99;
    s -> next = NULL;
    Insert(L2, s, 2);
    PrintList(L2);
     
    LNode *s1 = (LNode*)malloc(sizeof(LNode));
    s1 -> data = 99;
    s1 -> next = NULL;
    //同是s的话是同一个地址，插入就是替换，涉及指针的问题 
    BackInsert(L2, s1, 3);//插入到第四个位置 
    PrintList(L2);
    
    DelateElem(L2, 2);
    DelateElem(L2, 3);
    PrintList(L2);
    return 0; 
} 

2、双链表

#include <cstdio>
#include <cstdlib> 

typedef struct LNode{
    int data;
    struct LNode *prior, *next;
}LNode, *LinkList;//定义结构体和结构体指针

/*初始化*/ 
LinkList InitList(LinkList &L){
    L = (LinkList)malloc(sizeof(LNode));
    L->data = -1;
    L->next = NULL;
    L->prior = NULL;
    return L; 
} 
/*头插法建立双链表*/
LinkList FrontList(LinkList &L){
    L = InitList(L);
    
    LNode *s;
    for(int i = 0; i < 7; i++){
        s = (LNode*)malloc(sizeof(LNode));//每次需要新的地址 
        s->data = i;
        
        s->next = L->next;
        L->next = s;
        s->prior = L;
        if(s->next != NULL)
            s->next->prior = s;
    }
    return L;
}
/*尾插法建立双链表*/
LinkList BackList(LinkList &L){
    L = InitList(L);
    LNode *s, *r = L;
    
    for(int i = 0; i < 7; i++){
        s = (LNode*)malloc(sizeof(LNode));//每次需要新的地址 
        s->data = i;
        
        r->next = s;
        s->prior = r;
        r = s;
    }
    r -> next = NULL;
    return L;
}
/*求表长*/
int Length(LinkList &L){
    LNode *p = L -> next;
    int cnt = 0;
    while(p){
        cnt++;
        p = p->next;
    }
    //L->data = cnt;
    return cnt;
}
/*按值查找元素*/
LNode *GetElem(LinkList &L, LNode *e){
    LNode *p = L->next;
    while(p && p->data != e->data){
        p = p->next;
    } 
    return p;
}
/*按序号查找元素，从1开始*/
LNode *LocateElem(LinkList &L, int x){
    int Llength = Length(L);
    if(x < 0 || x > Llength)
        return NULL;
    
    LNode *p = L->next;
    int cnt = 0;
    while(p && cnt < x){
        cnt++;
        p = p->next;
    } 
    return p;
}
/*插入，第i个位置*/
bool ListInsert(LinkList &L, LNode *s, int i){
    int Llength = Length(L);
    if(i < 0 ||i >= Llength)
        return false;
        
    LNode *p = LocateElem(L, i - 1);
    s->next = p->next;
    p->next = s;
    s->next->prior = s;
    s->prior = p;
}
/*删除*/
bool ListDelate(LinkList &L, int i, LNode &e){
    int Llength = Length(L);
    if(i < 0 ||i >= Llength)
        return false;
        
    LNode *q, *p = LocateElem(L, i - 1);
    q = p -> next;
    e.data = q -> data;
    
    p->next = q->next;
    q->next->prior = p;
    free(q);//删除的是第i个位置上的元素啊 
}
/*打印*/
void PrintList(LinkList &L){
    printf("正序为：");
    LNode *p = L; 
    LNode *p1 = NULL;
    while(p != NULL){
        printf("%d ", p->data);
        if(p->next == NULL)
            p1 = p;
        p = p -> next;
    }
    puts(""); 
    
    printf("逆序为：");
    while(p1){
        printf("%d ", p1->data);
        p1 = p1 -> prior;
    }
    puts("");
}
/*判空*/
bool Empty(LinkList &L){
    if(L->next == NULL)
        return true;
    return false;
}
/*销毁,递归释放内存*/ 
void Destory(LinkList &L, LNode *s){
    if(s == NULL){
        L->next = NULL;
        return;
    }
        
    Destory(L,s->next);
    free(s);
    s=NULL;
    //L->data--;
} 
/*销毁,非递归释放内存*/ 
void Destory2(LinkList &L){
    LNode *t,*p = L -> next;
    while(p){
        t = p -> next;
        free(p);
        L->data--;
        p = t;
    }
    L -> next = NULL;
} 

int main()
{
    LinkList L2 = BackList(L2);
    PrintList(L2);
    printf("尾插法表长为%d
", Length(L2));
    
    LinkList L = FrontList(L);
    PrintList(L);
    printf("头插法表长为%d
", Length(L));
    
    Destory(L2, L2->next);
    PrintList(L2);
    if(Empty(L2))
        printf("空表
");
        
    /*Destory2(L);
    PrintList(L);
    if(Empty(L))
        printf("空表
");*/
        
    PrintList(L);
    LNode *x = (LNode*)malloc(sizeof(LNode));
    x -> data = 3;
    x -> next = x ->prior = NULL; 
    printf("查找到值为%d的元素
", GetElem(L, x)->data);
    for(int i = 0; i < 4; i++)
        printf("查序号为%d元素的值为%d
",i, LocateElem(L, i)->data);
    
    x -> data = 99;
    ListInsert(L, x, 3);
    PrintList(L);
    
    LNode e;
    e.data = -1;
    e.next = e.prior = NULL;
    ListDelate(L, 3, e);
    printf("删除元素的值为%d
", e.data);
    PrintList(L);
    
    return 0;
}