linux------数据结构

已于 2024-08-28 19:57:39 修改
阅读量285 收藏 1
点赞数 1
文章标签： linux 数据结构 算法
于 2024-08-27 18:59:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mutou8541/article/details/141610146
版权

数据结构：

1.衡量一个程序是否优秀：
    1.时间复杂度：
        数据量增长与程序运行时间的比例关系以函数描述称为时间渐进复杂度函数,简称时间复杂度
        O(c) > O(logn) > O(n) > O(nlogn) > O(n^2) > O(n^3) > O(2^n)
    2.空间复杂度：
        数据量增长与程序所占用空间的比例关系称为空间复杂度

2.数据结构:
    数据之间的关系 
        逻辑结构：
            1. 线性结构
                一对一 表
            2. 非线性结构
                一对多 树 
                多对多 图
        
        存储结构：
            1. 顺序存储结构
            2. 链式存储结构
            3. 离散存储
            4. 索引存储

3.程序：
    程序 = 数据结构 + 算法

4.数据结构： 
    顺序表
    链式表
    顺序栈
    链式栈
    顺序队列
    链式队列 
    树 
    二叉树
    常见的排序查找算法

    安装内存泄露检测工具：
    sudo apt-get install valgrind

    检测方法：
    valgrind --tool=memcheck --leak-check=full ./a.out

5.顺序表:

1.整形

#include "seqlist.h"
#include <stdio.h>

int ShowFun(void *pElement, void *arg)
{   
    int *pData = pElement;

    printf("%d ", *pData);

    return 0;
}

int UpdateFun(void *pElement, void *arg)
{
    int *pData = pElement;

    if (*pData == 4)
    {
        *pData = 40;
    }

    return 0;
}

int FindFun(void *pElement, void *arg)
{
    int *pData = pElement;

    if (*pData == 30)
    {
        return 1;
    }
    else 
    {
        (*(int *)arg)++;
    }

    return 0;
}

int main(void)
{
    SeqList *pseqlist = NULL;
    int val = 0;
    int n = 0;

    pseqlist = CreateSeqList(10);
    AppendSeqList(pseqlist, 1);
    AppendSeqList(pseqlist, 2);
    AppendSeqList(pseqlist, 3);
    AppendSeqList(pseqlist, 4);
    AppendSeqList(pseqlist, 5);
    PosInsertSeqList(pseqlist, 0, 10);
    PosInsertSeqList(pseqlist, 3, 30);

    printf("===============================\n");
    printf("顺序表当前元素个数:%d/%d\n", GetCountSeqList(pseqlist), GetCapacitySeqList(pseqlist));
    printf("===============================\n");
    printf("元素内容:\n");
    ForeachSeqList(pseqlist, ShowFun, NULL);
    printf("\n");
    printf("===============================\n");
    printf("修改元素:\n");
    ForeachSeqList(pseqlist, UpdateFun, NULL);
    printf("===============================\n");
    printf("元素内容:\n");
    ForeachSeqList(pseqlist, ShowFun, NULL);
    printf("\n");
    printf("===============================\n");
    printf("查找元素:\n");
    n = 0;
    ForeachSeqList(pseqlist, FindFun, &n);
    printf("n = %d\n", n);
    printf("===============================\n");
    printf("删除元素:\n");
    n = 0;
    ForeachSeqList(pseqlist, FindFun, &n);
    DeleteSeqList(pseqlist, n);
    DeleteSeqList(pseqlist, 0);
    DeleteSeqList(pseqlist, GetCountSeqList(pseqlist)-1);
    printf("===============================\n");
    printf("元素内容:\n");
    ForeachSeqList(pseqlist, ShowFun, NULL);
    printf("\n");
    printf("===============================\n");
    ClearSeqList(pseqlist);
    printf("元素内容:\n");
    ForeachSeqList(pseqlist, ShowFun, NULL);
    printf("\n");
    printf("===============================\n");
    DestroySeqList(&pseqlist);

    return 0;
}
#include "seqlist.h"
#include <stdlib.h>
#include <stdio.h>

