linux定义数据结构压缩,Linux下数据结构学习笔记

最新推荐文章于 2024-06-11 17:51:58 发布
最新推荐文章于 2024-06-11 17:51:58 发布
阅读量111 收藏
点赞数
文章标签： linux定义数据结构压缩

一、顺序表

使用数组实现

优点：查找快，可以使用下标定位

缺点：增加、删除慢，之后的所有元素需要移动

结构体定义方式1:

需要malloc创建数组

typedef struct seqlist{

//数组指针，使用malloc动态创建堆上的数组

data_t *buf;

//数组长度

int maxLen;

//list后元素的位置

int last;

}seqlist_t;

结构体定义方式2:

这种方式可以使用定义变量的方式创建结构体，分配在栈上

也可以用malloc创建，分配在堆上

在malloc创建结构体或者定义变量时，系统根据结构体内元素的顺序，自动赋值对应的内存地址以初始化

typedef struct seqlist{

data_t buf[N];

int maxLen;

int last;

}seqlist_t;

常用方法：

//创建

seqlist_t *create_seqList(int size){

seqlist_t *l = (seqlist_t *)malloc(sizeof(seqlist_t));

l->buf = (data_t *)malloc(sizeof(data_t) * size);

l->maxLen = size;

l->last = -1;

}

//清空

void clear_seqlist(seqlist_t *l);

//判满

int is_full_seqlist(seqlist_t *l);

//判空

int is_empty_seqlist(seqlist_t *l);

//打印

void show_seqlist(seqlist_t *l);

//插入

int insert_seqlist(seqlist_t *l, int pos, data_t num);

//删除

data_t delete_seqlist(seqlist_t *l, int pos);

//定位

int index_of_seqlist(seqlist_t *l, data_t target);

//反转

void reverse_seqlist(seqlist_t *l){

int i = 0;

while(i < (l->last + 1)/2){

l->buf[i] ^= l->buf[l->last - i];

l->buf[l->last - i] ^= l->buf[i];

l->buf[i] ^= l->buf[l->last - i];

i++;

}

}

二、链表

使用指针将各个节点连接实现

优点：增加、删除快，直接改变指针的指向即可

缺点：查找慢，只能遍历

结构体定义方式：

typedef struct link_node{

//节点数据

data_t data;

//下个节点指针

struct link_node * next;

}linknode_t;

常用方法：

//创建

linklist_t create_linklist(){

//创建链表头，不存放数据

linklist_t l = (linklist_t)malloc(sizeof(linklist_t));

}

//判空

int is_empty_linklist(linklist_t l);

//打印

void show_linklist(linklist_t l);

//插入

int insert_linklist(linklist_t l, int pos, data_t data){

//malloc创建节点

}

//删除

int delete_linklist_node(linklist_t l, data_t data){

//解链

//free

}

//反转

void reverse_linklist(linklist_t l){

linknode_t *p = l->next;

l->next = NULL;

linknode_t *q;

while(p){

q = p->next;

p->next = l->next;

l->next = p;

p = q;

}

}

三、顺序栈

使用数组实现

依次往数组中添加元素，使用top标记后加入的元素的位置作为栈顶，出栈的时候再按照数组逆序取出

结构体定义方式1：

需要malloc创建数组

typedef struct node_t{

//数组指针

data_t *data;

//数组长度

int maxlen;

//栈顶位置

int top;

}arrstack_t;

结构体定义方式2:

typedef struct node_t{

data_t buf[N];

int maxLen;

int top;

}seqlist_t;

常用方法：

//创建

arrstack_t *create_stack(int len){

arrstack_t *stack = (arrstack_t *)malloc(sizeof(arrstack_t));

stack->data = (data_t *)malloc(sizeof(data_t) * len);

stack->maxlen = len;

stack->top = -1;

return stack;

}

//清空

int clear_stack(arrstack_t *s);

//判空

