链表实现

最新推荐文章于 2024-10-07 21:35:28 发布
最新推荐文章于 2024-10-07 21:35:28 发布
阅读量324 收藏
点赞数
文章标签： list null delete struct system
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hanxp1601/article/details/6725704
版权

link.h

 

#ifndef __LINK_H__
#define __LINK_H__

#define ERROR ( -1 )
#define OK      ( 0  )

#define TRUE  ( 1 == 1 )
#define FALSE ( !TRUE  )


typedef int BOOL;
typedef int elem_t;            //定义元素的数据类型

typedef struct node
{
    elem_t data;
    elem_t bata;
    struct node * next;
}tagNode_t,tagList_t;


/**//* 把已经存在的头节点进行初始化为一个空链表 */
void initList ( tagList_t * list );
/**//* 销毁链表 */
void destroyList( tagList_t * list );

/**//* 将链表重置为空 */
void clearList( tagList_t * list );

BOOL listEmpty( tagList_t * list );
/**//* 链表长度 */
int listLength( tagList_t * list );

/**//* 得到指定位置 pos 的元素，如果顺利得到则返回TRUE，否则返回 FALSE*/
BOOL getElem( tagList_t * list, int iPos, elem_t * e);

/**//* 返回第一个满足 compare 关系的元素的位置，如果不存在则返回 -1 */
int locateElem( tagList_t * list, elem_t e,
    BOOL (*compare)(elem_t e1,elem_t e2));

/**//* 将元素e插到链表的指定位置 ,若iPos > listLength() 则插到最后*/
BOOL listInsert( tagList_t * list, int iPos, elem_t e );

BOOL listInsertFront( tagList_t * list, elem_t e, elem_t f);

/**//* 按照费递减序插入元素 e */
BOOL listSortInsert( tagList_t * list, elem_t e );

BOOL listDeleteFront( tagList_t * list, elem_t * e );

/**//* 用visit 函数遍历链表 */
void listTraverse( tagList_t * list, void (*visit)(elem_t e));
/**//* 打印链表 */
void listPrint( tagList_t * list);

#endif

--------------------------------------------------------------------------

 

linkFun.h

 

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "link.h"


/**//* 把已经存在的头节点进行初始化为一个空链表 */
void initList ( tagList_t * list )
{
    list->next = NULL;
}
/**//* 销毁链表,没有释放头结点 */
void destroyList( tagList_t * list )
{
    tagNode_t * pn = NULL;
    assert( list != NULL );
   
    pn = list->next;
    while( pn != NULL)
    {
        list->next = pn->next;
        free( pn );
        pn = list->next;
    }
}

/**//* 将链表重置为空 */
void clearList( tagList_t * list )
{
    destroyList( list );  //同 销毁
}

BOOL listEmpty( tagList_t * list )
{
    return ( NULL == list->next );
}

int listLength( tagList_t * list )
{
    int iLen = 0;
    tagNode_t * ptn = NULL;
    assert( list != NULL );
   
    ptn = list->next;
    while( ptn != NULL )
    {
        iLen += 1;
        ptn = ptn->next;
    }
    return iLen;
}

/**//* 得到指定位置 pos 的元素，如果顺利得到则返回TRUE，否则返回 FALSE*/
BOOL getElem( tagList_t * list, int iPos, elem_t * e)
{
    BOOL bRet = FALSE;
    tagNode_t * ptn = NULL;
    assert( list );        //list != NULL
   
    if( list || ( iPos >= 0 ) )
    {
        ptn = list->next;
        while( iPos-- && ptn )
        {
            ptn = ptn->next;
        }       
        if( ptn != NULL )
        {
            *e = ptn->data;
            bRet = TRUE;
        }       
    }
    return bRet;   
}

/**//* 返回第一个满足 compare 关系的元素的位置，如果不存在则返回 0 */
int locateElem( tagList_t * list, elem_t e,
    BOOL (*compare)(elem_t e1,elem_t e2))
{
    int iPos = 0;
    tagNode_t * ptn = NULL;
    assert( list );        //list != NULL
   
    ptn = list->next;
    while( ptn )
    {
        iPos += 1;
        if( compare( e, ptn->data ) )
        {
            break;
        }
        ptn = ptn->next;
    }
    if( NULL == ptn )
    {
        iPos = 0;
    }
    return iPos;
   
}

