带头节点单链表的实现

最新推荐文章于 2021-11-03 21:45:00 发布
最新推荐文章于 2021-11-03 21:45:00 发布
阅读量804 收藏 1
点赞数 1
分类专栏： 数据结构 文章标签： 单链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32744005/article/details/50396998
版权


               心得体会：单链表是一种 链式存取 的数据结构，用一组物理地址任意的存储单元存放线性表中的数据元素。

          存储：1.逻辑存储

                     2.物理存储

          思维角度：1.逻辑线性结构         一对一

                            2.逻辑非线性结构       一对多

          实现存储方式：1.连续存储方式  eg：数组的申请 ，用malloc 申请一次申请一整块

                                   2.非连续存储方式   eg :链表，树 等 。每创建一个元素，就申请 一 块空间。

          链表的具体存储表示为：

           1  用一组任意的存储单元来存放线性表的结点（这组存储单元既可以是连续的，也可以是不连续的）

            2  链表中结点的逻辑次序和物理次序不一定相同。为了能正确表示结点间的逻辑关系，在存储每个结点值的同时，还必须存储指示其后继结点的地址（或位置）信息（称为指针（pointer）或链(link)）

             3  链表通过每个结点的链域将线性表的n个结点按其逻辑顺序链接在一起的。

             4   每个结点只有一个链域的链表称为单链表（Single Linked List）。

             #include<stdio.h>
#include<stdlib.h>
#include<strings.h>
#include<string.h>
#define TRUE  (1)
#define FALSE (0)
typedef unsigned char Boolean;
typedef struct List_Node       //结构体的声明
{
   int date;            
   struct List_Node *next;
}List_Node;

typedef List_Node  *List_Head;             //自定义List_Node *   <==>  List_Head

List_Head Init_List(void)                                     ;    //链表的初始化
void      Destroy_List(List_Head *head)                       ;    //链表的销毁
Boolean   Push_Frount(List_Head head, int value)              ;    //头部添加
Boolean   Push_Back(List_Head head, int value)                ;    //尾部添加（
Boolean   Pop_Frount(List_Head head)                          ;    //头部删除
Boolean   Pop_Back(List_Head head)                       ;    //尾部删除（效率低）
void      Show_List(List_Head head)                              ; //显示链表信息
Boolean   Find_Node(List_Head head, int value, List_Node **node) ; //链表的查找
void      Sort_List_Ascend(List_Head head)                       ; //链表升序
void      Sort_List_Descend(List_Head head)                      ;    //链表降序
int       Get_List_Length(List_Head head)                        ;    //链表的长度
void      Modify_Node(List_Head head, int value,int new_value)   ;  //链表节点的修改

Boolean Insert_Node(List_Head head,int value,int new_value);//插入的新值
static void *Malloc(size_t size);                 //申请任何类型都可以指向的（size）大小的内存空间
static List_Head Create_Node(void);               //申请一个节点

void swap(List_Node *pm ,List_Node *pn,int List_size);
void swap(List_Node *pm ,List_Node *pn,int List_size)
{
    
     List_Head mid =(List_Head) malloc(List_size);
     memcpy(mid,pm,List_size);
     memcpy(pm,pn,List_size);
     memcpy(pn,mid,List_size);
     free(mid);   
}
List_Head Init_List(void)//链表初始化
{
   List_Head head=NULL;
   head=Create_Node();
   return head;
}
/**************包裹函数*******************/
static void *Malloc(size_t size)//申请任何类型都可以指向的（size）大小的内存空间
{
   void *result=malloc(size);
   if(result==NULL){       //申请失败的情况下
      fprintf(stderr,"the memory is full\n");
      exit(1);
   }
  
   return result;
}
static List_Head Create_Node(void)   //申请一个节点
{
   List_Node *node=(List_Node *)Malloc(sizeof(List_Node));
   bzero(node,sizeof(List_Node));    //对申请的空间进行清零包括：数据赋0 和 指针赋NULL
   return node;
}
void Destroy_List(List_Head *head)//链表的销毁
{
   if(head==NULL||*head==NULL){  //传进一个指向链表根指针的指针
      return ;
   }
   List_Node *p=NULL;
   List_Node *q=NULL;
   p=*head;                      //p指向head的首地址,
   while(p!=NULL){                //p指向的空间的首地址不为空
      q=p;            //q用于存放p上一次所指的空间的首地址
      p=p->next;      //进行遍历
      free(q);        //释放p上一次所指向的空间
   } 
  
  *head=NULL;        //因为根指针的指向没变，但所指向空间内存已释放，故进行赋值为空，避免垃圾数据
}
Boolean Push_Frount(List_Head head, int value)//链表的前添加
{
   List_Head new=NULL;
   new=Create_Node();
   if(head==NULL){
       return FALSE;
   }
   new->date=value;     //对插入的数据进行赋值
   new->next=head->next;//这两步顺序不能更改，必须先让node->next 先指向head->next
   head->next=new;      //再让头节点指向新节点
   head->date++;
   return TRUE;

  
}
Boolean Push_Back(List_Head head ,int value)//链表的后添加
{
   List_Head pm=NULL;
   pm=head;
  
   if(head==NULL){ //检验链表是否存在
       return FALSE;
   }
   while(pm->next!=NULL){ //链表遍历条件，最后节点的指针指向是否为NULL
       pm=pm->next;
   }
   pm->next=Create_Node(); //当不满足条件时，循环已经遍历到最后一个节点了
   pm->next->date=value;
   head->date++;
   return TRUE;
}
Boolean Pop_Frount(List_Head head)//链表的前删除
{
   if(head==NULL||head->next==NULL){ //判断链表是否存在，且是否有有效的节点
        return FALSE; 
   }
   List_Head pm=NULL;  
   pm=head->next;
   head->next=pm->next;  //让head->next指向下一个成员的next所指向的位置
   free(pm);        //依次释放成员空间
   head->date--;
   return TRUE;
}