int is_empty_stack(arrstack_t *s);

//判满

int is_full_stack(arrstack_t *s);

//出栈

data_t pop_stack(arrstack_t *s);

//入栈

int push_stack(arrstack_t *s, data_t data);

//取栈首元素，不出栈

data_t get_top_stack(arrstack_t *s);

//打印

void show_stack(arrstack_t *s);

四、链式栈

使用链表实现

将链表第一个节点作为栈顶，每次都是从头部插入，出栈也是从头部弹出

结构体定义方式：

//链表节点结构体

typedef struct node_t{

data_t data;

struct node_t *next;

}stacknode_t;

//表示栈的结构体，为了方便像顺序栈一样操作，top始终指向链表第一个节点，表示栈顶

//也可以只定义一个结构体，定义一个头节点，使用头插法实现，这个只是个人习惯

typedef struct node_stack{

int len;

stacknode_t *top;

}linkstack_t;

常用方法：

//创建

linkstack_t *create_stack(){

linkstack_t *linkstack = (linkstack_t *)malloc(sizeof(linkstack_t));

linkstack->len = 0;

linkstack->top = NULL;

return linkstack;

}

//清空

int clear_stack(linkstack_t *s){

while(s->top){

stacknode_t *node = s->top;

s->top = node->next;

free(node);

node = NULL;

}

}

//判空

int is_empty_stack(linkstack_t *s);

//入栈

int push_stack(linkstack_t *s, data_t data){

stacknode_t *node = (stacknode_t *)malloc(sizeof(stacknode_t));

node->data = data;

node->next = NULL;

node->next = s->top;

s->top = node;

s->len++;

}

//出栈

int pop_stack(linkstack_t *s){

stacknode_t *node = s->top;

s->top = node->next;

s->len--;

data_t data = node->data;

free(node);

node = NULL;

}

//取栈首元素，不出栈

int get_top(linkstack_t *s);

//打印

void show_stack(linkstack_t *s);

五、链式队列

使用链表实现，定义一个front头指针，指向第一个元素前一个位置，定义一个rear尾指针，指向后一个元素位置

结构体定义方式：

//链表节点结构体

typedef struct node_t{

int data;

struct node_t *next;

}nodequeue_t, *linklist_t;

//表示队列的结构体

typedef struct{

linklist_t front, rear;

}linkqueue_t;

常用方法：

//创建

linkqueue_t *create_link_queue(){

//创建表示队列的结构体

linkqueue_t *lq = (linkqueue_t *)malloc(sizeof(linkqueue_t));

//创建链表的头节点，不存放数据

nodequeue_t *nq = (nodequeue_t *)malloc(sizeof(nodequeue_t));

nq->next = NULL;

lq->front = lq->rear = nq;

return lq;

}

//清空

int clear_queue(linkqueue_t *lq){

while(!is_empty_queue(lq)){

nodequeue_t *delnode = lq->front->next;

//判断队头的下一个是否是队尾，需要把rear指向链表头节点

if(lq->front->next == lq->rear){

lq->rear = lq->front;

}

lq->front->next = delnode->next;

free(delnode);

delnode= NULL;

}

}

//判空

int is_empty_queue(linkqueue_t *lq){

return lq->front == lq->rear;

}

//入队

int in_link_queue(linkqueue_t *lq, int data);

//出队

int out_link_queue(linkqueue_t *lq){

nodequeue_t *out_node = lq->front->next;

//每次都需要判断队头的下一个是否是队尾，需要把rear指向链表头节点

if(lq->rear == lq->front->next){

lq->rear = lq->front;

}

lq->front->next = out_node->next;

int ret = out_node->data;

free(out_node);

out_node = NULL;

}

//打印

void show_link_queue(linkqueue_t *lq);

六、顺序队列

使用数组实现，使用伪溢出的方式将数组当成一个循环链表

结构体定义方式1：

使用数组指针，需要malloc创建数组