/**//* 将元素e插到链表的指定位置 ,若iPos > listLength() 则插到最后*/
BOOL listInsert( tagList_t * list, int iPos, elem_t e )
{
    BOOL bRet = FALSE;
    tagNode_t * ptn = NULL, * pstNew = NULL;
    assert( list );        //list != NULL
   
    if( list || (iPos >= 0) )
    {
        ptn = list->next;
        while( iPos-- && ptn->next )
        {
            ptn = ptn->next;
        }       

        pstNew = ( tagNode_t * )malloc( sizeof( tagNode_t ) );
        if( pstNew != NULL )
        {
            pstNew->data = e;
            pstNew->next = ptn->next;
            ptn->next = pstNew;
           
            bRet = TRUE;
        }   
    }
    return bRet;
}

BOOL listInsertFront( tagList_t * list, elem_t e, elem_t f)
{
    BOOL bRet = FALSE;
    tagNode_t * pstNew =
        ( tagNode_t * )malloc( sizeof( tagNode_t ) );
    assert( list );
   
    if( pstNew != NULL )
    {
        pstNew->data = e;
        pstNew->bata = f;
        pstNew->next = list->next;
        list->next = pstNew;
       
        bRet = TRUE;
    }
    return bRet;
}

/**//* 按照非递减序插入元素 e */
BOOL listSortInsert( tagList_t * list, elem_t e )
{
    BOOL bRet = FALSE;
    tagNode_t * ptn = NULL, * pstNew = NULL;
    assert( list );
   
    ptn = list;
    while( ptn->next )
    {
        if( ptn->next->data > e )
        {       
            bRet = TRUE;
            break;
        }
        ptn = ptn->next;
    }
   
    pstNew = ( tagNode_t * )malloc( sizeof( tagNode_t ) );
    if( pstNew != NULL)
    {
        pstNew->data = e;
        pstNew->next = ptn->next;
        ptn->next = pstNew;
       
        bRet = TRUE;
    }

    return bRet;
}

BOOL listDeleteFront( tagList_t * list, elem_t * e )
{
    BOOL bRet = FALSE;
    tagNode_t * ptn = NULL;
   
    if( list != NULL )
    {
        ptn = list->next;
        *e = ptn->data;
        list->next = ptn->next;
        free( ptn );
        bRet = TRUE;
    }
    return bRet;
}

/**//* 用visit 函数遍历链表 */
void listTraverse( tagList_t * list, void (*visit)(elem_t e))
{
    tagNode_t * ptn = NULL, * pstNew = NULL;
    assert( list );
   
    ptn = list->next;
    while( ptn )
    {
        visit( ptn->data );
        ptn = ptn->next;
    }
}

/**//* 打印链表 */
void listPrint( tagList_t * list)
{
    tagNode_t * ptn = NULL;
    assert( list );
   
    ptn = list->next;
    while( ptn )
    {
        printf("list.data = %d  list.bata = %d\n",ptn->data,ptn->bata);
        ptn = ptn->next;
    }    
}

-------------------------------------------------------------------------------------

 

main.c

 

#include <stdio.h>
#include "link.h"
#include "linkFun.h"