Boolean Pop_Back(List_Head head)//链表的后删除
{
   if(head==NULL||head->next==NULL){  //链表是否存在以及链表是否存在节点
  
       return FALSE;
   }
   List_Head pm=NULL;         //找到倒数第二个节点
                              //第二种方法
   List_Head pn=NULL;        //while(pm->next->next != NULL){
   pm=head;                  //
   while(pm!=NULL){            //pm=pm->next;}
                          //free(pm->next);
      pn=pm;                 //倒数第二个节点
      pm = pm->next;         //最后一个节点
   }
   pn->next=NULL;             //倒数第二个节点的指针赋NULL，确保不指向其他非法区域
   free(pm);                 //释放最后一个节点的空间
   head->date--;
   return TRUE;
}


Boolean Insert_Node(List_Head head,int value,int new_value)
{        
     if(head == NULL){
         return FALSE;
     }
     List_Head node = NULL;
     node = Create_Node();                                  
     List_Head pm = NULL;
     pm = head->next;
     while(pm != NULL){
         if(pm->date == value){
              node->next = pm->next;
              pm->next = node;
              node->date = new_value;
              head->date++;
              return TRUE;
         }
         pm = pm->next;
     }
     return FALSE;
}
void Show_List(List_Head head)//链表的显示
{ 
     List_Head pm = NULL;
     if(head==NULL){           //检验参数是否正确
         return ;
     }   
     pm = head->next;
     for(pm;pm != NULL;pm=pm->next){
         printf("     %d",pm->date);          //打印每个节点里的数据
     }
     printf("\n");
}

Boolean Find_List(List_Head head,int value,List_Node **node)//链表的查找
{
    if(head==NULL){
        return FALSE;
    }
    List_Head pm = NULL;
    pm = head->next;
    while(pm!=NULL){
        if(pm->date == value){
            if(node != NULL){       //检测欲要指向的节点的指针是否合法
                *node = pm;         //指向所找到节点的首地址
                return TRUE;
            }
        return FALSE;          
        }
    pm = pm->next;                  //遍历的步长
   }
}
   
void Sort_List_Ascend(List_Head head)//链表的升序
{
    List_Node *p_node = NULL;
    List_Node *q_node = NULL;

    if(head == NULL || head->date < 2){
        return ;
    }

    for(p_node = head->next; p_node->next ; p_node = p_node->next){
        for(q_node = p_node->next; q_node; q_node = q_node->next){
            if(p_node->date > q_node->date){
                swap(p_node, q_node, sizeof(List_Node) - sizeof(List_Node *));
            }
        }
    }
 
}


void Sort_List_Descend(List_Head head)//链表的降序
{
 
    List_Node *p_node = NULL;
    List_Node *q_node = NULL;

    if(head == NULL || head->date < 2){   //不能是空链表，节点必须大于1个
        return ;
    }

    for(p_node = head->next; p_node->next ; p_node = p_node->next){  
        for(q_node = p_node->next; q_node; q_node = q_node->next){
            if(p_node->date < q_node->date){
                swap(p_node, q_node, sizeof(List_Node) - sizeof(List_Node *));//交换
            }
        }
    }

}

