C语言 链表系列

已于 2022-07-18 19:53:33 修改
阅读量1.1k 收藏
点赞数 1
分类专栏： 笔记 文章标签： c语言
于 2022-04-01 18:06:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45272323/article/details/123904367
版权

目录

1.简单链表

2.头插法

3.销毁 与 删除

4.逆序

5.头节点链表

1.简单链表

#include<stdio.h>

typedef struct node
{
    int data;
    struct node *next;
}node;

node *head = NULL;

void traverse()  //遍历
{ 
    node *p = head;

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

}

int main()
{
    node n1 = {1,NULL};
    node n2 = {2,NULL};
    node n3 = {3,NULL};
    node n4 = {4,NULL};
    node n5 = {5,NULL};
    node n6 = {6,NULL};
    node n7 = {7,NULL};
    node n8 = {8,NULL};
    node n9 = {9,NULL};
  
    head = &n1;
    n1.next = &n2;
    n2.next = &n3;
    n3.next = &n4;
    n4.next = &n5;
    n5.next = &n6;
    n6.next = &n7;
    n7.next = &n8;
    n8.next = &n9;
    n9.next = NULL;

    traverse();
    return 0;
}

2.头插法

 #include<stdio.h>
#include<stdlib.h>

typedef struct node
{
    int data;
    struct node *next;
}node;

node *head = NULL;

node *mk_node(int item)   //   分配空间
{
    node*p = (node *)malloc(sizeof(node)); // 分配空间 （node *）强制类型转换
    if (p == NULL)
    {
        printf("malloc failed\n");
        exit(1);
    }

    p -> data = item;  // 初始化
    p -> next = NULL;

    return p;  //返回节点地址
}

void free_node(node *p)  //释放节点函数 谁申请 谁释放
{
    free(p);
}

void insert_node(node *p)  // 头插法
{
    p -> next = head;
    head = p;
}

void traverse()  //遍历
{ 
    node *p = head;

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

}

int main()
{

    node *p;
    int i;

    for (i = 1; i < 10; i++)
    {    
        p = mk_node(i);  // 调用函数 给值
        insert_node(p);  // 头插法

        traverse();
    }
    return 0;
}

3.销毁 与 删除

#include<stdio.h>
#include<stdlib.h>

typedef struct node  //定义结构体
{
    int data;
    struct node *next;
}node;

node *head = NULL;  //定义头指针 指 链表开头

node *mk_node(int item)   //   分配空间
{
    node*p = (node *)malloc(sizeof(node)); // 分配空间 （node *）强制类型转换
    if (p == NULL)
    {
        printf("malloc failed\n");
        exit(1);
    }

    p -> data = item;  // 初始化
    p -> next = NULL;

    return p;  //返回节点地址
}

void free_node(node *p)  //释放节点函数 谁申请 谁释放
{
    free(p);
    p = NULL;
}

void insert_node(node *p)  // 头插法
{
    p -> next = head;
    head = p;
}
void insert_node_l2b(node *p)//插入排序
{
    if(head == NULL)
    {
        head = p;
        return;
    }

    if(p->data < head->data)//在head的前
    {
        insert_node(p);
        return;
    }


    node *pre = head;//在head的后 

    while(pre->next != NULL)
    {
        if(pre->next->data >= p->data)//pre下一个节点数值大于p　则跳出循环
        {
            break;
        }
        pre = pre->next;
    }
    p->next = pre->next;
    pre->next = p;
}


void traverse()  //遍历
{ 
    node *p = head;

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

node *search(int target)  //查找  
{ 
    node *p = head;

    while( p != NULL)
    {
        if (p->data  == target)
        {
            return p;
        }
        p = p ->next;
    }
    return NULL;
}

void rm_node(node *p)   //删除
{
    if (head == p)  //在第一个情况 头
    {
        head = head->next;
        return ;
     }

    node *pre = head;  //从头结点的下一个节点开始删除

    while (pre->next != NULL) 
    {
        if (pre->next == p)
        {
            pre->next = p->next; // 直接跳过删除目标
            p->next = NULL;
            return;
        }
        pre = pre->next;
    }

}

void destroy()  // 销毁节点
{
    node *p;

    while (head != NULL)
    {
      p = head;
      head = head->next;
      free_node(p);
    }
}

int main()
{

    node *p;
    int i;
    int target;

    for (i = 1; i < 10; i++)
    {    
        p = mk_node(i);  // 调用函数 给值
        insert_node(p);  // 头插法
    }

    traverse();       //遍历
    scanf("%d",&target);
    p = search(target);
    if (p == NULL)
    {
      printf("can't find %d\n", target);
    }else
    {
      printf("%p %d %d\n",p, p-> data, target);
      rm_node(p);
      traverse();
      printf("%d\n",p->data);
      free_node(p);
    }

    destroy();
    traverse();

    return 0;
}

4.逆序

void reverse()
{
    node *p;
    node *nhead = head;
    head = NULL ;

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

        insert_node(p);
    }
}

