数据结构学习笔记01链表

一．单向链表：

由于线性表的顺序存储结构(数组)，在插入和删除需要移动大量元素以及其他特殊情况下，效率低下，耗时费力，此处引入了链表的概念。

链表的基本组成单元为结点(node)，包括两个域：存储数据元素信息的域->数据域；存储直接后继存储位置的域(指针)->指针域。

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define OK 1
#define ERROR 0


typedef int Status;/* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int ElemType;/* ElemType类型根据实际情况而定，这里假设为int */

typedef struct Node
{
    ElemType data;
    struct Node *next;
}Node;
typedef struct Node *LinkList; //定义LinkList

Status InitList(LinkList *L);
Status Destroy(LinkList L);
Status ClearList(LinkList *L);
bool ListEmpty(LinkList L); 
int ListLength(LinkList L);
Status GetElem(LinkList L,int i,ElemType *e);
int LocateElem(LinkList L,ElemType e);
Status PriorElem(LinkList *L, ElemType cur_e, LinkList *pre_e);
Status NextElem(LinkList *L, ElemType cur_e, LinkList *next_e);
Status ListInsert(LinkList *L,int i,ElemType e);
Status ListDelete(LinkList *L,int i,ElemType *e);
Status ListTraverse(LinkList L);
void CreateListHead(LinkList *L, int n);
void CreateListTail(LinkList *L, int n);

Status visit(ElemType c)
{
    printf("%d ",c);
    return OK;
}

/*初始化顺序线性表: 构造一个空的线性表L*/
Status InitList(LinkList *L) 
{ 
    *L = (LinkList)malloc(sizeof(Node)); /* 产生头结点,并使L指向此头结点，L为头指针 */
    if(!(*L)) /* 存储分配失败 */
            return ERROR;
    (*L)->next = NULL; /* 指针域为空 */

    return OK;
}
/*初始条件:线性表L已存在。操作结果：销毁线性表L*/
Status Destroy(LinkList L)
{
    ClearList(&L);
    free(L);
    L = NULL;
}

/* 初始条件：顺序线性表L已存在。操作结果：将L重置为空表 */
Status ClearList(LinkList *L)
{ 
    LinkList p,q;
    p=(*L)->next;           /*  p指向第一个结点 */
    while(p)                /*  没到表尾 */
    {
        q=p->next;
        free(p);
        p=q;
    }
    (*L)->next = NULL;        /* 头结点指针域为空 */
    return OK;
}

/* 初始条件：顺序线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE */
bool ListEmpty(LinkList L)
{ 
    if(L->next)
        return false;
    else
        return true;
}

/* 初始条件：顺序线性表L已存在。操作结果：返回L中数据元素个数 */
int ListLength(LinkList L)
{
    int i = 0;
    LinkList p=L->next; /* p指向第一个结点 */
    while(p)                        
    {
        i++;
        p=p->next;
    }
    return i;
}

/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) 
操作结果：用e返回L中第i个数据元素的值 */
Status GetElem(LinkList L,int i,ElemType *e)
{
    int j = 1;             /* j为计数器 */
    LinkList p;             /* 声明一结点p */
    p = L->next;         /* 让p指向链表L的第一个结点 */          
    while (p && j < i) {   /* p不为空或者计数器j还没有等于i时，循环继续 */  
        p = p->next;       /* 让p指向下一个结点 */
        j++;
    }
    if ( !p || j>i ) 
        return ERROR;       /*  第i个元素不存在 */
    *e = p->data;        /*取第i个元素的数据 */
    return OK;
}

/* 初始条件：顺序线性表L已存在 
操作结果：返回L中第1个与e满足关系的数据元素的位序。
若这样的数据元素不存在，则返回值为0 */
int LocateElem(LinkList L,ElemType e)
{
    int i=0;
    LinkList p=L->next;
    while(p)
    {
        i++;
        if(p->data==e) /* 找到这样的数据元素 */
                return i;
        p=p->next;
    }

    return 0;
}

/*初始条件：线性表L已存在
操作结果：若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱，
否则操作失败，pre_e无定义*/
Status PriorElem(LinkList *L, ElemType cur_e, LinkList *pre_e)
{
    LinkList p;
    p = (*L)->next;
    if(p->data == cur_e) {        /* 是第一个 */
        pre_e = NULL;
        return ERROR;
    }
    while(p->next)
    {
        if(p->next->data == cur_e) {
            *pre_e = p;
            return OK;
        }
        p = p->next;
    }
    pre_e = NULL;
    return ERROR;
}

