数据结构_郝斌_链表

离散存储[链表]

typedef应用举例

#include <stdio.h>

typedef struct Student
{
    int sid;
    char name[100];
    char sex;
}* PSTU, STU;          //PSTU等价于struct Student * ，STU等价于struct Student   

int main(void)
{
        STU st;          //struct Student st;
        PSTU ps = &st;   //struct Student * ps = &st;
        ps->sid = 99;
        printf("%d
",ps->sid);

        system("pause");
        return 0;
}

离散存储[链表]

• 定义：n个节点离散分配，彼此通过指针相连，每个节点只有一个前驱节点，每个节点只有一个后续节点，首节点没有前驱节点，尾节点没有后续节点。

专业术语

• 首节点：第一个有效节点
• 尾节点：最后一个有效节点
• 头节点：第一个有效节点之前的那个节点，头节点并不存放有效数据，加头节点的目的主要是为了方便对链表的操作，头节点的数据类型和首节点类型一样
• 头指针：指向头节点的指针变量
• 尾指针：指向尾节点的指针

如果希望通过一个函数来对链表进行处理，我们至少需要接受链表的哪些参数：

• 只需要一个参数：头指针
• 因为我们可以通过头指针推算出链表的其他所有信息

//用结构体设计一个节点

#include <stdio.h>

typedef struct Node
{
    int data;    //数据域
    struct Node * pNext; //指针域
}NODE, *PNODE;            //NODE等价于struct NOde, PNODE等价于struct Node *

int main(void)
{
    return 0;
}

链表分类

• 单链表
• 双链表：每一个节点有两个指针域
• 循环链表：能通过任何一个节点找到其他所有的节点
• 非循环链表

算法

• 遍历
• 查找
• 清空
• 销毁
• 求长度
• 排序
• 删除节点
• 插入节点

狭义的算法是与数据的存储方式密切相关

广义的算法是与数据的存储方式无关

泛型：利用某种技术达到的效果就是不同的存储方式执行的操作是一样的

插入节点伪代码（在PPT里）

如何看懂一个算法

1. 算法的流程
2. 每个语句的功能
3. 试数
4. 自己重新写一遍代码

复习

数据结构

1. 狭义：数据结构是专门研究数据存储的问题，数据的存储包含两方面：个体的存储 + 个体关系的存储
2. 广义：数据结构既包含数据的存储也包含数据的操作，对存储数据的操作就是算法

算法

1. 狭义：算法是和数据的存储方式密切相关
2. 广义：算法和数据的存储方式无关，这就是泛型思想

数据的存储结构有几种

1.线性

1. 连续存储[数组]
   优点：存取速度很快
   缺点：事先必须知道数组的长度，插入删除元素很慢，空间通常是有限的，事先必须知道数组的长度
2. 离散存储[链表]
   优点：空间没有限制，插入删除元素速度很快
   缺点：存取速度慢
3. 线性结构的应用：栈/队列

2.非线性

1. 树
2. 图

代码

//list.cpp

#include <stdio.h>
#include <malloc.h>
#include<stdlib.h>

typedef struct Node
{
    int data;             //数据域
    struct Node * pNext;  //指针域
}NODE, *PNODE;            //NODE等价于struct Node, PNODE等价于struct NOde *

//函数声明
PNODE create_list(void);
void traverse_list(PNODE pHead);  
bool is_empty(PNODE phead);
int length_list(PNODE);
bool insert_list(PNODE, int, int);       //在pHead所指向链表的第pos个节点的前面插入一个新的节点，该节点的值是val,并且pos的值从一开始
bool delete_list(PNODE, int, int *);
void sort_list(PNODE);

int main(void)
{
    PNODE pHead = NULL;  //等价于struct NOde * pHead = NULL;
    int val;

    pHead = create_list();  //creat_list()功能：创建一个非循环单链表，并将该链表的头节点的地址赋给pHead
    traverse_list(pHead);
    //insert_list(pHead,4,33);
    if(delete_list(pHead,4,&val) )
    {
        printf("chenggong");
    }
    else
    {
        printf("shibai");
    }
    
    traverse_list(pHead);
    //int len = length_list(pHead);
    //sort_list(pHead);
    //traverse_list(pHead);

    system("PAUSE");
    return 0;
}

PNODE create_list(void)
{
    int len;              //用来存放有效节点的个数
    int i;
    int val;             //用来临时存放用户输入的节点的值

//分配了一个不存放有效数据的头节点
PNODE pHead = (PNODE)malloc(sizeof(NODE) );
if(NULL == pHead)
{
    printf("分配失败，程序终止！
");
    exit(-1);
}
PNODE pTail = pHead;
pTail->pNext = NULL;

    printf("请输入您需要生成的链表节点的个数： len = ");
    scanf("%d", &len);

    for(i=0; i<len; ++i)
    {
        printf("请输入第%d个节点的值：",i+1);
        scanf("%d", &val);
    

    PNODE pNew = (PNODE)malloc(sizeof(NODE) );
    if(NULL == pNew)
    {
        printf("分配失败，程序终止！
");
        exit(-1);
    }
    pNew->data = val;
    pTail->pNext = pNew;
    pNew->pNext = NULL;
    pTail = pNew;
    }
    return pHead;
}

void traverse_list(PNODE pHead)
{
    PNODE p = pHead->pNext;

    while(NULL != p)
    {
        printf("%d ", p->data);
        p = p->pNext;
    }
    printf("
");
    return;
}

bool is_empty(PNODE phead)
{
    if(NULL == phead->pNext)
    return true;
    else
    {
        return false;
    }
    
}

int length_list(PNODE pHead)
{
    PNODE p = pHead->pNext;
    int len = 0;

    while(NULL != p)
    {
        ++len;
        p = p->pNext;
    }
    
    return len;
}

void sort_list(PNODE pHead)              //冒泡排序
{
    int i,j,t;
    int len = length_list(pHead);
    PNODE p,q;

    for(i=0, p=pHead->pNext; i<len-1; ++i,p=p->pNext)
    {
        for(j=i+1,q=p->pNext; j<len; ++j,q=q->pNext)
        {
            if(p->data > q->data)        //类似于数组中的：a[i] >a[j]
            {
                t = p->data;             //类似于数组中的：t = a[i];
                p->data = q->data;       //类似于数组中的：a[i] = a[j];
                q->data = t;             //类似于数组中的：a[j] = t;
            }
        }
    }
}

bool insert_list(PNODE pHead, int pos, int val)       //在pHead所指向链表的第pos个节点的前面插入一个新的节点，该节点的值是val,并且pos的值从一开始
{
    int i = 0;
    PNODE p = pHead;

    while(NULL != p && i<pos-1)
    {
        p = p->pNext;
        ++i;
    }
    if(i>pos-1 || NULL == p)
    return false;

    PNODE pNew = (PNODE)malloc( sizeof(NODE) );
    if(NULL == pNew)
    {
        printf("动态分配内存失败！
");
        exit(-1);
    }
    pNew->data = val;
    PNODE q = p->pNext;
    p->pNext = pNew;
    pNew->pNext = q;

    return true;
}

bool delete_list(PNODE pHead, int pos, int * pVal)
{
    int i = 0;
    PNODE p = pHead;

    while(NULL != p->pNext && i<pos-1)
    {
        p=p->pNext;
        ++i;
    }
    if(i>pos-1 || NULL == p->pNext)
    return false;

    PNODE q = p->pNext;
    *pVal = q->data;

    //删除p节点后面的节点
    p->pNext = p->pNext->pNext;
    free(q);
    q = NULL;

    return true;
}

2020/04/08