线性表与链表

 

一、线性表介绍

        1、线性结构

        2、线性表

二、线性表的顺序表示和实现：

三、线性表的链式表示和实现

        1、不带头节点的单向链表

        2、带头节点的单向链表

常考的笔试题：

        1、逆序链表、反转链表。

        2、找到环型链表的入口。

        3、寻找Y型链表的入口。

        4、访问链表的倒数第k个节点。

四、双向链表

五、双向循环链表

六、Linux内核链表

七、通用链表

一、线性表介绍

1、线性结构

在数据元素的非空有限集中：

• 存在唯一的一个被称做“第一个”的数据元素

• 存在唯一的一个被称做“最后一个”的数据元素

• 除第一个之外，集合中的每个数据元素均只有一个前驱

• 除最后一个之外，集合中的每个数据元素均只有一个后继

2、线性表

线性表是n个数据元素的有限序列，同一线性表中的元素必定具有相同特性，相阾的数据元素之间存在着序偶关系。

线性表中元素的个数n(n>=0)定义为线性表的长度，0==n时称为空表，在非空表中每个数据元素都有一个确定的位置(下标)。

线性表是一个相当灵活的数据结构，它的长度可根据需要增长或缩短。

二、线性表的顺序表示和实现：

线性表的顺序表示指的是用一组地址连续的存储单元依次存储线性表的数据元素。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#define TYPE int
​
// 设计数据结构
typedef struct Array
{
    TYPE* base; // 存储元素的基址
    size_t cnt; // 元素的数量
    size_t cap; // 表的容量
}Array;
​
// 创建线性表,调用者需要提供容量参数，成功返回线性表指针
Array* creat_array(size_t cap)
{
    // 为线性表创建内存空间
    Array* array = malloc(sizeof(Array));
    // 创建存储元素的内存空间
    array->base = malloc(sizeof(TYPE)*cap);
    // 初始化数量成员
    array->cnt = 0;
    // 备份线性表的容量
    array->cap = cap;
    // 返回线性表指针
    return array;
}
​
// 销毁线性表,调用者只需要提供线性表指针即可
void destory_array(Array* array)
{
    // 释放存储元素的内存空间
    free(array->base);
    // 释放线性表内存空间
    free(array);
}
​
// 清理所有元素
void clear_array(Array* array)
{
    array->cnt = 0;
}
​
// 判断线性表是否是空表
bool empty_array(Array* array)
{
    return 0 == array->cnt;
}
​
// 求线性表的长度
size_t length_array(Array* array)
{
    return array->cnt;
}
​
// 访问指定位置的元素
bool get_array(Array* array,int index,TYPE* elemp)
{
    if(index >= array->cnt)
        return false;
​
    *elemp = array->base[index];
    return true;
}
​
// 在末尾添加元素
void add_back_array(Array* array,TYPE elem)
{
    // 容量如果不够用
    if(array->cnt >= array->cap)
    {
        // 容量扩展两倍
        array->cap *= 2;
        // 元素存储空间扩展两倍
        array->base = realloc(array->base,sizeof(TYPE)*array->cap);
    }
​
    // 末尾添加元素
    array->base[array->cnt++] = elem;
}
​
// 插入元素
bool insert_array(Array* array,int index,TYPE elem)
{
    // 如果下标不合法则插入失败
    if(index >= array->cnt)
        return false;
​
    // 把最后一个元素添加到末尾
    add_back_array(array,array->base[array->cnt-1]);
​
    // 线性表的顺序存储才可以使用
    memmove(array->base+index+1,array->base+index,sizeof(TYPE)*(array->cnt-index-2));
    
    array->base[index] = elem;
    return true;
}
​
// 删除元素，按位置删除
bool delete_index_array(Array* array,int index)
{
    if(index >= array->cnt)
        return false;
​
    memmove(array->base+index,array->base+index+1,sizeof(TYPE)*(array->cnt-index-1));
    array->cnt--;
    return true;
}
​
// 查询元素
int query_array(Array* array,TYPE elem,int (*compare)(const void*,const void*))
{
    for(int i=array->cnt-1; i>=0; i--)
    {
        if(!compare(&elem,array->base+i))
            return i;
    }
    return -1;
}
​
// 删除元素，按值删除
bool delete_value_array(Array* array,TYPE elem,int (*compare)(const void*,const void*))
{
    return delete_index_array(array,query_array(array,elem,compare));
}
​
// 对线性表进行排序
void sort_array(Array* array,int (*compare)(const void*,const void*))
{
    bool flag = true;
    for(int i=array->cnt-1; flag && i>0; i--)
    {
        flag = false;
        for(int j=0; j<i; j++)
        {
            if(1 == compare(array->base+j,array->base+j+1))
            {
                TYPE tmp = array->base[j];
                array->base[j] = array->base[j+1];
                array->base[j+1] = tmp;
                flag = true;
            }
        }
    }
}
​
// 遍历线性表,只是为了测试
void show_array(Array* array)
{
    for(int i=0; i<array->cnt; i++)
    {
        printf("%d ",array->base[i]);
    }
    printf("\n");
}
​
int main(int argc,const char* argv[])
{
    Array* array = creat_array(10);
    for(int i=0; i<10; i++)
    {
        add_back_array(array,rand()%100);
    }
    
    show_array(array);
​
    int intcmp(const void* p1,const void* p2)
    {
        if(*(int*)p1 > *(int*)p2)
            return 1;
        if(*(int*)p1 < *(int*)p2)
            return -1;
        return 0;
​
    }
    
    delete_value_array(array,77,intcmp);
​
    sort_array(array,intcmp);
    
    show_array(array);
    destory_array(array);
    return 0;
}

作业：把顺序线性表的成员指针实现方式改为柔性数组。

// 设计数据结构
typedef struct Array
{
    size_t cnt;     // 元素的数量
    size_t cap;     // 表的容量
    TYPE base[];    // 存储元素的柔性数组
}Array;
​
// 创建线性表,调用者需要提供容量参数，成功返回线性表指针
Array* creat_array(size_t cap)
{
    // 为线性表创建内存空间
    Array* array = malloc(sizeof(Array)+sizeof(TYPE)*cap);
    // 初始化数量成员
    array->cnt = 0;
    // 备份线性表的容量
    array->cap = cap;
    // 返回线性表指针
    return array;
}
​
// 销毁线性表,调用者只需要提供线性表指针即可
void destory_array(Array* array)
{
    // 释放线性表内存空间
    free(array);
}
​
// 在末尾添加元素
void add_back_array(Array* array,TYPE elem)
{
    // 容量如果不够用
    if(array->cnt >= array->cap)
    {
        // 容量扩展两倍
        array->cap *= 2;
        // 元素存储空间扩展两倍
        array = realloc(array,sizeof(Array)+sizeof(TYPE)*array->cap);
    }
​
    // 末尾添加元素
    array->base[array->cnt++] = elem;
}

三、线性表的链式表示和实现

线性表的顺序存储结构的特点是逻辑关系上相邻的两个元素在物理位置上也相邻，因此可以随机存取表中的任一元素，它的存储位置可以用一个简单、直观的公式来表示。

这个特点也铸成了这种存储结构的缺点：在插入、删除操作时，需要移动大量的元素。而线性表的另一种表示方法——链存储结构刚好弥补了它的缺点。

链存储结构不要求逻辑上相邻的元素在物理位置上也相邻，因此它没有顺序存储结构所有具有的缺点，但同时也失去了顺序存储结构可随机存取的优点。

链存储结构的特点