【考研代码笔记】数据结构

Dorri
211 阅读9分钟

【数据结构学习笔记】2.3线性表的链式表示

1.用代码定义一个单链表

struct LNode{               //定义单链表节点类型 
    ElemType data;          //每个节点存放一个数据元素 
    struct LNode *next;     //指针指向下一个节点 
};
typedef struct LNode LNode;
typedef struct LNode *LinkList;
​
等价于
typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;
  • 要表示一个单链表时，只需声明一个头指针L，指向单链表的第一个结点
    LNode *L;   //声明一个指向单链表第一个结点的指针
或者
LinkList L; //(常用)代码可读性高
  • 通过malloc增加一个新的节点：在内存中申请一个结点所需空间，并用指针p指向这个结点
    struct LNode *p=(struct LNode *) malloc(sizeof(struct LNode));
  • typedef关键字---数据类型重命名
    格式：typedef <数据类型> <别名>
    typedef int zhengshu;
typedef int *zhengshuzhizhen;
​
int x=1;    <=>     zhengshu x=1;
int *p;     <=>     zhengshuzhizhen p;
​
typedef struct LNode LNode;
LNode *p=(LNode *) malloc(sizeof(LNode));
  • LNode * ：强调返回的一个结点
    LinkList：强调这是一个单链表
    LNode * GetElem(LinkList L,int i){
    int j=1;
    LNode *p=L->next;
    if(i==0)
        return L;
    if(i<1)
        return NULL;
    while(p!=NULL&&j<i){
        p=p->next;
        j++;
    } 
    return p;
}

2.不带头结点的单链表(写代码麻烦)

typedef struct LNode{
    ElemType data;
    struct LNODE *next;
}LNode,*LinkList;
​
//初始化一个空的单链表
bool InitList(LinkList &L){
    L=NULL;                 //空表，暂时还没有任何结点(防止脏数据) 
    return true;
}
​
//判断单链表是否为空
bool Empty(LinkList L){
    if(L==NULL)
        return true;
    else
        return false;
} 
或：
bool Empty(LinkList L){
    return (L==NULL);
}
​
void test(){
    LinkList L;         //声明一个指向单链表的指针、
    //初始化一个空表啊
    InitList(L); 
}
  • 对第一个数据结点和后续数据结点的处理需要用不同的代码逻辑
  • 对空表和非空表的处理需要用不同的代码逻辑

3.带头结点的单链表(写代码方便)

typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;
​
//初始化一个单链表(带头结点)
bool InitList(LinkList &L){
    L=(LNode *)malloc(sizeof(LNode));   //分配一个头结点
    if(L==NULL)
        return false;
    L->next=NULL;
    return true;    //头结点之后暂时没有结点 
} 
​
//判断单链表是否为空(带头结点) 
bool Empty(LinkList L){
    if(L->next==NULL)
        return true;
    else 
        return false;
}
​
void test(){
    LinkList L;         //声明一个指向单链表的指针、
    //初始化一个空表啊
    InitList(L); 
}

1111.png

4.按位序插入(带头结点)

ListInsert(&L,i,e):插入操作。在表L中的第i个位置上插入指定元素e。(找到第i-1个结点，将新结点插入其后)

1.png

typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;
​
//在第i个位置插入元素e(带头结点 )
bool ListInsert(LinkList &L,int i,ElemType e){
    if(i<1)
        return false;
    LNode *p;           //指针p指向当前扫描到的结点
    int j=0;            //当前p指向的是第几个结点
    p=L;                //L指向头结点，头结点是第0个结点(不存数据)
    while(p!=NULL&&j<i-1){      //循环找到第i-1个结点 
        p=p->next;
        j++;
    } 
    if(p==NULL)         //i值不合法
        return false;
    LNode *s=(LNode *)malloc(sizeod(LNode));
    s->data=e;
    s->next=p->next;
    p->next=s;          //将结点s连接到p之后
    return true;        //插入成功 
}
  • 平均时间复杂度：O(n)

5.按位序插入(不带头结点)