/*初始条件：线性表L已存在
操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后驱，
否则操作失败，next_e无定义*/
Status NextElem(LinkList *L, ElemType cur_e, LinkList *next_e)
{
    LinkList p;
    p = (*L);
    while(p->next) 
    {
        if(p->data == cur_e) {
            *next_e = p->next;
            return OK;
        }
        p = p->next;
    } 
    *next_e = NULL;
    return ERROR;
}

/* 初始条件：顺序线性表L已存在,1≤i≤ListLength(L) + 1,
操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */
Status ListInsert(LinkList *L,int i,ElemType e)
{ 
    int j = 1;
    LinkList p,s;
    p = *L;  
    while (p && j < i) {    /* 寻找第i个结点 */
        p = p->next;
        ++j;
    } 
    if (!p || j > i) 
        return ERROR;   /* 第i个元素不存在 */
    s = (LinkList)malloc(sizeof(Node));  /*  生成新结点(C语言标准函数) */
    s->data = e;  
    s->next = p->next;      /* 将p的后继结点赋值给s的后继  */
    p->next = s;          /* 将s赋值给p的后继 */
    return OK;
}

/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L)
操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 */
Status ListDelete(LinkList *L,int i,ElemType *e) 
{ 
    int j;
    LinkList p,q;
    p = *L;
    j = 1;
    while (p->next && j < i) {    /* 遍历寻找第i个元素 */
        p = p->next;
        ++j;
    }
    if (!(p->next) || j > i) 
        return ERROR;           /* 第i个元素不存在 */
    q = p->next;
    p->next = q->next;            /* 将q的后继赋值给p的后继 */
    *e = q->data;               /* 将q结点中的数据给e */
    free(q);                    /* 让系统回收此结点，释放内存 */
    return OK;
}