typedef struct node_t{

data_t *data;

int max_size;

int front, rear;

}arrqueue_t;

结构体定义方式2：

typedef struct node_t{

data_t data[N];

int max_size;

int front, rear;

}arrqueue_t;

常用方法：

//创建

arrqueue_t *create_arrqueue(int size){

arrqueue_t *q = (arrqueue_t *)malloc(sizeof(arrqueue_t));

q->data = (data_t *)malloc(sizeof(data_t) * size);

q->max_size = size;

q->front = q->rear = size - 1;

return q;

}

//判空

int is_full_queue(arrqueue_t *q){

if(((q->rear + 1)%q->max_size) == q->front){

return 1;

}

}

//判满

int is_empty_queue(arrqueue_t *q){

return q->rear == q->front;

}

//入队

int in_queue(arrqueue_t *q, data_t data){

q->rear = (q->rear + 1)%q->max_size;

q->data[q->rear] = data;

}

//出队

int out_queue(arrqueue_t *q){

q->front = (q->front + 1)%q->max_size;

return q->data[q->front];

}

//清空

int clear_queue(arrqueue_t *q);

//打印

void show_arrqueue(arrqueue_t *q){

/*

int temp = q->front;

do{

temp = (temp + 1)%N;

printf("%d\n",q->data[temp]);

}while(temp!= q->rear);

*/

/*

int i;

for(i = (q->front + 1)%N; i != (q->rear + 1)%N; i = (i + 1)%N){

printf("%d\n",q->data[i]);

}

*/

int i = 0;

int size = ((q->max_size - q->front) + q->rear)%q->max_size;

while(i < size){

int index = (q->front + 1 + i)%q->max_size;

printf("queue[%d] = %d\n", index, q->data[index]);

i = (i + 1)%q->max_size;

}

}

七、二叉树

结构体定义方式：

typedef struct tree{

int data;

struct tree *lchild, *rchild;

}tree_t;

常用方法：

//创建指定节点数的完全二叉树

tree_t *create_totol_tree(int i, int num){

tree_t *t = (tree_t *)malloc(sizeof(tree_t));

t->data = i;

if(2 * i <= num){

t->lchild = create_totol_tree(2 * i, num);

}else{

t->lchild = NULL;

}

if(2 * i + 1 < num){

t->rchild = create_totol_tree(2 * i + 1, num);

}else{

t->rchild = NULL;

}

return t;

}

//递归方式创建二叉树

tree_t *create_tree(){

char ch;

tree_t *t;

scanf("%c", &ch);

if('#' != ch){

t = (tree_t *)malloc(sizeof(tree_t));

t->data = ch;

t->lchild = create_tree();

t->rchild = create_tree();

return t;

}else{

return NULL;

}

}

//递归方式-前序遍历二叉树

void pr_show_tree(tree_t *t){

if(NULL == t){

return;

}

printf("%c", t->data);

pr_show_tree(t->lchild);

pr_show_tree(t->rchild);

}

//递归方式-中序遍历二叉树

void mid_show_tree(tree_t *t){

if(NULL == t){

return;

}

mid_show_tree(t->lchild);

printf("%c", t->data);

mid_show_tree(t->rchild);

}

//递归方式-后序遍历二叉树

void re_show_tree(tree_t *t){

if(NULL == t){

return;

}

re_show_tree(t->lchild);

re_show_tree(t->rchild);

printf("%c", t->data);

}