int Get_List_Length(List_Head head)//链表的长度
{
    if(head==NULL){
        return -1;
    }
    return head->date;
}
void Modify_Node(List_Head head ,int value,int new_value)//链表的修改
{
     if(head==NULL||head->next==NULL){   //检查参数
         return ;
     }
     List_Head pm = NULL;   
     pm = head->next;                   //让指针指向第一个节点
     while(pm!=NULL&&pm->date != value){
            
         pm = pm->next;
     }
     pm->date = new_value;//修改想要的值
}

int main(int argc, char **argv)
{
    List_Head head =Init_List();   //链表的初始化
    int i = 0;
    int insert_next_value =0;   //想要插到那个数的后面的那个数
    int new_value = 0;
    int value = 0;
    List_Node *find = NULL;

    for(i = 0; i < 10; ++i){    //头部添加10个元素
        Push_Frount(head, rand() % 100);
    }
    printf("显示头部添加的10个元素：\n");
    Show_List(head);   //显示链表信息

    printf("显示尾部输入确定值15:\n");
    Push_Back(head,15);
    Show_List(head);   //显示链表信息

    Pop_Frount(head);    //头部删除一个

    // Pop_Back(head);      //尾部删除一个
    printf("把原值为15的节点对应的值修改为5:\n");
    Modify_Node( head ,15,5);//把原值为15的节点对应的值修改为5
    Show_List(head);   //显示链表信息

    printf("the count of list:%d\n", Get_List_Length(head));// 得到链表的长度

    printf("你要找哪个节点:\n");
    scanf("%d", &value);
    Find_List(head, value, &find);//指向所要找的节点的指针的的地址//
                                    //，所以传进去的参数就是指针的指针
    if(find == NULL){
        printf("the %d is not found!\n", value);
    }else{
        printf("found! the value is %d\n", find->date);//找到那个节点的数据
    }
    printf("降序显示链表的信息:\n");
    Sort_List_Descend(head);
    Show_List(head);   //降序显示链表信息

    printf("升序显示链表信息:\n");
    Sort_List_Ascend(head);
    Show_List(head);   //升序显示链表信息
    printf("输入想要插入那个数的后面和插入的新值:");
    scanf("%d:",&insert_next_value);
    printf("请输入插入的新值:");
    scanf("%d",&new_value);
    Insert_Node(head,insert_next_value,new_value);
    Show_List(head);
 
    Destroy_List(&head);      //释放空间
    return 0;
}


