线性表

最新推荐文章于 2020-07-15 22:15:47 发布
最新推荐文章于 2020-07-15 22:15:47 发布
阅读量683 收藏
点赞数
分类专栏： c语言 数据结构 文章标签： 线性表 c
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014132720/article/details/51771148
版权

线性表

6/27/2016 20:35 PM

1. 顺序线性表seqlist

在内存中的存储在连续的空间，可以利用一维数组实现。

特点:

1.  连续存储；
2.  存取密度高；
3.  删除、插入需要移动大量元素；
4.  内存利用不灵活

内存中随机存储，分不再不同存储块，称为结点。通过指针相互链接。

typedef struct node_t{
  data_t data;
  struct node_t* next;        
}linklist_t;      //一般用typedef重名为linklist_t类型；

特点:

1.各个结点通过malloc动态分配空间；
2. 因此不是连续的；

相关功能实现代码

//在c语言中，非零==真
#define TRUE 1
#define FALSE 0

typedef int data_t;
typedef int bool;

/*******节点类型定义Link_t*****/
typedef struct node{
    data_t data;    //储存数据：
    struct node *next;  //下一个节点指针域
}Link_t;

Link_t *linklist_create();  //创建链表

bool linklist_isEmpty(Link_t *head);    //判空

//求链表长度，不包括头指针
int linklist_getLength(Link_t *head);   //求链表长度

//找到指定位置pos的元素,这里人性化点，按照人思维，第1个就是head->next所指向
data_t linklist_getElem(Link_t *head, int pos);

//找到指定位置pos地址指针,同上，人性化
Link_t* linklist_getLocation(Link_t *head, int pos);

bool linklist_clear(Link_t *head);  //清空

void linklist_destroy(Link_t *head);    //摧毁，释放内存空间

bool linklist_insert(Link_t *head, int pos, data_t add);    //在指定位置处插入元素，即前插,不是后插哦

bool linklist_deletPosition(Link_t *head, int pos); //删除指定位置的元素

bool linklist_deletElem(Link_t *head, data_t elem); //删除指定的元素

int linklist_locate(Link_t *head, data_t elem); //定位elem在链表中第一次出现的位置

bool linklist_dataReplace(Link_t * head, data_t old_data, data_t new_data); //将链表中old_data替换成new_data
bool linklist_showList(Link_t *head);   //显示整个链表
Link_t* linklist_malloc();  //为临时节点开辟空间
void linklist_invert(Link_t *head); //链表倒置
void linklist_sort(Link_t *head);   //链表插入排序法

#endif

/*linklist.c*/
#include<stdio.h>
#include<stdlib.h>
#include <strings.h>
#include "linklist.h"

/*动态分配内存创建
 *创建成功返回Link_t* 指针
 * 失败：NULL
 */
Link_t *linklist_create()
{
    Link_t *head  = (Link_t *)linklist_malloc();
    if(NULL == head)
    {
        printf("Linklist create Failed...\n");
        return NULL;
    }

    bzero(head, sizeof(Link_t));

    //将头指针初始化，假定-1为无效的数据，指针置空
    head->data = -1;
    head->next = NULL;
    printf("new list has been created....\n");

    return head;
}

bool linklist_isEmpty(Link_t * head)
{
    return (head->next == NULL);
}

//求链表长度，不包括头指针
int linklist_getLength(Link_t *head)
{
    int len = 0;
    Link_t *p = head->next;
    while(NULL != p)
    {
        len++;
        p = p->next;
    }

    return len;
}

/*
 *清除链表
 *不能过直接将头指针的next置空，否则链表其他的节点再也无法操作，导致内存一直占用
 *除了头节点，其他节点空间全部释放
 */
bool linklist_clear(Link_t *head)
{

    Link_t *p  = head->next;//用于记录当前节点的下一个节点地址，方便循环
    Link_t *q  = NULL;  //用于指向要删除的节点      

    while(NULL != p)
    {
        q = p;  //将循环到的非空地址保存到q
        free(q);    //释放q
        p = p->next;    //p继续找到下一个
    }

    head->next = NULL;  //将头指针置空
}


data_t linklist_getElem(Link_t *head, int pos)  //找到指定位置的元素
{
    //由于人性化，所以插入的位置不能为0，pos: [1,len+1]
    //插入的位置可以是最后一个元素的后边，因此<=len+1
    if(pos < 1 || pos > linklist_getLength(head)+1)
    {
        printf("Position Invalid. Can`t find the elem...\n");
        return FALSE;
    }

    int i  = 0;

    Link_t *p  =  head->next;

    while(NULL != p)
    {
        i++;
        if(i == pos)
        {
            break;
        }else{
            p = p->next;
        }

    }

    return p->data;

}

