1-链表的基本操作

以你之姓@ 2023-08-17 16:02 124阅读 0赞

#### 1-1 数据结构的概述 ####

**定义**

> 我们如何把现实中大量而反复的问题以特定的数据类型和特定的存储结构保存到主存储器(内存)中，以及在此基础上为实现某个功能（比如查找某个元素，删除某个元素，对所有元素进行排序）而执行的相应的操作，这个相应的操作也叫做算法。

数据结构=个体+个体的关系  
算法=对存储数据的操作

狭义：

*  数据结构是专门研究数据存储的问题
 *  数据的存储包含两方面：个体的存储 + 个体关系的存储

广义：

*  数据结构既包含数据的存储也包含数据的操作
 *  对存储数据的操作就是算法

#### 1-2 算法 ####

狭义：

*  算法是和数据的存储方式密切相关

广义：

*  算法和数据的存储方式无关，这就是泛型思想

**衡量算法的标准：**  
1、时间复杂度

*  大概程序要执行的次数，而并非是执行的时间（因为同一程序在不同机器上执行的时间是不一样的，有差异)

2、空间复杂度：算法执行过程中大概所占用的最大内存

3、难易程度

4、健壮性  
程序 = 数据的存储 + 数据的操作 + 可以被计算机执行的语言

**泛型**

*  对于同一种逻辑结构，无论该逻辑结构的物理存储是什么样子的，我们可以对它执行相同的操作。

#### 2-1 数据的存储有几种： ####

**1、线性结构【把所有的结点用一根直线穿起来】：**  
连续存储：【数组】  
a、优点

*  存取速度快

b、缺点：

*  事先必须知道数组的长度
 *  插入删除元素很慢
 *  空间通常是有限的
 *  需要大块连续的内存块

**2、离散存储【链表】**  
1、定义：

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

2、专业术语：  
a、首节点：

*  第一个有效节点

b、尾节点：

*  最后一个有效节点

c、头节点：

*  头结点的数据类型和首节点的类型一样没有存放有效数据，最最前面的，是在首节点之前的，主要是为了方便对链表的操作。

d、头指针：（指向头）

*  指向头节点的指针变量

f:尾指针：

*  指向尾节点的指针

> （头结点有可能很大，占的内存可能大，假设我想造一个函数输出所有链表的值，那你如果不用头指针类型做形参，那由于不同链表的头节点不一样大小，这样就没办法找出形参）

3、确定一个链表需要几个参数：

> **只需要一个参数:头指针，因为通过它我们可以推出链表的所有信息。**

**4、链表分类：**

a、单链表

b、双链表：

*  每一个节点有两个指针域

c、循环链表

*  能通过任何一个节点找到其他所有的节点

d、非循环链表

> （java中变成垃圾内存则会自动释放，但是C和C++则不会，所以要  
> 手动释放，否则会引起内存泄露。delete等于free）

#### 5-1 链表的优缺点 ####

优点：

*  空间没有限制
 *  插入删除元素很快

缺点：

*  存取速度很慢

插入节点
    r = p->pNext; p->pNext = q;  q->pNext = r;
    q->pNext = p->pNext;  p->pNext = q;
    
    删除节点
    r = p->pNext;
    p->pNext = p->pNext->pNext;
    free(r);

/**
        链表代码实现。
    */
    # 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);
    // 在pHead所指向链表的第pos个节点的前面插入一个新的结点，该节点的值是val， 并且pos的值是从1开始
    bool insert_list(PNODE pHead, int pos, int val);
    // 删除链表第pos个节点，并将删除的结点的值存入pVal所指向的变量中,  并且pos的值是从1开始
    bool delete_list(PNODE pHead, int pos, int * pVal);  
    // 对链表进行排序
    void sort_list(PNODE); 
    
    int main(void)
    {   
        // 等价于 struct Node * pHead = NULL;
        PNODE pHead = NULL; 
        int val;
        
        // create_list()功能：创建一个非循环单链表，并将该链表的头结点的地址付给pHead
        pHead = create_list(); 
        traverse_list(pHead);
        
        //insert_list(pHead, -4, 33);
        if ( delete_list(pHead, 4, &val) )
        {
            printf("删除成功，您删除的元素是: %d\n", val);
        }
        else
        {
            printf("删除失败!您删除的元素不存在!\n");
        }
    
        traverse_list(pHead);
        
        //int len = length_list(pHead);
        //printf("链表的长度是%d\n", len);
    
        //sort_list(pHead);
        //traverse_list(pHead);
        
    /*  if ( is_empty(pHead) )
            printf("链表为空!\n");
        else
            printf("链表不空!\n");
    */
        return 0;
    }
    
    PNODE create_list(void)
    {
        int len;  //用来存放有效节点的个数
        int i;
        int val; //用来临时存放用户输入的结点的值
    
        //分配了一个不存放有效数据的头结点
        PNODE pHead = (PNODE)malloc(sizeof(NODE));
        if (NULL == pHead)
        {
            printf("分配失败, 程序终止!\n");
            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("分配失败, 程序终止!\n");
                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("\n");
        
        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;
                }
            }
        }
    
        return;
    }
    
    //在pHead所指向链表的第pos个节点的前面插入一个新的结点，该节点的值是val， 并且pos的值是从1开始
    bool insert_list(PNODE pHead, int pos, int val)
    {
        int i = 0;
        PNODE p = pHead;
    
        while (NULL!=p && i<pos-1)
        {
            p = p->pNext;
            ++i;
        }
    
        if (i>pos-1 || NULL==p)
            return false;
    
        //如果程序能执行到这一行说明p已经指向了第pos-1个结点,但第pos-1个节点是否存在无所谓
        //分配新的结点
        PNODE pNew = (PNODE)malloc(sizeof(NODE));
        if (NULL == pNew)
        {
            printf("动态分配内存失败!\n");
            exit(-1);
        }
        pNew->data = val;
        
        //将新的结点存入p节点的后面
        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;
        
        //如果程序能执行到这一行说明p已经指向了第pos-1个结点，并且第pos个节点是存在的
        PNODE q = p->pNext;  //q指向待删除的结点
        *pVal = q->data;  
    
        //删除p节点后面的结点
        p->pNext = p->pNext->pNext;
        
        //释放q所指向的节点所占的内存
        free(q);
        q = NULL;
        
        return true;
    
    }

转载于:https://www.cnblogs.com/Guard9/p/11138857.html