int main()
{
    elem_t e;
    tagList_t list;
   

   
    initList( &list );
   
    printf("IsEmpty: %s \n",(listEmpty( &list ) ? "true":"false"));
   
     
    listInsertFront( &list, 1 , 8);
    listInsertFront( &list, 2 , 7);   
    listInsertFront( &list, 3 , 6);
    listInsertFront( &list, 4 , 5);       
   
    listInsertFront( &list, 5 , 4);
    listInsertFront( &list, 6 , 3);   
    listInsertFront( &list, 7 , 2);
    listInsertFront( &list, 8 , 1);       
       
   
   
    /*
    listSortInsert( &list, 4 );
    listSortInsert( &list, 3 );
   

   
    listSortInsert( &list, 5 );
   

   
    listSortInsert( &list, 7 );
    listSortInsert( &list, 2 );
    */
    printf("getElem (3) %s : %d \n",(getElem( &list, 3, &e )?"right":"error"),e);
    printf("getElem (6) %s : %d \n",(getElem( &list, 6, &e )?"right":"error"),e);
   
    listPrint( &list );
    printf(" ");
   
    printf("len: %d ",listLength( &list ));
    listDeleteFront( &list, &e );
    printf("After delete front len: %d \n",listLength( &list ));
    printf("IsEmpty: %s \n",(listEmpty( &list ) ? "true":"false"));

   
    destroyList( &list );
   
    printf("IsEmpty: %s \n",(listEmpty( &list ) ? "true":"false"));
   
    system("pause");
}


 

-----------------------------------------------------------

DEVc++ 调试结果：

IsEmpty: true
getElem (3) right : 5
getElem (6) right : 2
list.data = 8  list.bata = 1
list.data = 7  list.bata = 2
list.data = 6  list.bata = 3
list.data = 5  list.bata = 4
list.data = 4  list.bata = 5
list.data = 3  list.bata = 6
list.data = 2  list.bata = 7
list.data = 1  list.bata = 8
 len: 8 After delete front len: 7
IsEmpty: false
IsEmpty: true
请按任意键继续. . .