Link_t* linklist_getLocation(Link_t *head, int pos) //找到指定位置的地址
{
    if(pos < 1 || pos > linklist_getLength(head)+1)
    {
        printf("Position Invalid.GETLOCATION: Can`t find the elem...\n");
        return NULL;
    }

    int i  = 0;

    Link_t *p  =  head->next;

    while(NULL != p)
    {
        i++;
        if(i == pos-1)  //找到指定位置的前一个即可通过p->next访问到pos处地址
        {
            break;
        }else{
            p = p->next;
        }

    }

    return  p->next;
}


//找到指定位置pos的前一个节点，用于插入操作
Link_t*  linklist_preNode(Link_t *head, int pos)
{

    //pos只能是从第一个到最后一个的下一个
    if(pos < 1 || pos > linklist_getLength(head)+1)
    {
        printf("ERR: Position Invalid.Can`t find the elem before %d.\n", pos);
        return NULL;
    }

    int i  = 0;

    //创建一个临时节点,默认先指向链表头节点
    Link_t *p  = head;

    /*
     * 错误在这里，由于只需要找到pos位置前的一个节点
     * 因此只需要循环pos-1次
     * 错在循环了pos次，从而超出了
     */
    for(i; i<pos-1; i++)
    {
        p = p->next;
    }

//  Link_t* p = linklist_getLocation(head, pos-1);  //这里还是有问题！！！！！！！！！！！！！！！！！
    return p;
}

bool linklist_insert(Link_t *head, int pos, data_t add)
{

    //判断插入的位置合法性,限定可插入的位置从第一个到最后一个的下一个[1,len+1]
    if(pos<1 || pos > (linklist_getLength(head)+1))
    {
        printf("ERR: Position Invalid.\n");
        return FALSE;
    }

    //找到要插入的位置的前一个节点 *pre
    Link_t *pre = linklist_preNode(head, pos);  //这个函数出现了严重的错误，导致操作了非法内存

    //开辟一个新的节点q来存放要插入的数据
    Link_t *q  = (Link_t*) malloc(sizeof(Link_t)); 
    if(NULL == q)
    {
        printf("Insert: Malloc Failed....\n");
        return FALSE;
    }

    bzero(q, sizeof(Link_t));
    q->data = add;
    q->next = NULL;

    //插吧！
    q->next = pre->next;
    pre->next = q;

    return TRUE;

}

bool linklist_deletPosition(Link_t *head, int pos)  //删除指定位置的元素
{
    //判断删除的位置合法性,限定可删除的位置从第一个到最后一个[1,len]
    if(pos<1 || pos > linklist_getLength(head))
    {
        printf("Delet: Position Invalid.\n");
        return FALSE;
    }

    /*
     *要删除pos处的元素
     *  1.找到它前面的节点pre；
     *  2.将pre的指针域设为pos后的节点地址
     *  3.释放pos处的节点
     * */

    Link_t *pre = linklist_preNode(head, pos);  //第pos个前一个节点
    Link_t *del = pre->next;    //要删除的第pos个节点

    pre->next = del->next;
    free(del);

    return TRUE;

}


bool linklist_deletElem(Link_t *head, data_t elem)  //删除指定的元素
{
    Link_t *del = linklist_malloc();
    if(NULL == del)
    {
        printf("ERR: DeletElem: malloc failed.\n");
        return FALSE;
    }
    del->data = -1;
    del->next = NULL;

    int pos = 0;
    pos = linklist_locate(head, elem);

    linklist_deletPosition(head, pos);

}

int linklist_locate(Link_t *head, data_t elem)  //定位elem在链表中第一次出现的位置,如果没找到，返回-1
{
    int pos = 0;
    Link_t *p = head->next;
    //遍历链表，找到指定元素的位置pos，然后调用linklist_deletPosition函数搞定
    while(NULL != p)
    {
        pos++;

        if(p->data == elem)
        {
            return pos;
        }
        p = p->next;

    }
}


bool linklist_showList(Link_t *head)
{
    if(head== NULL)
    {
        printf("链表空！\n");
        return FALSE;
    }

    Link_t *p  = head->next; 
    while( NULL != p)
    {
        printf("%3d\n", p->data);
        p = p->next;
    }
    printf("\n");

    return TRUE;
}

void linklist_destroy(Link_t *head)
{
    //也可以先调用clear，然后在释放head即可
    //遍历，依次释放各个节点内存
    Link_t *p = head->next;
    Link_t *del = NULL;

    while(NULL != p)
    {
        del = p;
        p = p->next;
        free(del);

    }
    free(head);
}