//在第i个位置插入元素e(不带头结点 )
bool ListInsert(LinkList &L,int i,ElemType e){
    if(i<1)
        return false;
    if(i==1){           //插入第1个结点的操作与其他结点操作不同
        LNode *s=(LNode *)malloc(sizeod(LNode));
        s->data=e;
        s->next=L；
        L=s;            //头指针指向新结点
        return true; 
    } 
    LNode *p;           //指针p指向当前扫描到的结点
    int j=1;            //当前p指向的是第几个结点
    p=L;                //L指向头结点，头结点是第0个结点(不存数据)
    while(p!=NULL&&j<i-1){      //循环找到第i-1个结点 
        p=p->next;
        j++;
    } 
    if(p==NULL)         //i值不合法
        return false;
    LNode *s=(LNode *)malloc(sizeod(LNode));
    s->data=e;
    s->next=p->next;
    p->next=s;          //将结点s连接到p之后
    return true;        //插入成功 
}
查找的部分可由：LNode *p=GetElem(L,i-1); 来封装

6.指定结点的后插操作

typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;
​
//在第i个位置插入元素e(带头结点 )
bool ListInsert(LinkList &L,int i,ElemType e){
    if(i<1)
        return false;
    LNode *p;           //指针p指向当前扫描到的结点
    int j=0;            //当前p指向的是第几个结点
    p=L;                //L指向头结点，头结点是第0个结点(不存数据)
    while(p!=NULL&&j<i-1){      //循环找到第i-1个结点 
        p=p->next;
        j++;
    } 
    return InsertNextNode(p,e);
} 
​
//后插操作：在p结点之后插入元素e
bool InsertNextNode(LNode *p,ElemType e){
    if(i<1)
        return false;
    LNode *s=(LNode *)malloc(sizeod(LNode));
    if(s==NULL)         //分配内存失败 
        return false;
    s->data=e;          //用结点s保存数据元素e 
    s->next=p->next;
    p->next=s;          //将结点s连到p之后
    return true; 
}

1.png

后插时间复杂度为：O(1)

7.指定结点的后插操作

思路1：

2.png

时间复杂度为：O(n)
思路2：

3.png

时间复杂度为：O(1)
//前插操作：在p结点之前插入元素e
bool InsertPriorNode(LNode *p,ElemType e){
    if(p==NULL)
        return false;
    LNode *s=(LNode *)malloc(sizeod(LNode));
    if(s==NULL)         //分配内存失败 
        return false;
    s->next=p->next;
    p->next=s;          //新结点s连到p之后
    s->data=p->data;    //将p中元素复制到s中
    p->data=e;          //p中元素覆盖为e 
    return true; 
}
思路3：

4.png

8.按位序删除(带头结点)

ListDelete(&L,i,&e):删除操作。删除表L中第i个位置的元素，并用e返回删除元素的值。
typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;
​
bool ListDelete(LinkList &L,int i,ElemType &e){
    if(i<1)
        return false;
    LNode *p;           //指针p指向当前扫描到的结点
    int j=0;            //当前p指向的是第几个结点
    p=L;                //L指向头结点，头结点是第0个结点(不存数据)
    while(p!=NULL&&j<i-1){      //循环找到第i-1个结点 
        p=p->next;
        j++;
    } 
    if(p==NULL)         //i值不合法
        return false;
    if(p->next==NULL)   //第i-1个结点之后已无其他结点
        return false; 
    LNode *q=p->next;   //令q指向被删除结点
    e=q->data;          //用e返回元素的值
    p->next=q->next;    //将*q结点从链中"断开"
    free(q);            //释放结点的存储空间 
    return true;        //删除成功 
} 
​
//删除指定结点 p，存在bug，问题在于只有一个数据的链表
bool DeleteNode(LNode *p){
    if(p==NULL)         
        return false;
    LNode *q=p->next;       //令q指向被删除结点
    p->data=p->next->data;  //和后继结点交换数据域 
    p->next=q->next;        //将*q结点从链中"断开"
    free(q);                //释放结点的存储空间 
}
查找的部分可由：LNode *p=GetElem(L,i-1); 来封装

9.按位查找