5.头节点链表

#include<stdio.h>
#include<stdlib.h>
#include<time.h>

//头结点链表 

typedef struct node  //定义结构体
{
    int data;
    struct node *next;
}node;

node sentinel  = {0,NULL};   //初始化
node *head = &sentinel;      

node *mk_node(int item)   //   分配空间
{
    node*p = (node *)malloc(sizeof(node)); // 分配空间 （node *）强制类型转换
    if (p == NULL)
    {
        printf("malloc failed\n");
        exit(1);
    }

    p -> data = item;  // 初始化
    p -> next = NULL;

    return p;  //返回节点地址
}

void free_node(node *p)  //释放节点函数 谁申请 谁释放
{
    free(p);
    p = NULL;
}

void insert_node(node *p)  // 头节点
{
    p -> next = head -> next;
    head -> next= p;
}

void insert_node_l2b(node *p)  //插入排序
{
    node *pre = head;

    while(pre ->next != NULL)
    {
       if (pre->next->data >= p->data)
       {
           break;
       }
       pre = pre ->next;
    }

    p ->next =pre->next;
    pre ->next = p;
}

void traverse()  //遍历
{ 
    node *p = head -> next;

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

node *search(int target)  //查找  
{ 
    node *p = head -> next;

    while( p != NULL)
    {
        if (p->data  == target)
        {
            return p;
        }
        p = p ->next;
    }
    return NULL;
}

void rm_node(node *p)   //删除
{
    

    node *pre = head;  //从头结点的下一个节点开始删除

    while (pre->next != NULL) 
    {
        if (pre->next == p)
        {
            pre->next = p->next; // 直接跳过删除目标
            p->next = NULL;
            return;
        }
        pre = pre->next;
     }

}

void destroy()  // 销毁节点
{
    node *p;

    while (head -> next != NULL)
    {
      p = head -> next;
      head -> next = p->next;
      free_node(p);
    }
}

void reverse()  //逆序
{
    node *p;
    node *nhead = head -> next;
    head -> next= NULL ;

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

        p->next = NULL;
        insert_node(p);
    }
}

int main()
{

    node *p;
    int i;
    int target;
    int data;
    srand(time(NULL));

    for (i = 1; i < 10; i++)
    {    
        data = rand() % 100 + 1;  //随机数
        p = mk_node(data);  // 调用函数 给值
        insert_node_l2b(p);  // 
    }

    traverse();       //遍历
    scanf("%d",&target);
    p = search(target);
    if (p == NULL)
    {
      printf("can't find %d\n", target);
    }else
    {
      printf("%p %d %d\n",p, p-> data, target);
      rm_node(p);
      traverse();
      printf("%d\n",p->data);
      free_node(p);
    }
    reverse();
    traverse();

    destroy();
    traverse();

    return 0;
}