bool linklist_dataReplace(Link_t * head, data_t old_data, data_t new_data)  //将链表中old_data替换成new_data
{
    Link_t *p = head->next;
    while(old_data != p->data && p->next != NULL)
    {
        p = p->next;
    }

    //当找到old_data节点后，替换
    p->data = new_data;
/*
    //递归，直到全部替换
    data_t older = old_data;
    data_t newer = new_data;

    linklist_dataReplace(p, older,newer);
*/
    return TRUE;
}


Link_t* linklist_malloc()   //为临时节点开辟空间
{
    Link_t *p  = (Link_t *) malloc(sizeof(Link_t));
    if(NULL == p)
    {
        return  NULL;
    }
    return p;
}

void linklist_invert(Link_t *head)  //链表倒置
{
    //利用头插法
    Link_t *p = head->next; //循环遍历指针
    Link_t *t = p;  //保存将要插入的节点
    head->next = NULL;//**断开原链表**

    while(p != NULL)
    {   
        t = p;  //插入的是断开后的无头链表p的首节点
        p = p->next;    //p循环到下一个节点  
        /*这个操作不能和下面一条换位置，因为，现在t和p指向的是同一个节点，
         * 如果先执行下一步，那么相当于把p的next也改变了
         * 但是先执行p = p->next,只是改变了指针变量p的指向地址，而t不会变*/
        t->next =head->next;    //继续把t封装好，记得把head当前的下一个节点地址保存到t->next中
        head->next = t;
    }
}

