【数据结构】线性表——链表


知识框架

在这里插入图片描述


单链表

#include <iostream>
using namespace std;
/**
 * 1.单链表的定义
 */
 typedef struct LNode{
     int data;
     struct LNode *next;
 }LNode,*LinkedList;

 /**
  * 2.单链表的两种实现方式:不带头结点和带头结点
  */

 //2.1不带头结点

 //初始化一个空的单链表
 bool InitList2(LinkedList &L){
     L = NULL; // 空表,暂时没有任何结点:防止脏读数据
     return true;
 }
 //判断单链表是否为空
 bool Empty2(LinkedList L){
     return L==NULL;
 }

 //2.2带头结点

//初始化一个空的单链表
 bool InitList(LinkedList &L){
     L = (LNode *) malloc(sizeof (LNode));//分配一个头结点
     if (L==NULL){ //内存不足,分配失败
         return false;
     }
     L->next = NULL; //头结点暂时没有结点
     return true;
 }

//判断单链表是否为空
bool Empty(LinkedList L){
    return L->next == NULL;
 }

 /**
  * 3.单链表的插入
  */

 //【指定结点的后插操作】代码重构:插入操作大多都包括 在p结点后插入元素e,,可以单独封装成一个函数
 bool InsertNextNode(LNode *p,int e){
     if (p == NULL){
         return false;
     }
     LNode *s = (LNode *) malloc(sizeof (LNode));
     if (s == NULL){ // 分配内存失败
         return false;
     }
     s->data = e;
     s->next = p->next;
     p->next = s;
     return true;
 }
 //【指定结点的前插操作】
 bool InsertPriorNode(LNode *p,int e){
     if (p == NULL){
         return false;
     }
     LNode *s = (LNode *) malloc(sizeof (LNode));
     if (s == NULL){
         return false;
     }
     s->next = p->next;
     p->next = s;
     s->data = p->data;
     p->data = e;
     return true;
 }

 //3.1按位序插入(带头结点):在第i个位置插入元素e
 bool ListInsert(LinkedList &L,int i,int e){
     if (i < 1){
         return false;
     }
     LNode *p = L; //指针p指向当前扫描到的结点
     int j = 0; //当前p指向的是第几个结点
     //循环找到第i-1个结点
     while (p != NULL && j < i-1){
         p = p->next;
         j++;
     }
/*     //i值不合法
     if (p==NULL){
         return false;
     }
     //插入操作
     LNode *s = (LNode *) malloc(sizeof (LNode));
     s->data = e;
     s->next = p->next;
     p->next = s;
     return true;*/
     return InsertNextNode(p,e);
 }

 //3.2按位序插入(不带头结点)
 bool ListInsert2(LinkedList &L,int i,int e){
     if ( i < 1){
         return false;
     }

     //两种情况:第一种插入到第一个结点,第二种插入到大于1的结点(找i-1结点,再插入)
     //1. 插入到第一个结点
     if (i == 1){
         LNode *s = (LNode *) malloc(sizeof (LNode));
         s->data = e;
         s->next = L;
         L = s;
         return true;
     }
     //2. 插入到大于1的结点(找i-1结点,再插入)
     LNode *p = L;
     int j = 1;
     while (p != NULL && j < i-1){
         p = p->next;
         j++;
     }
/*     if (p == NULL){
         return false;
     }
     LNode *s = (LNode *) malloc(sizeof (LNode));
     s->data = e;
     s->next = p->next;
     p->next = s;
     return true;*/
     return InsertNextNode(p,e);
 }

/**
 * 4.单链表的删除
 */

//4.1 按位序删除(带头结点)
bool ListDelete(LinkedList &L,int i,int &e){
    if (i < 1){
        return false;
    }
    //找到第i-1结点
     LNode *p = L;
    int j = 0;
    while (p != NULL && j < i-1){
        p = p->next;
        j++;
    }
    if (p == NULL){ //i值不合法
        return false;
    }
    if (p->next == NULL){//第i-1个结点后没有结点
        return false;
    }
    //删除第i个结点
    LNode *q = p->next;
    e = q->data;
    p->next = q->next;
    free(q);
    return true;
}