hanxp1601
关注
数据结构实验一 用链表实现大整数加减法
m0_61506053的博客
03-31 4131
题目： 用链表实现大整数加减法操作： 32位机器直接操作的数据最大为32个bit，若超过32bit，则需要单独设计算法。在这里，可以用链表每个结点存储大整数的每一位的十进制数字，则可以进行大整数的算数运算，该实验仅实现加减法操作。 要求: 随机产生2个1~50位的数字串，并存储到2个链表中。 进行加法或减法操作，结果存储到新的链表中。 打印运算结果。 目录 BigInteger.h BigInteger.cpp function.h function.cpp main.cpp ..
python双向链表实现实例代码
12-25
python双向链表实现代码： 复制代码 代码如下:#!/usr/bin/python# -*- coding: utf-8 -*- class Node(object): def __init__(self,val,p=0): self.data = val self.next = p self.prev = p class LinkList...
C语言的链表实现
weixin_73728044的博客
10-16 2281
C语言各种链表学习记录
双向链表实现栈
m0_56398287的博客
10-03 1397
双向链表来实现栈
C语言链表实现栈
wu1217的博客
09-07 4192
/** 链表实现带头结点的栈，入栈用头插法 环境codeblocks */ #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;stdbool.h&gt; typedef int ElemType; typedef struct Node { ElemType data; struct...
C#中 简单链表实现
weixin_43542114的博客
07-04 2030
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而线性表和顺序表相应的时间复杂度分别是O(logn)和O(1)
栈——链表实现
m0_53223094的博客
11-21 2828
链栈的一些基本操作，附带源码
多项式加法运算（链表实现）
热门推荐
2021dragon的博客
04-24 1万+
文章目录创建结点类型打印多项式尾插选择排序多项式相加代码总览 + 结果展示 创建结点类型 我们用链表存储一个多项式，那么该链表的每一个结点就代表多项式的某一项。所以我们的每一个结点必须包含三个信息：多项式的系数、多项式的指数以及指向下一个结点的指针。 typedef int SLTDataType;//指数、系数类型 typedef struct SListNode { SLTDataType coef;//系数 SLTDataType expon;//指数 struct SListNode* ne
学生管理系统——用链表实现
Longlong的博客
03-11 4881
前言 该程序是大一上学期的课设，在上学期的基础上对此程序进行了细节上的优化，以及将程序分成多个文件，第一次对多文件开发有了了解(再也不要将几千行代码放在一个文件内了) 一、 软件功能描述 假设学生成绩信息描述如下： 学号，姓名，身份证号，性别，民族，家庭住址，课程成绩，年龄 要求：程序能够实现，（１）增加、删除、修改学生的基本信息；（２）查询功能：查询学生人数；按性别查询学生人数；按民族查询学生人数；统计学生的平均分数；给学生排榜；按课程统计学生分数；查询获得某课程的最高分的学生信息；(3)、存储学生信
Java用链表实现队列
daBai_Zzz的博客
01-08 1961
/** * 链表实现队列 */ public class LinkedQueue { class Node{ int val; Node next; public Node(int val){this.val=val;} public Node(int val,Node next){this.val=val;this.next=next;} } // 队头指针 Node front; // 队尾指针
【C语言】链表实现队列
weixin_43757283的博客
07-14 4954
前言 利用动态数组实现了循环队列，这是静态的队列，缺点是需要预设大小，当队列满时，无法再插入新的数据，只有等队头的数据被取走以后才能往队列放入新的数据。 除了动态数组分配实现的队列之外，还可以使用链表实现队列，这种方式动态创建节点需要的内存，当有新的数据节点要加入时，才去申请内存空间，不需要预设大小，整个队列需要的内存空间不需要连续，并且插入删除更容易实现。但是同时也带来存取速度慢的缺点，操作也比数组的方式更加复杂。 其实用链表实现队列的方式十分简单，只需要在单链表的基础上，增加一个尾指针即可。因为队列的.
C语言学生考试系统（链表实现）
05-25
《C语言学生考试系统——链表实现》 在信息技术领域，C语言作为一种基础且强大的编程语言，被广泛用于系统编程、软件开发以及教学实训。本项目“C语言学生考试系统”便是利用C语言来实现的一个简易考试管理工具，其...
学生信息管理系统（C++实现，链表实现，还有完整的实验报告）
06-27
定义结构体类型,使用动态链表结构编程实现学生 管理系统如下功能： (1)录入每个学生的基本信息； (2)计算每个学生的平均分； (3)按平均分从高到低输出学生信息； (4)按学生姓名的字典顺序输出学生基本信息； (5)按...
图书管理系统（C语言链表实现）含实验报告
05-25
大学期间用C语言链表实现的一个图书管理系统，主要功能有 a. 设备申请。由专业人员填写“申请表”送交领导批准购买。 b. 设备入库。新设备购入后要立即进行设备登记（包括类别、设备名、型号、规格、单价、数量、...
链表实现集合运算 链表实现集合交并差运算
12-27
链表实现集合运算 链表实现集合交并差运算
Redis list 类型
最新发布
m0_74099572的博客
10-07 331
列表类型 list 相当于 数组或者顺序表list内部的编码方式更接近于 双端队列 ，支持头插 头删 尾插 尾删。需要注意的是，Redis的下标支持负数下标。 比如数组大小为5，那么要访问下标为 -2 的值可以理解为访问 5 - 2 = 3Redis中的数据是有序的，但是注意这里的有序不是指排序数组中的升序或者降序，而是指数据的顺序很关键。比如把元素位置调换之后，得到的新的list与原来的list是不等价的。同样的一个词在不同的上下文中，它的意义可能是不一样的。比如同步这个词在 线程之间和IO之间的意义就不
day22 Collection 迭代器 增强for List
2303_79357053的博客
09-30 1131
创建Collection集合的对象多态的方式具体的实现类ArrayListCollection集合常用方法方法名说明添加元素从集合中移除指定的元素根据条件进行移除清空集合中的元素判断集合中是否存在指定的元素判断集合是否为空int size()集合的长度，也就是集合中元素的个数List集合的特点存取有序可以重复有索引。
C++——list
2301_79998744的博客
10-05 927
list的模拟实现
C++初始化列表 initializer_list 介绍
cxrlover的博客
10-01 531
相较于vector更加轻量使用{}构造列表对象使用initializer_list接收根据begin()end()迭代器获取元素内容使用const修饰，不可更改适用情况：传递数量不确定的相同类型的参数，并且对于参数内容无需更改。
链表实现大整数加法
"该资源是关于使用链表实现大整数加法的程序代码，主要应用于数据结构课程。代码中定义了结构体`CPoint`，包含一个整型数字（digit）和指向下一个节点的指针（next）。通过输入两个大整数的字符串表示，将它们转换为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值