void linklist_sort(Link_t *head)    //链表插入排序法
{
    Link_t *p = head->next; //循环遍历指针
    Link_t *t = head->next; //保存head后的有序链表
    head->next = NULL;//断开原链表

    //现将第一个元素直接插到head后边
    head->next = p;
    p = p->next;

    while(p!= NULL)
    {
        if(p->data < t->data){
            p->next = t;
            head->next = p;
        }else if(p->data > t->data){
            if(t == NULL){
                t->next = p;    
            }else{
                t = t->next;
            }
        }
        p = p->next;
    }
}
MichaelJay2015
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
基础线性表
10-11
线性表（linear_list）是最常用且最简单的一种数据结构
C++通过类实现线性表
08-19
C++ 通过类实现线性表 本文详细介绍了 C++ 通过类实现线性表的知识点，包括线性表的基本概念、类实现线性表的思路、类成员函数的实现等。 线性表的基本概念 线性表是一种基本的数据结构，线性表是由零个或多个...
深入浅出线性表
blackxc的博客
07-15 159
顾名思义像线一样的性质的表，有一个打头的，有一个结尾的，中间元素一个跟个一个； 线性表List：零个或多个元素的有限序列 序列：元素之间是有顺序的，当表的长度为0称之为空表 1. 线性表的顺序存储结构 顺序存储定义：用一段地址连续的存储单元依次存储线性表的数据元素 存储方式：说白了就是在内存找一块连续的存储单元，就是一维数组 数组长度和线性表长度区别：线性表的长度(随着元素的插入删除是变化的)就是数据元素的个数 数组长度大于或等于这个 存储地址：存储器每个存储单元都有自己的编号就是内存地址，sele.
第5课 - 线性表的本质
基建工时福贵
06-30 171
第5课 - 线性表的本质 数据结构是为了解决生活中的实际问题而存在的，那生活中与线性表相对应的例子有什么呢？ 幼儿园中就有一个例子，在老师安排小朋友活动时，会将小朋友组织成下面的站队形式，这个就是线性表。 　　 1. 线性表的定义 　　 　　（1）线性表是0个或多个数据元素的集合 　　（2）线性表中的数据元素之间是有顺序的，这一点非常重要 　　（3）线性表中的数据元素的个...
数据结构：广义表的深度长度，线性结构与非线性结构
Kobe51920的博客
11-03 812
1.广义表的深度与长度 https://blog.csdn.net/W_K_L/article/details/78983957 2.线性结构与非线性结构 线性结构 :是一个有序数据元素的集合。常用的线性结构有：线性表，栈，队列，双队列，数组，串。其特点是数据元素之间存在一对一的线性关系。（串又称为字符串，是一种特殊的线性表，其特殊性体现在数据元素是一个字符，也就是说串是一种内容受限的线性表。（栈...
广义表的长度和广义表的深度
热门推荐
zhupengqq的博客
07-08 2万+
广义表的长度和广义表的深度 广义表是对线性表的扩展——线性表存储的所有的数据都是原子的（一个数或者不可分割的结构），且所有的数据类型相同。而广义表是允许线性表容纳自身结构的数据结构。 广义表定义： 广义表是由n个元素组成的序列：LS = （a1，a2, ... an）;其中 ai是一个原子项或者是一个广义表。n是广义表的长度。若ai是广义表，则称为LS的子表。 广义表表头和
LinkList 单链表的实现
Spades_J 的博客
07-27 5424
LinkList.h#include "stdio.h" #include "math.h" #include "malloc.h" #include "stdlib.h"//typedef int DataType;//LinkNode是链表的结点类型，LinkList是指向链表的指针类型 //如果定义了 LinkList L;则定义了一个链表，L指向该链表的第一个结点 //不带头结点，链表为空，
线性表综合题_C语言_线性表_
09-29
线性表是计算机科学中数据结构的基础概念，它是由n（n≥0）个相同类型元素构成的有限序列。在本题中，我们关注的是如何使用C语言来实现线性表的一些基本操作，包括添加元素（增）、删除元素（删）、修改元素（改）...
数据结构线性表
04-08
线性表是最基本、最简单、也是最常用的一种数据结构。线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的（注意，这句话只适用大部分线性表，而不是全部。
全局变量和局部变量在内存中的区别
Michael Jay 深度挖掘机
07-18 2414
程序中各数据类型在内存中的分配：1、栈区（stack）：——– 由编译器自动分配释放（存放函数的参数值， 局部变量的值等），操作方式类似于数据结构中的栈； 2、堆区（heap） ：——– 由程序员分配释放，如果不释放可能由OS回收，但区别与数据结构中的堆，其分配方式类似于链表； 3、全局区/静态区（全局变量/static）：——- 全局变量和静态static变量是放在一起的 已初始化的全局va
强制转换符的优先级
Michael Jay 深度挖掘机
06-14 2280
运算符优先级强制转换符6/13/2016 11:25:51 PM (float)5/2;//表达式的值为2.5； 因为，强制转化()优先级比四则运算符高，因此先执行强转，然后求商。
c中符号位扩展
Michael Jay 深度挖掘机
05-23 896
今天面试，遇到这样一道题：char c = 128; printf("%c",c); printf("%u",c); printf("%d",c);问输出结果。printf("%u\n", c); //按%u输出，结果为 4294967168 printf("%d\n", c); //按%d输出，结果为 -128 printf("%c\n", c);//按%c输出，结果为ASCII表对应的字符原因：
Makefile
Michael Jay 深度挖掘机
05-12 458
Makefile 变量声明 变量使用 换行符 类似define功能 自动推导 隐晦规则 PHONY表声明的文件是伪标件 减号- 命令以TAB开始 语法规则 指定make的文件 引用其他 伪目标 Makefile1. 变量声明: 递归展开: 将变量完全展开, 如果变量中还有其他变量也全部展开; VAR = var 简单展开: 只是展开一次, 不展开它包含的其他变量; VAR := var 2.
c高级字长字节序对齐
Michael Jay 深度挖掘机
06-20 411
c高级字节序、字长、数据对齐字长计算机一次完成处理的数据—字。不同体系结构，字长不同，目前常见的为32位字长处理器。为了解决不同体系结构不同字长问题，嵌入式linux中给出了: 不透明数据类型:隐藏了内部格式结构；例如保存进程标识符的pid_t实际长度被隐藏； 透明数据类型:长度明确的数据类型；在嵌入式中，储存硬件操作需要用到的数据类型，一般放在驱动文件，使用typedef映射到对应数据类型，如
函数数组传递
Michael Jay 深度挖掘机
06-14 366
将数组传递到函数一维数组void fun(int array[]); 二维数组
c高级预处理
Michael Jay 深度挖掘机
06-20 353
预处理预处理格式要求6/13/2016 11:17:27 PM 必须放在每行开头，因此在源文件中一行只能有一条预处理命令； 但是一条预处理指令可以放在多行，只需要在每行结尾添加 \ 即可。 宏定义无参宏定义 宏定义不是声明或者语句，行末没有分号； 宏定义从定义处直到程序结束，如需提前结束，使用#undef来取消； 宏名在程序中使用双引号括起来，则预处理不替换； 对输出格式使用宏定义，可以减少麻烦；
线性表详解与实现
"该资源是一份关于线性表的PPT，主要讲解了线性表的概念、顺序存储和链式存储以及应用案例分析，适用于学习数据结构的软件工程专业学生。" 线性表是数据结构中的基本概念，它是包含n（n>=0）个具有相同特性数据元素...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

MichaelJay2015

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值