//创建顺序表
SeqList *CreateSeqList(int MaxLen)
{
    SeqList *pTmpList = NULL;

    //1.申请标签空间
    pTmpList = malloc(sizeof(*pTmpList));
    if (NULL == pTmpList)
    {
        return NULL;
    }

    //2.对标签中的所有成员赋值
    pTmpList->cLen = 0;
    pTmpList->tLen = MaxLen;
    
    //3.申请存放数据的空间
    pTmpList->pData = malloc(MaxLen * sizeof(DataType));
    if (NULL == pTmpList->pData)
    {
        return NULL;
    }

    //4.返回标签首地址

    return pTmpList;
}

//顺序表是否已满
int IsFullSeqList(SeqList *pTmpList)
{
    return pTmpList->cLen == pTmpList->tLen ? 1 : 0;
}

//顺序表是否为空
int IsEmptySeqList(SeqList *pTmpList)
{
    return pTmpList->cLen == 0 ? 1 : 0;
}

//获得顺序表中元素个数
int GetCountSeqList(SeqList *pTmpList)
{
    return pTmpList->cLen;
}

//获得顺序表中元素的容量
int GetCapacitySeqList(SeqList *pTmpList)
{
    return pTmpList->tLen;
}

//末尾添加
int AppendSeqList(SeqList *pTmpList, DataType TmpData)
{
    if (IsFullSeqList(pTmpList))
    {
        return -1;
    }

    pTmpList->pData[pTmpList->cLen] = TmpData;
    pTmpList->cLen++;

    return 0;
}

//指定位置插入
//注意：
//  返回-1  表示顺序表已满
//  返回-2  表示插入数据的位置错误
int PosInsertSeqList(SeqList *pTmpList, int Pos, DataType TmpData)
{
    int n = 0;

    if (IsFullSeqList(pTmpList))
    {
        return -1;
    }

    //错误的插入位置
    if (!(Pos >= 0 && Pos <= pTmpList->cLen))
    {
        return -2;
    }

    for (n = pTmpList->cLen; n > Pos; n--)
    {
        pTmpList->pData[n] = pTmpList->pData[n-1];
    }
    pTmpList->pData[Pos] = TmpData;
    pTmpList->cLen++;

    return 0;
}

//元素遍历
//参数:
//   pFun:对遍历到的每个数据的操作方法
//   arg:对pFun函数的传参
//返回值:
//   成功返回0 
//   失败返回-1 
int ForeachSeqList(SeqList *pTmpList, int (*pFun)(void *Element, void *arg), void *arg)
{
    int i = 0;
    int ret = 0;

    for (i = 0; i < pTmpList->cLen; i++)
    {
        ret = pFun(&pTmpList->pData[i], arg);
        if (ret != 0)
        {
            return -1;
        }
    }

    return 0;
}

//删除
int DeleteSeqList(SeqList *pTmpList, int Pos)
{
    int i = 0;
    int n = 0;

    if (IsEmptySeqList(pTmpList))
    {
        return -1;
    }

    //删除元素的位置是否异常
    if (!(Pos >= 0 && Pos < pTmpList->cLen))
    {
        return -2;
    }

    for (n = Pos; n < pTmpList->cLen-1; n++)
    {
        pTmpList->pData[n] = pTmpList->pData[n+1];
    }
    pTmpList->cLen--;

    return 0;
}

//清0
int ClearSeqList(SeqList *pTmpList)
{
    pTmpList->cLen = 0;

    return 0;
}

//销毁
int DestroySeqList(SeqList **ppTmpList)
{
    free((*ppTmpList)->pData);
    free((*ppTmpList));
    *ppTmpList = NULL;

    return 0;
}
#ifndef __SEQLIST_H__
#define __SEQLIST_H__

typedef struct str 
{
    char data[128];
}str_t;

//存储数据类型 
typedef str_t DataType;

