C语言-单向链表学习node

最新推荐文章于 2024-04-26 17:29:19 发布
最新推荐文章于 2024-04-26 17:29:19 发布
阅读量575 收藏 1
点赞数
分类专栏： c语言数据结构-单向链表 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tiantianhaoxinqing__/article/details/112367409
版权

说明: 在此非常感谢笔记中涉及到的UP主上传的视频，因为此笔记是通过学习UP主的视频后根据视频记录的笔记。

建议：建议学习观看笔记中的视频时候一定要自己去通过键盘做笔记或者将代码在本地重现，不要试图通过大脑理解或者笔记本记录下来，因为很多时候通过键盘的输入可以加深对程序的理解和记忆，另一方面电子笔记利于随时随地的温习。

两个小时完全学会链表，学不会来找我，亲自教你~数据结构专场

  1. 内存4区：

    1. 代码区：函数代码–存放在代码区 函数名就是这个函数的地址。
    2. 全局区：全局的变量 字符串常量 初始化：int a;
    3. 栈区：5M–10M ，比较小，进肯能 告诉计算机 int double char 定义一个变量 c系统开辟 释放
    4. 堆区：自己定义大小，加载的数据用完后好要不要继续用，自己开辟，定义，释放
      #include <stdio.h>
#incldue <stdlib.h>
int main()
{
    int *p;
    //开辟内存, 开辟大小是字节
    p = (int *)malloc(sizeof(int));
    
    //释放内存
    free(p);
    
    exit(0);
}

  2. 数据结构：高速飙车，井然有序

    1. 用一套具体的方法来管理这些内存，高效，有序。

  3. 链表：火车站长的管理艺术。

    1. c是面向过程的。

    2. 结点：每一块内存
      [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4tdWa6L0-1610092841249)(en-resource://database/527:1)]
      [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ivki2hq2-1610092841251)(en-resource://database/528:1)]

    3. 数据：每一个结点中存放数据

      main.cpp
      #include <stdio.h>
#incldue <stdlib.h>
#include 'list.h'

void ShowData(Node* pnode)
{
   printf("x = %d \t y = %d \n", pnode->data.x,pnode->data.y);
}
int main()
{
   List *pList;//指针变量
   ListInit(&pList);//
   Node* p = (Node*)malloc(sizeof(Node));
    pnode->data.x = 10;
   pnode->data.y = 3;
   pnode->pnext = Null
   InserList(pList, pnode);
   
   TraverList(plist,ShowData);
   
   
   exit(0);
}
      list.cpp 写链表，此时数据，结点，无关
      
#include <stdio.h>
#incldue <stdlib.h>
#include 'list.h'

//r如何判断链表是空的，初始化链表
/*
* 功能：初始化链表，成功返回1，失败返回0
* 定义为二级指针是因为值传递时候c语言作用域问题，更改传递值的时候会借助指针和地址进行数值传递
*/
int ListInit(List **pplist)
{
    *（ppList） = (List*)malloc(sizeof(List));
    
    if(*ppList ==NULL)
        return 0;
    else
    {
        (*ppList)->pfront = NULL;
        (*ppList)->prear = NULL;
        (*ppList)->count = 0;
     }
     return 1;
     
}
/*
判断链表是否为空
*/
int IsEmpty(List* plist)
{
    if(plist->count ==0)
        return 1;
    else
        return 0;
}


/*
插入结点
在plist这个链表中插入pnode结点
*/
void InserList(List* plist,Node* pnode)
{
//尾插法
    if(IsEmpty(plist))
    {
        plist->pfront = pnode;
       
    }
    else
    {
        plist->prear->pnext = pnode;
       
    }
     plist->prear = pnode;
     plist->count ++;
}


//遍历链表
//留接口
//遍历pList这个链表
//void (*Traver)(Node* pnode) 函数指针
/*
指向指针的函数
函数
指针：Traver
指向：返回值类型为 void 参数为Node*
*/
void TraverList(List *pList,void (*Traver)(Node* pnode))
{
     Node *ptemp = plist->pfront;//ptemp指向第一个结点
     int listsize = plist->count;//有几个结点
     
     while(listsize)
     {
         Traver(ptemp);
         ptemp = ptemp->pnext;
         listsize--;
     }
}
      list.h
      //数据
 struct Data
{
    int x;
    int y;
};
//结点 1024
struct Node
{
    Da1ta data;//数据
    st0r uct Node *pnext;
};
//链表
struct List
{
   Node* pfront;//第一个结点的指针
   Node* prear;//最后一个结点的指针
   int count;//有多少指针
};

C语言核心重点知识教程——链表！理论加项目实乃学习效率最快

#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
//1 创建节点


//1.1 节点类型
struct Node{
     int data;//存储数据

     struct Node* pNext;//连接节点

};
//给类型定义
//typedefine struct Node node;

// 1.2 创建节点的函数
struct Node createNode(int);
//增
//尾增法
bool appenNodetoTree(struct Node** list, int);
//删

//改

//查
//从头到尾查
void travel(struct Node* head){
    struct Node* p = head;
    while(1){
    if(NULL==p) break;
    printf("%d",p->data);
    
    p= p->pNext;

}
printf("\n");
}


int main(int argc, char* argv){

    node * list = NULL;
    bool ret;
    struct node* pFind;
    
    for(int i = 0; i<6;i ++）{
        ret = appenNodetoTree(&list,i);
        if(ret)
            printf("appendNodeTree :%d succed! \n");
         else
            printf("失败了 @-@ \n");
    }
    
    
    travel(list);
    
   pFind = findNodePos(list,4);
   
   if(pFind)printf("找到了：%d \n",pFind->data);
   else
    printf("not found\n");

    eixt(0);


}

//制造节点函数
struct Node* createNode(int data){
    //申请空间 
    struct Node* pNew = (struct Node *)malloc(sizeof(struct Node));
    if(NULL == pNew) return NULL;
    //把数据设置好
    pNew->data = data;
    pNew->pNext = NULL;

    return pNew;
}

//尾增法
bool appenNodetoTree(struct Node** list, int data){
    //防御性编程
    if(NULL == list) return false;
    if(* list  == NULL){
        *list = createNode(data);
        return ture;
    }
    //找到尾部
    struct Node* pTail = list;
    /*
    while(1){
    if(NULL==pTail->pNext) break;
    pTail= pTail->pNext;
     }
     */
     while(pTail->pNext) pTail = pTail->pNext;
    //添加数据
    pTail-pNext = createNode(data);
    
    return true;
}
//查找
struct Node* findNodePos(struct Node* head, int findData){
    while(head){
        if(head->data == findData) return head;
        head = head->pNext;
    }
    return NULL;
}

C语言 链表基础知识清晰讲解（黑马）

  1. 链表是由一系列节点组成的，每个节点包含两个域，一个是数据域，数据域用来保存用户数据。另外一个书指针域，保存下一个节点的地址。
  2. 链表在内存中是非连续的。
  3. 链表在指定位置插入和删除都不需要移动元素，只需要修改指针即可
  4. 查找效率低一些，相对于数组
  5. 链表相对于数组，多了指针域空间开销
  6. 拿到链表第一个节点，就相当于拿到了整个链表。
main.c
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

//链表结点类型定义
struct LinkNode
{
    int data;
    struct LinkNode * next;
}

viod test()
{
    struct LinkNode node1 = {10, NULL};
    struct LinkNode node2 = {20, NULL};
    struct LinkNode node3 = {30, NULL};
    struct LinkNode node4 = {40, NULL};
    struct LinkNode node5 = {50, NULL};
    struct LinkNode node6 = {60, NULL};
    
    node1.next = &node2;
    node2.next = &node3;
    node3.next = &node4;
    node4.next = &node5;
    node5.next = &node6;
    
    //如何遍历链表
    //先定一个辅助指针变量
    struct LinkNode *pCurrent
}

int main()
{
    exit(0);
}

#####  main.c
void test()
{
    //初始化链表
    struct LinkNode *header = Init_LinkList();
    //打印链表
    Foreach_LinkList(header);
    
    //插入数据
    InsertByValue_LinkList(header,300,6);
    
     //打印链表
    Foreach_LinkList(header);
    
    //清空链表
    Clear_LinkList（header);
    
    RemoveByValue_linList(head,200);
     Foreach_LinkList(header);
     
     //销毁链表
     Destroy_LinkList(header);
 
    
}
int main()
{
    test();

    exit(0);
}
###### LinkList.h

    //定义节点数据
    struct LinkNode
    {
        int data;
        struct LinkNode *next;
    }
    
    //初始化链表
    struct LinkNode *Init_LinkList();
    //在值为oldval的后面插入一个新的数据newval
    viod InsertByValue_LinkList(struct LinkNode *header,int oldval,int newval);
    
    //删除值为val的节点
    void RemoveByValue_linList(sturct LinkNode *header,int delValue);
    
    //遍历
    void Foreach_LinkList(struct LinkNode *header);
    
    //销毁
    void Destroy_LinkList(struct LinkNode *header);
    
    //清空、
    void Clear_LinkList(struct LinkNode *header);

    
    ###### LinkList.c

     //初始化链表
    struct LinkNode *Init_LinkList()
    {
        //创建头结点
        sturct LinkNode *header = malloc(sizeof(struct LinkNode));
        header->data = 1;
        header->next = NULL;
        
        //尾部指针
        struct LinkNode *pRear = header;
        int val = 1;
        while(true)
        {
            printf("请输入插入的数据:  \n);
            scanf("%d",&val);
            if(val == 1)
            {
                break;
            }
            //先创建新节点
            struct LinkNode *newnode  = malloc(sizeof(struct LinkNode));
            newnode->data = val;
            newnode->next = NULL;
            
            //新节点插入列表中、
            pRear->next = newnode;
            
            //更新尾部指针只想
            pRear = newnode;
        }
        return header;
    }
    //在值为oldval的后面插入一个新的数据newval
    viod InsertByValue_LinkList(struct LinkNode *header,int oldval,int newval)
    {
        if(NULL == header)
        {
            return;
        }
        //两个辅助指针变量
        struct LinkNode *pRrev = header;
        struct LinkNode *pCurrent = pPrev->next;
        
        while(pCurrent->data != NULL)
        {
            if(pCurrent->data == oldval)
            {
                break;
            }

            pPrev = pCurrent;
            pCurrent = pCurrent->next;
        }
        if(NULL == pCurrent)
        {
            return;
        }
        
        //先创建新节点
        struct LinkNode *newnode = malloc(sizeof(struct LinkNode));
        newnode->data = newval;
        newnode->next = NULL;
        
        //新节点插入到链表中
        newnode->next = pCurrent;
        pPrev->next = newnode;
        
    }
    
    //删除值为val的节点
    void RemoveByValue_linList(sturct LinkNode *header,int delValue);
    {
        if(NULL == header)
        {
            return;
        }
        //两个辅助指针变量
        struct LinkNode *pPrev = header;
        struct LinkNode *pCurrent = pPrev->next;
        
        while(pCurrent != NULL)
        {
            if(pCurrent->data == delValue)
            {
                break;
            }
            //移动两个辅助指针
            pPrev = pCurrent;
            pCurrent = pCurrent->next;
        }
        if(NULL == pCurrent)
        {
            return;
        }
        
        //重新建立待删除节点的前驱和后继节点的关系
        pPrev->next = pCurrent->next;
        //释放删除节点内存
        free(pCurrent);
        pCurrent = NULL;
    }
    
    //遍历
    void Foreach_LinkList(struct LinkNode *header)
    {
        if(NULL == header)
        {
            return;
        }
        //辅助指针变量
        struct LinkNode *pCurrent = header->next;
        
        while(pCurrent != NULL)
        {
            printf("%d",pCurrent->data);
            pCurrent = pCurrent->next;
        }
        
    }
    
    //销毁
    void Destroy_LinkList(struct LinkNode *header)
    {
        if(NULL == header)
        {
            return;
        }
        //辅助指针变量
        struct LinkNode *pCurrent = header->next;
        
        while(pCurrent != NULL)
        {
            //先保存下一个节点地址
            struct LinkNide *pNext = pCurrent->next;
            //释放当前节点
            free(pCurrent);
            //指针向后移动
            pCurrent= pNext;
            
        }
    }
    //清空、
    void Clear_LinkList(struct LinkNode *header)
    {
        if(NULL == header)
        {
            return;
        }
        //辅助指针变量
        struct LinkNode *pCurrent = header->next;
        
        while(pCurrent != NULL)
        {
            //先保存一下当前节点的下一个节点
            struct LinkNode *pNext = pCurrent->next;
            //释放当前节点内存
            free(pCurrent);
            
            //pCurrent指向下一个节点
            pCurrent = pNext;
        }
        header->next = NULL;
    }
多云转晴，适合debug
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言创建一个节点Node(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
02-22 3812
C语言创建一个节点Node节点结构体定义C语言创建一个节点Node完整源码 节点结构体定义 struct node { struct node *leftNode; int data; struct node *rightNode; }; C语言创建一个节点Node完整源码 #include <stdio.h> #include <stdlib.h> struct node { struct node *leftNode; int dat
c语言使用node类型指针,C语言中关于指针等相关理解和使用事宜
weixin_39923945的博客
05-19 1108
作者：心叶时间：2018-04-21 17:24定义指针是一个变量，其值是另一个变量的地址，地址代表的是在内存中的位置。需要记住的是，数组变量本身就是一个指针。地址的类型地址是存在类型的，是不是感觉好奇怪，指针不是代表一个地址的吗，地址还有类型吗？看一个例子：int *ip; /* 一个整型的指针 */double *dp; /* 一个 double 型的指针 */float ...
c语言使用node类型指针,C语言利用 void 类型指针实现面向对象类概念与抽象
weixin_39976733的博客
05-19 545
不使用C++时，很多C语言新手可能认为C语言缺乏了面向对象和抽象性，事实上，C语言通过某种组合方式，可以间接性的实现面对对象和抽象。不过多态和继承这种实现，就有点小麻烦，但是依然可以实现。核心：利用 void 类型指针，可以指向任意类型指针。1 //基本代码2 void* p;3 p = (void*) "HelloWorld";45 char* str;6 str = (char*) p;78 ...
带头结点的单链表（插入，删除，逆序）
weixin_50603017的博客
01-08 1601
#include <stdio.h> #include <stdlib.h> struct node { int data; struct node *pNext; }; /* 函数名: createNode 函数参数：data--结点的数据元素 函数返回值： 返回堆区创建出来的结点首地址 函数作用： 创建一个新结点 */ struct node* createNode(int data) { struct node *p = (struct nod.
数据结构特性解析 (三) 链表
lt的博客
06-30 3283
前言 链表是一种比较简单的数据结构,你可以在编程环境下轻松写出一个链表,甚至生活中也有很多链表的提现,比如铁链,文章底部的下一篇上一篇都可以称作链表数据结构 描述 链表像铁链一样,一个链节点连着另一个或另两个节点. 在计算机中,一般是每一个节点除了存储自身的信息外,还会存储另一个节点的内存地址,相当于链接到下一个节点,如下图所示 (红色是链表的节点,黑色是被其他数据占用的内存) 可以看到链表可以不按照顺序存,只需要指向下一个地址 特点 1.链表相对于数组,内存占用更高 上面的代码就
分文件实现温湿度数据管理系统项目
lzh201864031的博客
05-25 1132
目标：0、要点：1、函数声明的注意点：2、函数跨文件声明不成熟方法1：头文件间接声明 3、函数跨文件声明不成熟方法2：分函数（在.h文件中） 4、函数跨文件声明不成熟方法3：分函数（在.c文件中） 5、函数的分文件原理：将上述三种方法（主要是方法1和方法3）的优势进行结合，可以总结出自定义函数的分文件方法。如图示例： 1、变量的三特性：我们之前学过变量的四要素，现在看看变量具有哪三个特性。2、内存的分区：这个内存我们一般认为是虚拟内存（32位平台下的虚拟内存有4G大小，gcc编译器就是64位平台），对其划分
C语言实现输出链表中倒数第k个节点
12-31
运行本文所述实例可实现输入一个单向链表，输出该链表中倒数第k个节点。 具体实现方法如下： /* * Copyright (c) 2011 alexingcool. All Rights Reserved. */ #include using namespace std; int array[] = {5, 7,...
数据结构笔记：单向链表
12-22
链表与顺序表都是线性表 知识点补充 b = 20 a = 'achar' a = b # 在python中，所有的变量保存的都是值的地址（就相当于c语言中的指针） # 等号右边表示执行，=b中的b就是执行，根据值的地址取到b的值，就成了a=20，...
单向链表的demo - p_node_link.rar
11-20
p_node_link.rar是一个完整的C语言链表demo，放到linux系统下直接make编译即可。demo中总共有链表操作的10中方法及调用案例。供大家参考学习使用。
C语言实现单链表实现方法
12-31
链表和我们之前实现过的顺序表一样，都是简单的数据结构，链表分为单向链表、双向链表、循环链表。而单向链表又分为两种实现方法，一种为带头节点的单链表，一种为不带头节点的单链表。我们来具体看看不带头节点的...
第11章 动态数据结构-链表-21
08-03
第11章 动态数据结构的C语言实现单向链表-2int power;struct node *next;建立一个单向链表1 创建节点：2 链：使每个节点的指针域存
数据结构——二叉树练习（深搜广搜）
最新发布
qq_67693066的博客
04-26 823
数据结构——二叉树练习
408数据结构专项2011
m0_60441630的博客
04-22 306
个人觉得这种思路在考场上思考起来比较慢，没有接触过类似的思想并不会很快想出来。并且最优解与该题暴力解难度与分值性价比的原因，并没有深入学习。思考：将两条序列整合为一条序列，然后对整合后的序列判断中位数。
408专项数据结构2013
m0_60441630的博客
04-23 170
思考：对序列进行排序后，判断一段连续序列的长度是否超过n/2;用快排注意平均时间复杂度是O(nlogn)，归并才是真正的最坏O(nlogn)。但我不确定实际书写的时候能否用sort函数代替加快速率，如果不能，我大概率不会选择去手写一个快排。思考：个人理解就是军团打架，一v一剩下来的肯定是最多军团的人。正式一点说应该是摩尔投票法。没必要纠结名字，思想很简单。思考：暴力双循环，但时间复杂度有点低，拿分可以拿9分。
TreeSet 和 TreeMap 和 HashSet 和 HashMap
m0_61731585的博客
04-26 534
TreeMap，TreeSet，HashMap，HashSet 的区别和联系，底层是什么；哈希表，哈希碰撞的出现和解决，一些题目
数据结构——二叉树的操作 (层序遍历)（C++实现）
qq_67693066的博客
04-26 433
数据结构——二叉树的操作（层序遍历）（C++实现）
C++信息学奥赛 数据结构认识
博樽
04-23 733
数据结构认识的练习训练
了解数组：算法与应用
JAZJD的博客
04-21 401
通过本文的介绍，希望读者能够更加深入地理解数组的基本操作、常见算法以及实际应用，并能够灵活运用这些知识解决实际问题。数组是计算机科学中最基本的数据结构之一，它的应用涵盖了从简单的数据存储到复杂的算法实现。冒泡排序是一种简单的排序算法，它重复地遍历数组，依次比较相邻的两个元素，并交换它们直到整个数组有序。线性搜索是一种简单直观的搜索算法，它逐个检查数组中的元素，直到找到目标元素或遍历完整个数组。将数组逆序是另一个常见的操作，可以通过交换数组的首尾元素、次首尾元素等方式实现。// 返回目标元素的索引。
算法和数据结构4.23:
sinat_26916241的博客
04-23 304
L1排序和查找算法：复杂度分析查找算法：顺序查找、二分查找、其他查找算法排序算法：冒泡排序、快速排序、其他排序算法L2数据结构-线性表：链表、栈、队列、堆L3数据结构-非线性表：二叉树、图。
C语言实现单向链表加注释
06-11
以下是C语言实现单向链表并加上注释的代码示例： ```c #include #include // 定义单向链表结构体 struct Node { int data; // 数据域 struct Node* next; // 指针域 }; int main() { // 初始化链表头节点 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值