只要代码敲得好，BUG就追不到我
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构】C语言实现单链表（带头结点）
SHLYYY
05-04 1926
SLLWNode;// 在pos之前插入 void SLLWInsert(SLLWNode * phead , SLLWNode * pos , SLLWDataType x);// 在pos之后插入 void SLLWInsertAfter(SLLWNode * pos , SLLWDataType x);// 删除pos位置的值 void SLLWErase(SLLWNode * phead , SLLWNode * pos);
链表的头节点理解
qq_43148788的博客
01-02 5197
链表的头节点理解
Mysql——free链表
小志的博客
11-03 1371
一、free链表的概述 当MySQL启动的时候，需要向操作系统申请Buffer Pool的内存空间，但是，当从磁盘上读取一个页然后存储到Buffer Pool的时候，该存放到Buffer Pool的哪个位置呢？而Buffer Pool中是存在有数据的空间和无数据的空间，那么问题又来了，怎么去区分哪些缓冲页是空闲的呢？针对这个问题，free链表就可以满足上述需求了。 Buffer Pool的初始化过程中，是先向操作系统申请连续的内存空间，然后把它划分成若干个【控制块&缓冲页】对。 当插入数
数据结构 带头结点的单链表 操作大全 最全的链表操作（c++实现）
09-27
1800多行代码 22个功能 最全的链表操作 如需转载请注明出处 我的博文：http://blog.csdn.net/u012350104 欢迎交流 讲解代码中函数的ppt：http://download.csdn.net/detail/u012350104/9143181 Made By Fred韩
带头结点的单链表的总结
热门推荐
weixin_42373873的博客
04-23 1万+
线性表的链式存储是用若干地址分散的存储单元存储数据元素，逻辑上相邻的数据元素在物理位置上不一定相邻。 带头结点的单链表是指，在单链表的第一个结点之前增加一个特殊的结点，称为头结点。 头结点的作用：使所有链表（包括空表）的头指针非空，并使对单链表的插入，删除操作不需要区分是否为空表或是否在第一个位置进行，从而与其他位置的插入，删除操作一致。 基本操作： 接口里的方法声明： public inte...
C++ 实现带头节点的单链表
10-11
在下最近在学数据结构，这是我写的一个单链表操作！希望可以帮到大家！
不带头节点的单链表倒置算法
10-08
数据结构上机作业张宪超第二章。 给定一个不带头节点的单链表，写出链表倒置的算法。
Java实现带头结点的单链表
08-25
链表分为带头节点和不带头节点两种类型的链表。 实现原理： 添加节点：添加节点的思路是这样的，先遍历整个链表，找到最后一个节点，将要增加的节点添加到该节点的后面。下面是添加节点的步骤： 1. 定义一个辅助...
线形表---链表---带头节点单链表的就地逆置
11-27
用c语言描述的线形表---链表---带头节点单链表的就地逆置
C语言实现单链表实现方法
08-29
本文主要讨论不带头节点的单链表实现。 链表的定义如下： ```c typedef int DataType; typedef struct Node{ DataType data; struct Node *next; } Node, *pNode, *pList; ``` 在这个定义中，`Node` 结构体包含一...
C语言——带头节点单链表常见操作
时光若止-Dale
04-20 5017
#include <stdio.h> #include <stdlib.h> typedef struct stu { int data; //存放数据 struct stu* next; //下一个节点地址 }Node; typedef struct { int count; // 节点个数 Node* head; // 头结点 }List; //创建新节点功能
单向链表的实现（带头结点）-c语言
better_xiong的博客
06-15 1485
1.带头结点的单向链表的结构 head指针始终指向头结点，head->data不放元素。当head->next==NULL时，链表为空表，不为空表时，head->next指向首结点，即head->next=a1。 2.单向链表带头结点和不带头结点的区别 区别主要有两个方面： （1）使用头结点后在链表中第一个结点位置插入和删除操作更加方便。 （2）使用头结点后，对于空链表和非空链表的操作是一样的。如果不使用头结点，当链表非空时，头指针指向第一个结点的地址，如果是空链表，头指针为NUL
带头结点的单链表简单实现
nb_zsy的博客
09-23 296
/*带头结点的单链表实现*/ #include <stdio.h> #include <stdlib.h> typedef struct ElemType { int id; char name[10]; }ElemType; typedef struct Node { ElemType data; struct Node* next; }ListNode,*LinkList; /*初始化该链表*/ int InitList(LinkList* L) { *L = (
C语言带头结点的单链表
weixin_43484734的博客
11-07 2569
带头结点的单链表 之前的文章创建的单链表都是不带头结点的单链表。有时，我们为了更加方便地对链表进行操作，会在单链表的第一个结点前附设一个结点，称为头结点。 头指针与头结点的异同 头指针： 头指针是指链表中指向第一个结点的指针，若链表有头结点，则是指向头结点的指针。头指针具有标识作用，所以常用头指针冠以链表的名字。 头结点： 头结点是为了操作的统一和方便而设立的，放在第一元素的结点之前，其数据域一般...
C++单链表的建立（有头节点）
Jeff_Winger的博客
10-22 6074
#ifndef chainWithHeader_ #define chainWithHeader_ #include #include //数组 #include //STL中的算法 #include //istringstream流 #include//异常处理 #include//迭代器 #include//标准库中的数学操作函数 #include #include #include
C++之带头节点单链表的简单操作
Allureyou的博客
03-08 3016
#ifndef _LINK_H_ #define _LINK_H_ class List { public: List(); ~List(); void insert(const int d1); void tail_insert(const int d1); void insert_pos(const int d1,const int d); v
C语言实现带头结点的单向链表（头插法）
但行前路 无问西东
08-24 3655
此篇博文代码实现的是用C语言实现带头结点的链表的创建，遍历，摧毁。 代码如下： /********************************************************************************* * Copyright: (C) 2018 Dinghuanhuan&lt;736787419@qq.com&gt; * ...
带头结点的单链表实现
cjy0000的专栏
06-26 734
下面是本人总结的关于带头结点的单链表的实现代码
实现带头结点的单链表
qq_43554677的博客
04-19 514
数据结构——单链表 实现带头结点的单链表 实现带头结点的单链表 功能：对单链表进行 初始化 ，判空， 求表长，插入元素， 删除元素， 查找元素， 尾插法|头插法创建单链表 ，销毁表 心得：通过打印的数据可以清晰判断链表长度变化，判断是否完成基础功能 代码 /* 实现带头结点的单链表 功能：对单链表进行 初始化 ，判空， 求表长，插入元素， 删除元素， 查找元素， ...
带头节点单链表的实现c++
最新发布
04-03
以下是带头节点单链表的实现 c 代码： ```c #include #include typedef struct Node { int data; struct Node *next; } Node; typedef struct List { Node *head; } List; // 初始化带头节点的单链表 void ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值