//4.2 按位序删除(不带头结点)
bool ListDelete2(LinkedList &L,int i,int &e){
    if (i < 1){
        return false;
    }
    if (i == 1){
        LNode *p = L;
        L = p->next;
        free(p);
    }
    //找第i-1个结点
    LNode *p = L;
    int j = 1;
    while (p != NULL && j < i-1){
        p = p->next;
        j++;
    }
    if (p == NULL){
        return false;
    }
    if (p->next == NULL){
        return false;
    }
    //删除第i个结点
    LNode *q = p->next;
    e = q->data;
    p->next = q->next;
    free(q);
}

//4.3删除指定结点p【p不能为最后一个结点】
bool DeleteNode(LNode *p){
    if (p == NULL){
        return false;
    }
    LNode *q = p->next;
    p->data = q->data;
    p->next = q->next;
    free(q);
}

/**
 * 5.查找
 * 按位查找  按值查找  求单链表的
 */

//5.1按位查找【带头结点】
LNode * GetElem(LinkedList L,int i){
    if (i < 1){
        return NULL;
    }
    LNode *p = L;
    int j = 0;
    while (p != NULL && j < i){
        p = p->next;
        j++;
    }
    return p;
}

//5.2按值查找
LNode * LocateElem(LinkedList L,int e){
    LNode *p = L->next;
    while (p != NULL && p->data != e){
        p = p->next;
    }
    return p;
}

//5.3求表的长度
int Length(LinkedList L){
    LNode *p = L;
    int j = 0;
    while (p->next != NULL){ //注意点是p->next
        p = p->next;
        j++;
    }
    return j;
}

/**
 * 6.创建:尾插法和头插法
 */

//6.1尾插法
LinkedList ListTailInsert(LinkedList &L){
    int x; //要插入的数据元素
    L = (LNode *) malloc(sizeof (LNode)); //创建头结点
    //定义一个指针:指向最后一个元素
    LNode  *r = L;
    cin>>x; //输入要插入的数据值
    LNode *s;//要插入的结点
    while (x != 9999){ //x=9999结束
        s = (LNode *) malloc(sizeof (LNode));
        s->data = x;
        r->next = s;
        r = s;//再次指向最后一个元素
        cin>>x;
    }
    r->next = NULL; //尾结点指针置空
    return L;
}

//6.2头插法
LinkedList ListHeadInsert(LinkedList &L){
    int x;//要插入的数据元素
    L = (LNode *) malloc(sizeof (LNode));
    //定义一个指针指向头结点
    LNode *p = L;
    p->next = NULL;
    //要插入的结点
    LNode *s;
    cin>>x;
    while (x != 9999){
        s = (LNode *) malloc(sizeof (LNode));
        s->data = x;
        s->next = p->next;
        p->next = s;
        cin>>x;
    }
    return L;
}

//【单链表逆置】
LinkedList Reverse(LinkedList &L){
    //指向头结点
    LNode *p = L;
    //记录一下第一个结点
    LNode *first = L->next;
    //指向要插入的元素:从第二个元素开始
    LNode *q = L->next->next;
    //要插入的结点
    LNode *s;
    while (q != NULL){
        s = q;
        q = q->next;
        s->next = p->next;
        p->next = s;
    }
    //最后一个结点,及最先的第一个结点指向NULL
    first->next = NULL;
    return L;
}

/**
 * 输出链表全部元素
 */
 void ListPrint(LinkedList L){
     LNode *p = L->next;
    while (p != NULL){
        cout << p->data<<"   ";
        p = p->next;
    }
    cout<<endl;
 }


int main() {
    //头插法创建
    LinkedList L;
    ListHeadInsert(L);
    ListPrint(L);
    //逆置
    Reverse(L);
    ListPrint(L);
    //表长
    int length = Length(L);
    cout<<"Length: "<<length<<endl;
    //插入
    ListInsert(L,2,10);
    ListPrint(L);
    //删除
    int e = 0;
    ListDelete(L,3,e);
    ListPrint(L);
    return 0;
}


双链表

#include <iostream>
using namespace std;
/**
 * 1. 双链表的定义
 */