//顺序表标签结构
typedef struct list
{
    DataType *pData;        //存放数据空间首地址
    int tLen;               //最大存放元素个数
    int cLen;               //当前元素个数
}SeqList;

extern SeqList *CreateSeqList(int MaxLen);
extern SeqList *CreateSeqList(int MaxLen);
extern int IsEmptySeqList(SeqList *pTmpList);
extern int IsFullSeqList(SeqList *pTmpList);
extern int GetCountSeqList(SeqList *pTmpList);
extern int GetCapacitySeqList(SeqList *pTmpList);
extern int AppendSeqList(SeqList *pTmpList, DataType TmpData);
extern int PosInsertSeqList(SeqList *pTmpList, int Pos, DataType TmpData);
extern int ForeachSeqList(SeqList *pTmpList, int (*pFun)(void *Element, void *arg), void *arg);

#endif

2.字符串型

#include "seqlist.h"
#include <stdio.h>

int IpShowFun(void *pElement, void *arg)
{
    DataType *pData = pElement;

    printf("IP:%s\n", pData->data);
    printf("-------------------------\n");

    return 0;
}

int main(void)
{
    SeqList *pseqlist = NULL;
    int val = 0;

    pseqlist = CreateSeqList(10000);
    DataType TmpData1 = {"192.168.0.100"};
    AppendSeqList(pseqlist, TmpData1);
    
    DataType TmpData2 = {"192.168.0.110"};
    AppendSeqList(pseqlist, TmpData2);

    DataType TmpData3 = {"192.168.0.120"};
    AppendSeqList(pseqlist, TmpData3);

    DataType TmpData4 = {"192.168.0.130"};
    AppendSeqList(pseqlist, TmpData4);

    DataType TmpData5 = {"192.168.0.140"};
    AppendSeqList(pseqlist, TmpData5);

    printf("===============================\n");
    printf("当前IP个数:%d/%d\n", GetCountSeqList(pseqlist), GetCapacitySeqList(pseqlist));
    printf("===============================\n");
    printf("已经登录用户的IP列表\n");
    ForeachSeqList(pseqlist, IpShowFun, NULL);
    printf("===============================\n");
    
    return 0;
}
#include "seqlist.h"
#include <stdlib.h>
#include <stdio.h>

//创建顺序表
SeqList *CreateSeqList(int MaxLen)
{
    SeqList *pTmpList = NULL;

    //1.申请标签空间
    pTmpList = malloc(sizeof(*pTmpList));
    if (NULL == pTmpList)
    {
        return NULL;
    }

    //2.对标签中的所有成员赋值
    pTmpList->cLen = 0;
    pTmpList->tLen = MaxLen;
    
    //3.申请存放数据的空间
    pTmpList->pData = malloc(MaxLen * sizeof(DataType));
    if (NULL == pTmpList->pData)
    {
        return NULL;
    }

    //4.返回标签首地址

    return pTmpList;
}

//顺序表是否已满
int IsFullSeqList(SeqList *pTmpList)
{
    return pTmpList->cLen == pTmpList->tLen ? 1 : 0;
}

//顺序表是否为空
int IsEmptySeqList(SeqList *pTmpList)
{
    return pTmpList->cLen == 0 ? 1 : 0;
}

//获得顺序表中元素个数
int GetCountSeqList(SeqList *pTmpList)
{
    return pTmpList->cLen;
}

//获得顺序表中元素的容量
int GetCapacitySeqList(SeqList *pTmpList)
{
    return pTmpList->tLen;
}

//末尾添加
int AppendSeqList(SeqList *pTmpList, DataType TmpData)
{
    if (IsFullSeqList(pTmpList))
    {
        return -1;
    }

    pTmpList->pData[pTmpList->cLen] = TmpData;
    pTmpList->cLen++;

    return 0;
}