低调王子
关注
Linux 打印堆栈方法
LU_ZHAO的博客
03-18 1947
linux内核堆栈打印方法 dump_stack() 或 __backtrace() linux应用层堆栈打印方法 int backtrace(void **buffer, int size); 获取当前的调用栈信息，结果存储在buffer中，返回值为栈的深度，参数size限制栈的最大深度，即最大取size步的栈信息。 char **backtrace_symbols(void *const...
Linux学习笔记——CentOS
MCC
04-20 3万+
Linux1 介绍2 安装3 Linux 的目录结构4 远程操作工具5 1 介绍 Linux 是一个开源、免费的操作系统，具有很强的稳定性、安全性、以及处理多并发的能力，目前大多数企业级应用甚至是集群项目都部署运行在 Linux 操作系统上，很多软件公司考虑到开发成本都首选Linux，Linux 在中国软件公司得到了广泛的使用。 Linux 的主要发行版本有以下几种： Ubuntu（乌班图）、RedHat（红帽）、CentOS、Debain（蝶变）、Fedora、SuSE、OpenSUSE、红旗Li
Linux压缩打包命令——tar、zip、unzip
热门推荐
绮梦寒宵的博客
08-16 58万+
打包跟压缩的区别： 打包是指将多个文件或者目录放在一起，形成一个总的包，这样便于保存和传输，但是大小是没有变化的，压缩是指将一个或者多个大文件或者目录通过压缩算法使文件的体积变小以达到压缩的目的，可以节省存储空间，在压缩的时候通常是先打包再压缩； tar命令 tar命令参数前面加”-"与不加“-”的区别： tar命令参数前面加不加“-”执行命令的结果是没有区别的，区别只要是在与linux风...
Linux 存储 Stack详解
09-16 3039
Linux Kernel IO Stack
linux 进程崩溃 堆栈,如何在程序崩溃时自动生成堆栈跟踪
weixin_42297519的博客
05-03 759
linux虽然在execinfo.h中使用backtrace()函数打印堆栈跟踪并在得到分段错误时优雅地退出已被建议，我没有看到任何必要的复杂之处，以确保所产生的回溯指向故障的实际位置(至少对于某些体系结构-x86&ARM)。当您进入信号处理程序时，堆栈帧链中的前两个条目在信号处理程序中包含一个返回地址，在libc中包含一个在Sigaction()中的返回地址。在信号(故障位置)之前调用的...
第21章 信号：信号处理器函数
u010783439的博客
06-17 188
本章讨论了影响信号处理器函数操作与设计的一系列因素。由于没有对信号排队，故而在为处理器编码时，有时必须要考虑特定类型信号多次发生的可能性，即使之前信号只产生过一次。可重入问题会影响到对全局变量的修改方式，还限制了可从信号处理器函数中安全调用的函数范围。除了返回之外，信号处理器函数的终止还存在多种其他方法，其中包括：调用_exit(),发送信号来终止进程（kill(),raise()或abort()）,或者执行非本地跳转。
MongoDB学习笔记—Linux下搭建MongoDB环境
09-09
MongoDB的数据结构松散，以文档（document）的形式存储，采用类似JSON的BSON格式，由键值对组成，这使得数据操作更为灵活。 MongoDB的主要特点包括： 1. 面向文档存储：MongoDB以文档为中心，简化了数据模型，易于...
linux学习笔记
10-27
根据提供的文件信息，我们可以总结出以下几...这些知识点涵盖了TCP/IP协议中TCP连接的建立和关闭过程、Bash脚本的基本结构以及在Linux环境中进行软件安装和管理的方法。对于初学者来说，这些都是非常实用且重要的内容。
【学习笔记】Linux
最新发布
Eddie_hyh的博客
06-11 2037
Linux
Linux完美学习笔记
吆二一的博客
02-08 2641
一直想要找个机会系统学习一下Linux，终于在这次寒假抽出了部分时间完整地学习了Linux的知识，感到受益匪浅。我自己也做了很详细的学习笔记，整整一万来字，分享出来和大家一起学习！
堆栈存储（Linux环境下）
xq972的博客
05-28 465
堆栈存储（Linux环境下）源代码代码解释Linux环境下运行结果结果分析 源代码 #include <stdio.h> #include <stdlib.h> typedef struct { int a[2]; double d; } struct_t; double fun(int i) { volatile struct_t s; ...
Linux C 数据结构——栈
知秋一叶
12-28 2097
栈是限制在一段进行插入操作和删除操作的线性表（俗称堆栈），允许进行操作的一端称为“栈顶”，另一固定端称为“栈底”，当栈中没有元素称为“空栈”。特点：先进后出（FILO）。 栈顶即top，这里top有两种定义方式： 1、满栈（Full Stack）,top指向最后一个使用的空间； 2、空栈（Empty Stack），top指向下一个可用的空间；      栈也是线性表，所以也分顺序存储和
linux内核调试技巧 dump_stack()
stone8761的专栏
07-15 2760
linux内核提供函数dump_stack()来跟踪函数的调用过程，原理是通过打印当前cpu的堆栈的调用函数来显示当前的上下文环境与调用关系； 例： 创建一个混杂设备，并定义read函数。在read中加入dump_stack()，显示read调用关系。结果如下： [ 1560.465491] CPU: 0 PID: 2759 Comm: cat Tainted: GF
linux 复制栈数据结构,Linux C 数据结构——栈
weixin_32816613的博客
05-14 218
还是先把这张图贴出来，以便对比和理解 栈是限制在一段进行插入操作和删除操作的线性表(俗称堆栈)，允许进行操作的一端称为“栈顶”，另一固定端称为“栈底”，当栈中没有元素称为“空栈”。特点：先进后出(FILO)。 栈顶即top，这里top有两种定义方式：1、满栈(Full Stack),top指向最后一个使用的空间；2、空栈(Empty Stack)，top指向下一个可用的空间；栈也是线性表，所以也分...
如何对Linux文件进行压缩,Linux文件压缩与解压缩
weixin_32691939的博客
04-29 404
什么是压缩文件？原理是什么?简单的说，就是经过压缩软件压缩文件叫压缩文件，压缩的原理是把文件的二进制代码压缩，把相邻的0,1代码减少，例如有000000，可以把它变成6个0的写法60来减少该文件的空间，同理解压缩就是按照相同的原则把数据还原回来。Linux环境中有哪些格式的压缩文件?常见的压缩文件有*.tar,*.tar.gz,*.tgz,*.gz,*.Z,*.bz2,为啥有这么多种压缩文件？这是...
linux服务器简介,Linux服务器编程简介
weixin_39609354的博客
05-07 111
Linux服务器编程的特点是异步高并发，代码不能阻塞、不能休眠，以提高服务器的并发效率。给nginx写自定义的模块，就是典型的Linux服务器编程。nginx-rtmp-module就是一个开源的nginx模块，它为nginx添加了rtmp协议的支持。服务器的流程大概是这样：worker进程->epoll循环->event事件回调->connection连接->http协议...
双向链表（带头结点）
bentao1997719的博客
05-24 864
双链表 - 两个方向 带头节点 节点的定义 typedef int data_t; typedef struct link_node{ data_t data; //数据域，用来保存数据 struct link_node *next; //保存后面一个节点的地址 struct link_node *pre; //用来保存前一个节点的地址 }link_node_t; 创建带头结点的双链表 link_node_t *create_link_list(void) { //定义头结点，在堆上分配
c语言next域,数据结构 c语言 作用域问题
weixin_39694264的博客
05-19 292
问题用//标出来了，同样的语句为什么放入循环结果就完全不同了？#include #include #define OK 1#define NO 0int nn=0;typedef struct Node{int data;struct Node *next;}Node,*Linkstackptr;typedef struct{Linkstackptr top;int count;}Linkstac...
嵌入式Linux学习笔记：C语言、数据结构与IO编程
"这篇资源主要涉及的是嵌入式Linux学习之旅，涵盖了C语言、数据结构、Linux应用，特别是Linux的IO编程和进程线程编程。作者追风~忆梦分享了详细的学习笔记，包括每日学习内容和实践操作，旨在帮助读者深入理解相关...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值