//1.1定义
typedef struct DNode{
    int data;
    struct DNode *prior,*next;
}DNode,*DLinkList;

//1.2初始化(带头结点)
bool InitDoubleList(DLinkList &L){
    L = (DNode *) malloc(sizeof (DNode)); //分配一个头结点
    if (L == NULL){
        return false;
    }
    L->prior = NULL; //头结点的前一个结点为NULL
    L->next = NULL; //下一个结点暂时为NULL
    return true;
}

//1.3 链表判空
bool IsEmpty(DLinkList L){
    return L->next == NULL;
}

/**
 * 2. 双链表的插入
 */

//2.1 在p结点之后插入s结点
bool InsertNextDNode(DNode *p,DNode *s){
    if (p == NULL || s == NULL){
        return false;
    }
    s->next = p->next;
    //p->next->prior = s; 这里注意p可能是最后一个结点,即p->next = NULL;
    if (p->next != NULL){
        p->next->prior = s;
    }
    s->prior = p;
    p->next = s;
    return true;
}

/**
 * 3. 双链表的删除
 */

//3.1 删除p结点的后继结点
bool DeleteNextDNode(DNode *p){
    if (p == NULL){
        return false;
    }
    //要删除的结点
    DNode *q = p->next;
    if (q == NULL){
        return false;
    }
    p->next = q->next;
    if (q->next != NULL){
        q->next->prior = p;
    }
    free(q);
    return true;
}

//3.2 销毁链表
void DestroyList(DLinkList &L){
    if (L == NULL){
        return;
    }
    while (L->next != NULL){
        DeleteNextDNode(L);
    }
    free(L);
    L = NULL; //指向NULL
}

/**
 * 4. 双链表的遍历
 */

//4.1 p结点的后向遍历
void TraverseBack(DNode *p){

    while (p != NULL){
        cout << p->data <<"  ";
        p = p->next;
    }

}

//4.2 p结点的前向遍历
void TraversePrior(DNode *p){

    while (p->prior != NULL){ //跳过头结点
        cout << p->data <<"  ";
        p = p->prior;
    }

}

int main() {

    //初始化
    DLinkList L;
    InitDoubleList(L);
    //插入数据
    DNode *s;
    for (int i = 1; i <= 5; ++i) {
        s = (DNode *) malloc(sizeof (DNode));
        s->data = i;
        InsertNextDNode(L,s);
    }
    //遍历
    TraverseBack(L->next);
    //销毁
    DestroyList(L);
    return 0;
}


循环链表

#include <iostream>
using namespace std;

/**
 * 1.循环链表的定义:循环单链表和循环双链表
 */

//1.1 循环单链表
typedef struct LNode {
    int data;
    struct LNode *next;
}LNode, *LinkList;

//初始化一个循环单链表
bool InitList(LinkList &L){
    L = (LNode *) malloc(sizeof (LNode));
    if (L == NULL){
        return false;
    }
    L->next = L;
    return true;
}

//判断循环单链表是否为空
bool IsEmpty(LinkList L){
    return L->next == L;
}

//判断结点p是否为循环单链表的尾结点
bool IsTail(LinkList L,LNode *p){
    return p->next == L;
}


//1.2循环双链表
typedef struct DNOde{
    int data;
    struct DNOde *prior,*next;
}DNOde,*LinkedList;

//初始化一个循环单链表
bool InitDLinkList(LinkedList &L){
    L = (DNOde *) malloc(sizeof (DNOde));
    if (L == NULL){
        return false;
    }
    L->next = L;
    L->prior = L;
    return true;
}
//判断循环双链表是否为空
bool Empty(LinkedList L){
    return L->next == L;
}

//判断结点p是否为循环单链表的尾结点
bool Tail(LinkedList L,DNOde *p){
    return p->next == L;
}

int main() {

    return 0;
}


静态链表

#include <iostream>
using namespace std;


/**
 * 1. 静态链表
 */
#define MaxSize 10   //静态链表的最大长度
typedef struct {
    int data;
    int next; //下一个元素的数组下标
}SLinkList[MaxSize];


int main() {

    return 0;
}

  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值