//指定位置插入
//注意：
//  返回-1  表示顺序表已满
//  返回-2  表示插入数据的位置错误
int PosInsertSeqList(SeqList *pTmpList, int Pos, DataType TmpData)
{
    int n = 0;

    if (IsFullSeqList(pTmpList))
    {
        return -1;
    }

    //错误的插入位置
    if (!(Pos >= 0 && Pos <= pTmpList->cLen))
    {
        return -2;
    }

    for (n = pTmpList->cLen; n > Pos; n--)
    {
        pTmpList->pData[n] = pTmpList->pData[n-1];
    }
    pTmpList->pData[Pos] = TmpData;
    pTmpList->cLen++;

    return 0;
}

//元素遍历
//参数:
//   pFun:对遍历到的每个数据的操作方法
//   arg:对pFun函数的传参
//返回值:
//   成功返回0 
//   失败返回-1 
int ForeachSeqList(SeqList *pTmpList, int (*pFun)(void *Element, void *arg), void *arg)
{
    int i = 0;
    int ret = 0;

    for (i = 0; i < pTmpList->cLen; i++)
    {
        ret = pFun(&pTmpList->pData[i], arg);
        if (ret != 0)
        {
            return -1;
        }
    }

    return 0;
}

//修改

//查询

//销毁

3.结构体

#include "seqlist.h"
#include <stdio.h>

int IpShowFun(void *pElement, void *arg)
{
    DataType *pData = pElement;

    printf("IP:%s\n", pData->address);
    printf("Port:%d\n", pData->port);
    printf("-------------------------\n");

    return 0;
}

int main(void)
{
    SeqList *pseqlist = NULL;
    int val = 0;

    pseqlist = CreateSeqList(10000);
    DataType TmpData1 = {"192.168.0.100", 30000};
    AppendSeqList(pseqlist, TmpData1);
    
    DataType TmpData2 = {"192.168.0.110", 30000};
    AppendSeqList(pseqlist, TmpData2);

    DataType TmpData3 = {"192.168.0.120", 30000};
    AppendSeqList(pseqlist, TmpData3);

    DataType TmpData4 = {"192.168.0.130", 30000};
    AppendSeqList(pseqlist, TmpData4);

    DataType TmpData5 = {"192.168.0.140", 30000};
    AppendSeqList(pseqlist, TmpData5);

    printf("===============================\n");
    printf("当前IP个数:%d/%d\n", GetCountSeqList(pseqlist), GetCapacitySeqList(pseqlist));
    printf("===============================\n");
    printf("已经登录用户的IP列表\n");
    ForeachSeqList(pseqlist, IpShowFun, NULL);
    printf("===============================\n");
    
    return 0;
}
#include "seqlist.h"
#include <stdlib.h>
#include <stdio.h>

//创建顺序表
SeqList *CreateSeqList(int MaxLen)
{
    SeqList *pTmpList = NULL;

    //1.申请标签空间
    pTmpList = malloc(sizeof(*pTmpList));
    if (NULL == pTmpList)
    {
        return NULL;
    }

    //2.对标签中的所有成员赋值
    pTmpList->cLen = 0;
    pTmpList->tLen = MaxLen;
    
    //3.申请存放数据的空间
    pTmpList->pData = malloc(MaxLen * sizeof(DataType));
    if (NULL == pTmpList->pData)
    {
        return NULL;
    }

    //4.返回标签首地址

    return pTmpList;
}

//顺序表是否已满
int IsFullSeqList(SeqList *pTmpList)
{
    return pTmpList->cLen == pTmpList->tLen ? 1 : 0;
}

//顺序表是否为空
int IsEmptySeqList(SeqList *pTmpList)
{
    return pTmpList->cLen == 0 ? 1 : 0;
}

//获得顺序表中元素个数
int GetCountSeqList(SeqList *pTmpList)
{
    return pTmpList->cLen;
}

//获得顺序表中元素的容量
int GetCapacitySeqList(SeqList *pTmpList)
{
    return pTmpList->tLen;
}