是小皓呀
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
优化Traverse系列函数
wendy小橘子的博客
05-25 2842
优化后的Traverse.cpp： /*---- Includes ------------------------*/ #include "pch.h" #include "windows.h" #include <stdio.h> #include "Traverse.h" /*---- Static Function Statements ------------------------*/ /* *@brief 遍历搜索[target_dir]路径下的目标文件,并对符合条件的文件执行
C语言链表相关面试题.zip
03-13
C语言链表相关的面试题在软件开发领域的面试中是非常常见的，这是因为链表作为一种基本的数据结构，对于理解数据结构、算法以及内存管理等方面有着重要的作用。以下是一些关于C语言链表的面试题及其详细解释。 1. ...
在c语言中利用链表常见问题,C语言，链表中遇到棘手有关问题
weixin_30767895的博客
05-23 435
C语言，链表中遇到棘手问题/*2014年8月10日15:20:06单链表*/#include#includetypedefstructNode{intdata;structNode*pNext;}NODE,*PNODE;PNODECreatelist(void);voidTraverse(PNODE);intlength_list(PNODE);intmain(vo...
关于数据结构（c语言）中，线性表中链式结构的大部分操作的代码实现
weixin_60700743的博客
09-13 616
本篇文章将要介绍的，是线性表（逻辑结构）中的链式结构（存储结构），是线性表的基础之一，而在下列程序中，将要通过对链表的创建、判空、遍历输出、长度输出、升序排序（冒泡排序）、插入、删除的分段过程，对整体代码进行分析与解剖。
c语言循环队列代码,C语言实现循环队列
weixin_35361584的博客
05-19 630
本文实例为大家分享了c语言实现循环队列的具体代码，供大家参考，具体内容如下注意事项：1、循环队列，是队列的顺序表示和实现。因为是尾进头出，所以和顺序栈不同的是需要将顺序队列臆造成一个环状的空间，以便在尾部添加满之后从头部空位开始插入。2、也可以使用数组队列，也就是不能动态增长的顺序队列，这样不需要每次取模最大值来构成环形空间。每次插入新的队列尾元素时，尾指针增1，每当删除队列头元素时，头指针增1。...
【C++数据结构】遍历显式数组模板函数
Jasmine-Lily的博客
11-28 206
【C++数据结构】遍历显式数组模板函数
c语言链表的基本操作.rar
03-28
本压缩包文件"**c语言链表的基本操作.rar**"提供的是关于C语言实现链表操作的详细教程，主要涵盖以下几个关键知识点： 1. **链表的定义**：链表由一系列节点组成，每个节点包含数据域和指针域，指针域指向下一个...
C语言链表基本操作.docx
10-10
它与数组不同，数组中的元素在内存中是连续存储的，而链表则由一系列分散在内存各处的节点组成，每个节点通过指针链接到下一个节点。这使得链表在处理动态数据集时具有更大的灵活性。 首先，定义链表节点结构体是...
c语言链表的基本操作.docx
最新发布
07-04
在 C 语言中，链表是一种常见的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。以下是链表的基本操作及其实现： 定义链表节点结构体 首先，定义一个链表节点的结构体，包含数据和指向下一...
List：：traverse遍历
热门推荐
ganxiang2011的博客
05-28 1万+
声明：// 遍历 void traverse(void (*)(T&)); //遍历，依次实施visit操作（函数指针，只读或局部性修改） template <typename VST> //操作器 void traverse(VST&); //遍历，依次实施visit操作（函数对象，可全局性修改）定义：template <typename T> void List<T>::tra
Java 栈
冲冲冲的博客
01-09 86
java实现栈 栈是一种先进后出的数据结构，最后入栈的元素，最先读取出来。就像向箱子里放书一样，最后放进去的那本书，我们可以最先从箱子里取出来。 栈可以分为静态栈(数组实现)和动态栈(链表实现) Java实现动态栈 通过链表实现栈，我们可以想象有个栈顶节点，当入栈的时候，原先的栈顶节点成为新的节点后继节点，新的节点成为新的栈顶节点。同理，出栈的时候，讲栈顶节点弹出，第二个节点成为新的栈顶节点。 ...
Simple Tree Traverse（遍历）
csdn_cinderella的博客
05-16 1071
遍历算法 （the first node as the root node） 1．先（根）序遍历的递归算法定义： 若二叉树非空，则依次执行如下操作： ⑴ 访问根结点； ⑵ 遍历左子树； ⑶ 遍历右子树。 2．中（根）序遍历的递归算法定义： 若二叉树非空，则依次执行如下操作： ⑴遍历左子树； ⑵访问根结点； ⑶遍历右子树。 3．后（根）序遍历得递归算法定义： 若
【C语言】【数据结构】线性表（顺序+链式）基本操作
weixin_60897770的博客
10-22 1300
以下为本人大学期间某上机作业，分享给大家，如有不足欢迎指出！实验三 线性表的基本操作。实验四 线性链表的基本操作
void Traverse()//while( walker!=rear) { printf("%c",buff[walker]); walker=(walker+1)%10;
autumn20080101的专栏
05-10 688
// StaticQuene.cpp : Defines the entry point for the console application. // #include "stdafx.h" struct StaticQuene { private: char buff[10]; int front; int rear; public: bool isFull() { retur
c语言学习笔记（13）——链表
iteye_709的博客
08-07 127
链表算法：1.通俗定义：解题的方法和步骤2.狭义定义：对存储数据的操作 3.广义定义：广义的算法也叫泛型无论数据是如何存储的，对数据的操作都是一样的 我们至少可以通过两种结构来存储数据数组1.需要一整块连续的存储空间，内存中可能没有2.插入元素，删除元素效率极低。3.查找数据快链表1.查找效率低2.不需要一块连续的内存空间2.插入删除元素效率高 专业术语头指针存放头结点地址的指针变量头结点...
数据结构和算法学习指南
fdl123456的博客
01-07 1193
预计阅读时间：9 分钟这是好久之前的一篇文章学习数据结构的框架思维的修订版。之前那篇文章收到广泛好评，没看过也没关系，这篇文章会涵盖之前的所有内容，并且会举很多代码的实例，谈谈如何使...
树的三种遍历方式（C语言实现）
weixin_34007886的博客
10-27 323
//************************************************************************* // 【前序】遍历算法 //二叉树不空，先访问根结点，然后前序遍历左子树，再前序遍历右子树 //***********************************************************************...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值