/*思路1：*/
//按位查找，返回第i个元素(带头结点) 
LNode * GetElem(LinkList L,int i){
    if(i<0)
        return NULL;
    LNode *p;           //指针p指向当前扫描到的结点
    int j=0;            //当前p指向的是第几个结点
    p=L;                //L指向头结点，头结点是第0个结点(不存数据)
    while(p!=NULL&&j<i){        //循环找到第i-1个结点 
        p=p->next;
        j++;
    } 
    return p;
} 
​
/*思路2：*/
LNode * GetElem(LinkList L,int i){
    int j=1;
    LNode *p=L->next;
    if(i==0)
        return L;
    if(i<0)
        return NULL;
    while(p!=NULL&&j<i){        
        p=p->next;
        j++;
    } 
    return p;
}
  • 时间复杂度为：O(n)

10.按值查找

//按值查找，找到数据域==e的结点
LNode *LocateElem(LinkList L,ElemType e){
    LNode *p=L->next;
    //从第1个结点开始查找数据域为e的结点
    while(p!=NULL&&p->data!=e)
        p=p->next;
    return p;       //找到后返回该结点指针，否则返回NULL 
}

11.求表的长度

//求表的长度
int Length(LinkList L){
    int len=0;      //统计表长
    LNode *p=L;
    while(p->next!=NULL){
        p=p->next;
        len++;
    }
    return len;
}
  • 时间复杂度为：O(n)

12.尾插法建立单链表

LinkList List_TailInsert(LinkList &L){  //正向建立单链表
    int x;                  //设ElemType为整型
    L=(LinkList)malloc(sizeof(LNode));  //建立头结点。初始化空表
    LNode *s,*r=L;          //r为表尾指针
    scanf("%d",&x);         //输入结点的值
    while(x!=9999){         //输入9999表示结束
        //在r结点之后插入元素x 
        s=(LNode *)malloc(sizeof(LNode));
        s->data=x;
        r->next=s;
        r=s;    //r指向新的表尾结点
        scanf("%d",&x); 
    }
    r->next=NULL;   //尾结点指针置空
    return L; 
}

5.png

  • 时间复杂度为：O(n)

13.头插法建立单链表(链表逆置)

LinkList List_HeadInsert(LinkList &L){  //逆向建立单链表 
    LNode *s;
    int x;          
    L=(LinkList)malloc(sizeof(LNode));  //建立头结点
    L->next=NULL;       //初始为空表
    while(x!=9999){         //输入9999表示结束
        s=(LNode *)malloc(sizeof(LNode));
        s->data=x;
        s->next=L->next; 
        L->next=s;          //将新结点插入表中，L为头指针 
        scanf("%d",&x); 
    }
    return L; 
}
  • 此代码L->next=NULL;是否能删除？
    不能。因为如果此句删除头结点的指针将会指向内存中未知数据域(存在脏数据)，等所有插入操作完成后将会将最后的指针指向此数据域，导致链表内数据错误。
    故只要是初始化单链表，都先把头指针指向NULL。

6.png

14.双链表的初始化(带头结点)

7.png

typedef struct DNode{   //定义爽链表结点类型 
    ElemType data;      //数据域 
    struct DNode *prior,*next;  //前驱和后继指针 
}DNode,*DLinkList;
​
//初始化双链表
bool InitDLinkList(DLinkList &L){
    L=(DNode *)malloc(sizeof(DNode));   //分配一个头结点
    if(L==NULL)         //内存不足，分配失败 
        return false;
    L->prior=NULL;      //头结点的prior永远指向NULL
    L->next=NULL;       //头结点之后暂时还没有节点
    return true; 
} 
​
//判断双链表是否为空(带头结点)
bool Empty(DLinkList L){
    if(L->next==NULL)
        return true;
    else
        return false;
} 
​
void testDLinkList(){
    //初始化双链表
    DLinkList L;
    InitDLinkList(L); 
}

15.双链表的插入

//双链表的插入
bool InsertNextDNode(DNode *p,DNode *s){
    if(p==NULL||s==NULL)    //非法参数
        return false;
    s->next=p->next;
    if(p->next!=NULL)       //如果p结点有后继结点
        p->next->prior=s;
    s->prior=p
    p->next=s;
    return true; 
}