//末尾添加
int AppendSeqList(SeqList *pTmpList, DataType TmpData)
{
    if (IsFullSeqList(pTmpList))
    {
        return -1;
    }

    pTmpList->pData[pTmpList->cLen] = TmpData;
    pTmpList->cLen++;

    return 0;
}

//指定位置插入
//注意：
//  返回-1  表示顺序表已满
//  返回-2  表示插入数据的位置错误
int PosInsertSeqList(SeqList *pTmpList, int Pos, DataType TmpData)
{
    int n = 0;

    if (IsFullSeqList(pTmpList))
    {
        return -1;
    }

    //错误的插入位置
    if (!(Pos >= 0 && Pos <= pTmpList->cLen))
    {
        return -2;
    }

    for (n = pTmpList->cLen; n > Pos; n--)
    {
        pTmpList->pData[n] = pTmpList->pData[n-1];
    }
    pTmpList->pData[Pos] = TmpData;
    pTmpList->cLen++;

    return 0;
}

//元素遍历
//参数:
//   pFun:对遍历到的每个数据的操作方法
//   arg:对pFun函数的传参
//返回值:
//   成功返回0 
//   失败返回-1 
int ForeachSeqList(SeqList *pTmpList, int (*pFun)(void *Element, void *arg), void *arg)
{
    int i = 0;
    int ret = 0;

    for (i = 0; i < pTmpList->cLen; i++)
    {
        ret = pFun(&pTmpList->pData[i], arg);
        if (ret != 0)
        {
            return -1;
        }
    }

    return 0;
}

//修改

//查询

//销毁
#ifndef __SEQLIST_H__
#define __SEQLIST_H__

//数据对象类型
typedef struct clientinfo
{
    char address[256];
    int port;
}clientinto_t;

//存储数据类型 
typedef clientinto_t DataType;

//顺序表标签结构
typedef struct list
{
    DataType *pData;        //存放数据空间首地址
    int tLen;               //最大存放元素个数
    int cLen;               //当前元素个数
}SeqList;

extern SeqList *CreateSeqList(int MaxLen);
extern SeqList *CreateSeqList(int MaxLen);
extern int IsEmptySeqList(SeqList *pTmpList);
extern int IsFullSeqList(SeqList *pTmpList);
extern int GetCountSeqList(SeqList *pTmpList);
extern int GetCapacitySeqList(SeqList *pTmpList);
extern int AppendSeqList(SeqList *pTmpList, DataType TmpData);
extern int PosInsertSeqList(SeqList *pTmpList, int Pos, DataType TmpData);
extern int ForeachSeqList(SeqList *pTmpList, int (*pFun)(void *Element, void *arg), void *arg);

#endif

6.链表：
    1.空间可以不连续，访问元素不方便
    2.链表需要更大的空间存放数据和节点地址
    3.链表空间不连续,使得理论上长度是无限的
    4.链表的插入和删除效率很高

    链表的分类：
        1.单向链表
        2.双向链表
        3.循环链表
        4.内核链表

    1.单向链表  

1.段错误调试方法：
    1.按照网上的方法配置Ubuntu，允许生成core文件
    2.重新编译代码并加入-g选项(允许进行GDB调试)
    3.ulimit -c unlimited 
      不限制core文件的生成的大小
    4.执行代码,复现段错误,产生包含出错信息的core文件(检查core文件是否生成)
    5.gdb a.out core 
      查看段错误产生的位置
      bt 
      查看段错误时的堆栈信息
      p 变量名 
      查看段错误时的变量信息

2.vscode的调试方法