/* 初始条件：顺序线性表L已存在
操作结果：依次对L的每个数据元素输出 */
Status ListTraverse(LinkList L)
{
    LinkList p=L->next;
    while(p)
    {
        visit(p->data);
        p=p->next;
    }
    printf("
");
    return OK;
}

/*  随机产生n个元素的值，建立带表头结点的单链线性表L（头插法） */
void CreateListHead(LinkList *L, int n) 
{
    LinkList p;
    int i;
    srand(time(0));                         /* 初始化随机数种子 */
    *L = (LinkList)malloc(sizeof(Node));
    (*L)->next = NULL;                      /*  先建立一个带头结点的单链表 */
    for (i=0; i<n; i++) 
    {
        p = (LinkList)malloc(sizeof(Node)); /*  生成新结点 */
        p->data = rand()%100+1;             /*  随机生成100以内的数字 */
        p->next = (*L)->next;    
        (*L)->next = p;                        /*  插入到表头 */
    }
}

/*建立带表头结点的单链线性表L（尾插法） */
void CreateListTail(LinkList *L, int n) 
{
    LinkList p,r;
    *L = (LinkList)malloc(sizeof(Node));     /* L为整个线性表 */
    r = *L;                              /* r为指向尾部的结点 */
    for (int i = 0; i < n; i++) {
        p = (Node *)malloc(sizeof(Node));      /*  生成新结点 */
        scanf("%d",p->data); 
        r->next = p;        /* 将表尾终端结点的指针指向新结点 */
        r = p;            /* 将当前的新结点定义为表尾终端结点 */
    }
    r->next = NULL;                       /* 表示当前链表结束 */
}
int main()
{
    LinkList L, pre_e,next_e;    //创建一个可以指向结点的指针 
    CreateListTail(&L,10);
    ListInsert(&L,11,55); 
    ListTraverse(L);
    PriorElem(&L, 3, &pre_e);
    NextElem(&L, 3, &next_e);
    printf("前驱%d
",(*pre_e).data);
    printf("后继%d
",(*next_e).data);
    Destroy(L);

        
    return 0;
} 

单向链表的基本结构：

typedef struct Node

{

    ElemType data;

    struct Node *next;

}Node;

typedef struct Node *LinkList; //定义LinkList

单向链表的基本操作：/*只需浏览，作了解，详见（代码：sj1_0）*/

Status InitList(LinkList *L);

       操作结果：构造一个空的线性表。

Status Destroy(LinkList L);

       初始条件：线性表L已存在。

       操作结果：销毁线性表L

Status ClearList(LinkList *L);

       初始条件：线性表L已存在。

　　  操作结果：将L重置为空表

Status ListEmpty(LinkList L);      

       初始条件：线性表L已存在。

       操作结果：若L为空表，则返回TRUE，否则返回FALSE。

int ListLength(LinkList L);

　　  初始条件：线性表L已存在。

　　  作结果：返回L中数据元素个数。

Status GetElem(LinkList L, int i, ElemType *e);

       初始条件：顺序线性表L已存在，1≤i≤ListLength(L)。

       操作结果：用e返回L中第i个数据元素的值。

int LocateElem(LinkList L, ElemType e);

       初始条件：顺序线性表L已存在。

       操作结果：返回L中第1个与e满足关系的数据元素的位序。

若这样的数据元素不存在，则返回值为0。

Status PriorElem(LinkList *L, ElemType cur_e, LinkList *pre_e);

       初始条件：线性表L已存在

　　  操作结果：若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱，

　　  否则操作失败，pre_e无定义。

Status NextElem(LinkList *L, ElemType cur_e, LinkList *next_e);

       初始条件：线性表L已存在

　　  操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后驱，

　　  否则操作失败，next_e无定义。

Status ListInsert(LinkList *L, int i, ElemType e);

       初始条件：顺序线性表L已存在,1 ≤i ≤ ListLength(L) + 1。

　　  操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1。

Status ListDelete(LinkList *L, int i, ElemType *e);

       初始条件：顺序线性表L已存在，1≤i≤ListLength(L)。

　　  操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1。

Status ListTraverse(LinkList L);

       初始条件：顺序线性表L已存在。

　　  操作结果：依次对L的每个数据元素输出。

void CreateListHead(LinkList *L, int n);

       操作结果：立带表头结点的单链线性表L（头插法）。

void CreateListTail(LinkList *L, int n);

       操作结果：建立带表头结点的单链线性表L（尾插法）。

1.单链表的读取

　　算法思路：

　　1.声明一个指正p指向链表的第一个结点，初始化j = 1。

　　2.当j<i时，遍历链表，p=p->next; j++；

　　3.若链表末尾p为空，则说明第i个结点不存在。

　　4.否则查找成功，返回结点p的数据。

/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) 
操作结果：用e返回L中第i个数据元素的值 */
Status GetElem(LinkList L,int i,ElemType *e)
{
    int j = 1;             /* j为计数器 */
    LinkList p;             /* 声明一结点p */
    p = L->next;         /* 让p指向链表L的第一个结点 */          
    while (p && j < i) {   /* p不为空或者计数器j还没有等于i时，循环继续 */  
        p = p->next;       /* 让p指向下一个结点 */
        j++;
    }
    if ( !p || j>i ) 
        return ERROR;       /*  第i个元素不存在 */
    *e = p->data;        /*取第i个元素的数据 */
    return OK;
}

2.单链表的插入

　　算法思路：

　　1.声明一个指针p指向链表头结点，向后遍历p=p->next，直到满足条件。

　　2.新建一个结点s。

　　3.s->next = p->next ①

　　4.p->next = s       ②③

/* 初始条件：顺序线性表L已存在,1≤i≤ListLength(L) + 1,
操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */
Status ListInsert(LinkList *L,int i,ElemType e)
{ 
    int j = 1;
    LinkList p,s;
    p = *L;  
    while (p && j < i) {    /* 寻找第i个结点 */
        p = p->next;
        ++j;
    } 
    if (!p || j > i) 
        return ERROR;       /* 第i个元素不存在 */
    s = (LinkList)malloc(sizeof(Node));  /*  生成新结点 */
    s->data = e;  
    s->next = p->next;      /* 将p的后继结点赋值给s的后继  */
    p->next = s;            /* 将s赋值给p的后继 */
    return OK;
}

3.单链表的删除

　　算法思路：

　　1. 声明一个指针p指向链表头结点，向后遍历p=p->next，直到满足条件。

　　2. q = p->next

　　3. p->next = q->next  ①②

　　4. free(q)             　　 ③④

/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L)
操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 */
Status ListDelete(LinkList *L,int i,ElemType *e) 
{ 
    int j;
    LinkList p,q;
    p = *L;
    j = 1;
    while (p->next && j < i) {    /* 遍历寻找第i个元素 */
        p = p->next;
        ++j;
    }
    if (!(p->next) || j > i) 
        return ERROR;           /* 第i个元素不存在 */
    q = p->next;
    p->next = q->next;            /* 将q的后继赋值给p的后继 */
    *e = q->data;               /* 将q结点中的数据给e */
    free(q);                    /* 让系统回收此结点，释放内存 */
    return OK;
}

4.单链表的整体创建

　　算法思路：

　　1.创建指向头结点的头指针L，使r=L

　　While（）{

　　　　2.新建结点p

　　　　3.r->next = p

　　　　4.r = p

　　}如此往复

　　5.最后一个结点指针指向NULL

/*建立带表头结点的单链线性表L（尾插法） */
void CreateListTail(LinkList *L, int n) 
{
    LinkList p,r;
    *L = (LinkList)malloc(sizeof(Node));     /* L为整个线性表 */
    r = *L;                              /* r为指向尾部的结点 */
    for (int i = 0; i < n; i++) {
        p = (Node *)malloc(sizeof(Node));      /*  生成新结点 */
        scanf("%d",p->data); 
        r->next = p;        /* 将表尾终端结点的指针指向新结点 */
        r = p;            /* 将当前的新结点定义为表尾终端结点 */
    }
    r->next = NULL;                       /* 表示当前链表结束 */
}

总体思路就是如此。理解模型后，其他操作原理相同。

practice：

1.已知线性表中的元素以值的递增有序排列，并以单链表做存储结构。试写一高效的算法，删除表中所有大于mink且小于maxk的元素（若表中存在这样德尔元素），同时释放被删结点空间，并分析你的算法复杂度（注意：mink 和 maxk 是给定的两个参变量，它们的值可以和表中元素相同，也可以不同）。代码（代码：sj1_1）

//可以追溯到短学期写的
#include <stdio.h>
#include <stdlib.h>

struct line
{
    int num;
    struct line *next;
};
typedef struct line *LinkList;
LinkList head;

struct line *creat();
struct line *cut(int min,int max);
void display();
int main()
{
    int mink,maxk;
    creat();
    display();
    printf("Plead input mink & maxk:");
    scanf("%d %d",&mink,&maxk);
    cut(mink,maxk);
    display();
    return 0;
} 

struct line *creat()
{
    LinkList p1, p2;
    int count;
    printf("Please input the number of JieDian:");
    scanf("%d",&count);
    p1 = p2 =(struct line *)malloc(sizeof(struct line));
    scanf("%d",&p1->num);
    head = p1;
    for(int i = 1;i < count;i++)
    {
        p2 =(struct line *)malloc(sizeof(struct line));
        scanf("%d",&p2->num);
        p1->next = p2;
        p1 = p2;
    }
    p2->next = NULL;
    return head;
}
struct line *cut(int min,int max)
{
    LinkList p, q;
    p = head;
    while(p->next->num <= min)
        p = p->next;
    while(p->next->num > min && p->next->num < max)
    {
        q = p->next;
        p->next = q->next ;
        free(q);
    }
    q = NULL;    //    free(q)只是释放了q所指的内存空间。     q = NULL防止发生q为野指针 
    return head;
}

void display()
{
    LinkList p;
    p = head;
    if(p == NULL)
        printf("NULL!");
    else
    {
        while(p != NULL)
        {
            printf("%d ",p->num);
            p = p->next; 
        }
    }
    printf("
");
}

2.试写一算法，实现顺序表的就地置逆（不开辟新空间），即利用原表的存储空间将线性表（a1，a2，…，an）逆置为（an，an-1，…，a1）.

3.试写一算法，对单链表实现就地置逆。（代码：sj1_2）

/*短学期写的。。。 
单链表就地逆置(不开辟新空间) Change()
头结点不存num数据*/
#include <stdio.h>
#include <stdlib.h>

struct line
{
    int num;
    struct line* next;
};
struct line *head;
struct line *creat();
void Change();
void display();
int main()
{
    creat();
    printf("Original data:");
    display();
    Change();
    printf("Changed  data:");
    display();
}

struct line *creat()
{
    struct line *p1,*p2;
    int count;
    printf("Please input the number of JieDian:");
    scanf("%d",&count);
    p1 = p2 = (struct line *)malloc(sizeof(struct line));
    p1->num = 0;
    head = p1;
    for(int i = 0;i < count;i++)
    {
        p2 = (struct line *)malloc(sizeof(struct line));
        scanf("%d",&p2->num);
        p1->next = p2;
        p1 = p2;
    }
    p2->next = NULL;
    return head;
}
void Change()
{
    struct line *p,*q;
    p = head->next;
    head->next = NULL;
    while(p != NULL)
    {
        q = p->next;
        p->next = head->next;
        head->next = p;
        p = q;
    }
}
void display()
{
    struct line *p;
    p = head->next;
    if(p == NULL)
        printf("NULL!");
    else
    {
        while(p != NULL)
        {
            printf("%d ",p->num);
            p = p->next; 
        }
    }
    printf("
");
}

二.双向链表(做保留)

三.循环链表(做保留)