8.png

16.双链表的删除与摧毁

//双链表的删除
bool DeleteNextDNode(DNode *p){
    if(p==NULL) return false;
    DNode *q=p->next;       //找到p的后继结点q
    if(q==NULL) return false;   //p没有后继
    p->next=q->next;
    if(q->next!=NULL)       //q结点不是最后一个结点
        q->next->prior=p;
    free(q);
    return true; 
} 
​
//销毁双链表
void DestoryList(DLinkList &L){
    //循环释放各个数据结点
    while(L->next!=NULL)
        DeleteNextDNode(L);
    free(L);        //释放头结点
    L=NULL;         //头指针指向NULL 
}

9.png

17.双链表的遍历

//后向遍历
while(p!=NULL){
    //对结点p做相应处理
    p=p->next; 
} 
​
//前向遍历
while(p!=NULL){
    //对结点p做相应处理
    p=p->prior; 
} 
​
//前向遍历(跳过头结点)
while(p->prior!=NULL){
    //对结点p做相应处理
    p=p->prior; 
}
  • 时间复杂度为：O(n)

18.循环单链表

10.png

//初始化一个循环单链表
bool InitList(LinkList &L){
    L=(LNode *)malloc(sizeof(LNode));   //分配一个头结点
    if(L==NULL)     //内存不足，分配失败
        return false;
    L->next=L;      //头结点next指向头结点
    return true; 
} 
​
//判断循环单链表是否为空
bool Empty(LinkList L){
    if(L->next==L)
        return true;
    else
        return false;
} 
​
//判断结点p是否为循环单链表的表尾结点
bool isTail(LinkList L,LNode *p){
    if(p->next==L)
        return true;
    else 
        return false;
}

19.循环双链表

11.png

typedef struct DNode{
    ElemType data;
    struct DNode *prior,*next;
}DNode,*DLinkList;
​
//初始化一个循环双链表
bool InitDLinkList(DLinkList &L){
    L=(DNode *)malloc(sizeof(DNode));   //分配一个头结点
    if(L==NULL)     //内存不足，分配失败
        return false;
    L->prior=L;     //头结点prior指向头结点 
    L->next=L;      //头结点next指向头结点
    return true; 
} 
​
//判断循环双链表是否为空
bool Empty(DLinkList L){
    if(L->next==L)
        return true;
    else 
        return false;
}
 
//判断结点p是否为循环双链表的表尾结点
bool isTail(DLinkList L,DNode *p){
    if(p->next==L)
        return true;
    else 
        return false;
} 
​
void testDLinkList(){
    //初始化循环双链表
    DLinkListL L;
    InitDLinkList(L); 
}
​
//插入结点s
s->next=p->next;
p->next->prior=s;
s->prior=p;
p->next=s;
​
//删除结点s 
p->next=q->next;
q->next->prior=p;
free(q);

20.用代码定义一个静态链表

/*思路1：*/
#define MaxSize 10      //静态链表的最大长度
struct Node{            //静态链表结构类型的定义 
    ElemType data;      //存储数据元素
    int next;           //下一个元素的数组下标 
}; 
​
void testSLinkList(){
    struct Node a[MaxSize];
} 
​
/*思路2：*/
#define MaxSize 10      //静态链表的最大长度
struct Node{            //静态链表结构类型的定义 
    ElemType data;      //存储数据元素
    int next;           //下一个元素的数组下标 
}SLinkList[MaxSize]; 
​
void testSLinkList(){
    SLinkList a;        //a是一个静态链表 
}
​
/*思路3：*/
#define MaxSize 10      //静态链表的最大长度
struct Node{            //静态链表结构类型的定义 
    ElemType data;      //存储数据元素
    int next;           //下一个元素的数组下标 
}; 
typedef struct Node SLinkList[MaxSize];
​
void testSLinkList(){
    struct Node a[MaxSize]; //a是一个Node型数组 
}

12.png

avatar
文章
阅读
粉丝