3.单向链表操作：
    基本操作：
    1.创建
    2.销毁
    3.插入 
    4.删除
    5.打印
    6.修改
    7.查询

    复杂操作：
    1.查找链表中间节点
    2.查找链表倒数第k个节点
    3.链表的倒置(反转)
    4.链表的排序(冒泡排序、选择排序)
    5.已知链表中间某个节点地址，不知道头结点地址，如何删除该节点
    6.如何判断一个链表是否有环？环长？环的入口位置？
        是否有环：快指针每次走2步,慢指针每次走1步,快慢指针相遇则说明有环
        如何计算环长：标记相遇的位置，让指针继续向后走，没走一步计算器自加,走回到标记位置，则计算器值即为环长
        如何计算环入口位置：将一个指针从第一个节点向后走，将一个指针从相遇点向后走，两个指针相遇的位置即为环入口的位置
    

        

mutou8541
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
mipsel-linux-gcc4.4.0.tgz
10-25
在嵌入式系统开发领域，MIPS架构以其低功耗、高性能的特点被广泛应用，而`mipsel-linux-gcc4.4.0.tgz`正是针对MIPS体系结构的嵌入式Linux开发的一款关键工具——交叉编译器。这个压缩包文件包含的是GCC（GNU ...
mysql-shell-8.0.30-linux-glibc2.12-x86-64bit.tar.gz
08-17
4. **图形化操作**：虽然主要是命令行工具，但MySQL Shell也支持一些图形化的操作，如模式浏览器，便于用户查看和管理数据库结构。 5. **安全增强**：MySQL Shell支持最新的安全特性，如加密连接、身份验证插件等，...
mysql-5.7.28-linux-glibc2.12-x86_64.tar.gz
02-24
2. **JSON支持**：MySQL 5.7开始支持JSON数据类型，允许存储和检索非结构化数据，适应NoSQL的趋势。它提供了丰富的JSON函数，可以进行查询、更新和操作JSON文档。 3. **查询优化器改进**：查询优化器的改进包括CBO...
MongoDB Community（mongodb-linux-aarch64-ubuntu1804-5.0.8.tgz）
05-28
它支持的数据结构非常松散，是类似json的bson格式，因此可以存储比较复杂的数据类型。Mongo最大的特点是它支持的查询语言非常强大，其语法有点类似于面向对象的查询语言，几乎可以实现类似关系数据库单表查询的绝大...
Ubuntu-Linux操作系统基础介绍
07-12
安装后的系统目录结构包括/bin（存放基本命令）、/boot（引导文件）、/dev（设备文件）、/etc（系统配置）、/home（用户文件）、/lib（库文件）、/mnt（临时挂载点）、/opt（额外应用）、/proc（虚拟文件系统）、/...
企业级环境部署：在 Linux 服务器上如何搭建和部署 Python 环境？
sdgfafg_25的博客
08-29 411
在大部分企业里，自动化测试框架落地都肯定会集成到Jenkins服务器上做持续集成测试，自动构建以及发送结果到邮箱，实现真正的无人值守测试。不过Jenkins搭建一般都会部署在公司的服务器上，不会在私人电脑里，而服务器大部分都是Linux操作系统的。所以，我们如果要在Linux上的Jenkins服务器里运行python自动化的脚本，那么就在linux服务器上把python以及相关用到的第三方库的环境都安装部署好。我们今天就给大家详细介绍一下Linux里如何安装和部署Python的环境。
Linux中的常见命令——用户管理命令
qq_45569925的博客
08-27 384
默认创建用户的时候会在home文件夹下创建一个与用户同名的文件夹【该用户的主目录】，也可以在创建用户的时候设置该用户主目录的名称。【输入的密码是不在控制台显示的，输入完之后直接按回车键即可】使用wgh用户查看root下的文件。【此时的用户是没有密码的】给创建的用户设置密码。查看某个用户是否存在。
虚拟内存和linux（操作系统八股文part1）
linjixia的博客
08-24 1326
八股之虚拟内存和Linux部分的笔记。
Linux高性能服务器编程 总结索引 | 第2章：IP协议详解
AsherGu的博客
08-29 393
IP服务的特点；IPv4头部结构；IP分片；IP路由：IP模块工作流程，路由机制，路由表更新；IP转发；重定向；IPv6头部结构：IPv6固定头部结构，IPv6扩展头部
linux 系统性能调优技巧
m0_50641264的博客
08-27 276
【代码】linux 系统性能调优技巧。
Linux——进程管理
m0_67677309的博客
08-29 283
1、通过fork创建的子进程会拷贝父进程(数据段、bss段、堆、栈、I/O缓冲区)，与父进程共享代码段、子进程会继承父进程的信号处理方式。ITIMER_VIRTUAL 虚拟计时器 用户态的计时SIGVTALRM(26)**使用的时候要对应。ITIMER_REAL 真实计时器 程序总的计时时间SIGALRM(14)void (*sa_restorer)(void);// 第一次产生时钟信号的时间 **3秒钟一次，每个两秒。
Linux下，执行shell遇let:not found
janet110617的博客
08-27 219
在Linux下执行shell脚本，提示let:not found错误，文章介绍了错误原因及其解决方法
在linux 中如何将.c 文件转换为可执行文件
千千道的博客
08-29 824
在 Linux 环境下进行 C 语言编程时，将.c文件转换为可执行文件是一个关键的步骤。这个过程涉及到使用编译器和一些相关的工具，本文将详细介绍在 Linux 系统中如何将.c文件转换为可执行文件的方法。
Linux下IO多路复用—select，poll，epoll
热土程序园，利他愉己~
08-29 697
Linux下IO多路复用—select，poll，epoll IO多路复用是一种操作系统的技术，用于在单个线程或进程中管理多个输入输出操作。它的主要目的是通过将多个IO操作合并到一个系统调用中来提高系统的性能和资源利用率，避免了传统的多线程或多进程模型中因为阻塞IO而导致的资源浪费和低效率问题。 在IO多路复用中，通常使用的系统调用有 select()、poll()、epoll() 等，它们允许程序等待多个文件描述符（sockets、文件句柄等）中的任何一个变为可读或可写，然后再进行实际的IO操作。
Linux-部署YUM仓库及NFS共享服务
qq_42520799的博客
08-25 1040
YUM仓库服务、NFS共享存储服务等
linux上datax 安装以及使用
寂夜了无痕的博客
08-24 2904
linux上datax 安装以及使用
Linux——命名管道
最新发布
Dreamswi的博客
08-29 174
管道本质上就是一个可读写的文件，一个进程向文件中写入数据，另一个进程从文件中读取数据，那么此时就实现了通信。因为这种数据的传输是单向的，所以才被称作管道。管道的实现就是两个不同的进程打开同一个文件。匿名管道匿名管道仅用于父子进程或有血缘关系的进程（即有一个共同的祖先进程）原理在通信开始前父进程先以读和写两种权限分别打开同一个文件，再利用fork()函数形成父子进程，因为子进程继承了父进程的数据，所以打开的文件描述符表中也有以读和写两种权限分别打开同一个文件的文件描述符。
yocto | 基于Linux的定制系统跑Qt app(第三集)yocto任务与语法
m0_45463480的博客
08-29 688
默认情况下，bitbake会清理环境，只包括那些导出或在白名单中列出的东西，以确保构建环境是可重复和一致的。解析到变量所在位置时，若变量在此之前未被赋值，则继续往下解析，取最后一个?此外，此运算符在所有的=、+=、=+、.=、=.、?此外，此运算符在所有的=、+=、=+、.=、=.、?运算符可以将变量中匹配值（完全匹配）移除，同样也是等所有的=、+=、=+、.=、=.、?yocto项目的策略是使用空格作为缩进，而shell函数中可以出现tab符号，但为了避免弄混，建议统一使用空格作为缩进。
Linux 安装Mysql保姆级教程
林深时见鹿
08-29 171
记住这个初始密码，然后就可以进入Mysql。我们登录服务器，查看之前是否安装过mysql。由于我之前安装过，所以这里是有数据的。安装完成之后，就可以启动mysql了。如果需要删除重新下载，可以使用。这样我们就进入Mysql了。查看mysql启动状态。下载之后，安装安装包。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值