循环buffer 、链表

LiMinyu_IoT

已于 2024-03-16 15:05:52 修改

阅读量273

点赞数 3

文章标签：算法 linux 运维

于 2024-03-16 14:58:00 首次发布

本文链接：https://blog.youkuaiyun.com/2301_77123899/article/details/136762842

版权

循环buffer（ringBuffer）

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

typedef struct ring_buffer
{
    char *buf;
    unsigned int head;
    unsigned int tail;
    unsigned int size;
    unsigned int remain; 
} RING_BUFFER;

int buffer_create(RING_BUFFER *lbuf, unsigned int size)
{
    lbuf->buffer = malloc(size);
    lbuf->head = lbuf->tail = 0;
    lbuf->size = size;
    lbuf->remain = size;

    return 0;
}


buffer_write(RING_BUFFER *lbuf, char *wbuf, unsigned int wlen)
{
    int overflow;

    if (!wbuf)
    {
        print("ERROR\r\n");
        return -1;
    }

    if (wlen > remain)
    {
        print("ERROR\r\n");
        return 0;
    }

    overflow = lbuf->head + wlen - lbuf->size;
    if (overflow > 0)
    {
        memcpy(lbuf->buf + lbuf->head, wbuf, wlen - overflow);
        memcpy(lbuf->buf, wbuf + (wlen - overflow), overflow);

        lbuf->head = overflow;
    }
    else
    {
        memcpy(lbuf->buf + lbuf->head, wbuf, wlen);
        lbuf->head += wlen;
    }

    lbuf->remain -= wlen;

    return wlen;
}

buffer_read(RING_BUFFER *lbuf, char *rbuf, unsigned int rlen)
{
    int overflow;

    if (!rbuf)
    {
        print("ERROR\r\n");
        return -1;
    }

    if (rlen > lbuf->size - lbuf->remain)
    {
        print("ERROR\r\n");
        return 0;
    }

    overflow = lbuf->tail + rlen - lbuf->size;
    if (overflow > 0)
    {
        memcpy(rbuf, lbuf->buf + lbuf->tail, rlen - overflow);
        memcpy(rbuf + (rlen - overflow), lbuf->buf, overflow);
  
        lbuf->tail = overflow;
    }
    else
    {
        memcpy(rbuf, lbuf->buf + lbuf->tail, rlen);
        lbuf->tail += rlen;
    }

    lbuf->remain += rlen;

    return rlen;
}

buffer_free(RING_BUFFER *lbuf)
{
    free(lbuf->buffer);
    lbuf->head = lbuf->tail = 0;
    lbuf->size = size;
    lbuf->remain = size;

    return 0;
}


#define MAX_LEN 12
int mian()
{
    RING_BUFFER buf;
    char rbuf[MAX_LEN + 4];
    char wbuf[] = "0123456789abcdef";
    unsigned int rlen;
    unsigned int wlen;

    printf("MAX_LEN:%d\r\n", MAX_LEN);
    buffer_create(&buf, MAX_LEN);


    wlen = MAX_LEN;
    print("\r\n==1==\r\nWrite[%02d]: %.*s\r\n", wlen, wlen, wbuf); 
    ret = buffer_write(&buf, wbuf, wlen);
    if (ret != wlen)
    {
        printf("ERROR:write fail!\r\n");
    }
    rlen = MAX_LEN;
    memset(rbuf, 0, sizeof(rbuf));
    ret = buffer_read(&rbuf, rbuf, rlen);
    if (ret != rlen)
    {
        printf("ERROR:read fail!\r\n");
    }
    print("Read[%02d]: %.*s\r\n", rlen, rlen, rbuf);

    wlen = 2;
    print("\r\n==2==\r\nWrite[%02d]: %.*s\r\n", wlen, wlen, wbuf);
    ret = buffer_write(&buf, wbuf, wlen);
    if (ret != wlen)
    {
        printf("ERROR:write fail!\r\n");
    }
    wlen = 4;
    print("Write[%02d]: %.*s\r\n", wlen, wlen, wbuf);
    ret = buffer_write(&buf, wbuf, wlen);
    if (ret != wlen)
    {
        printf("ERROR:write fail!\r\n");
    }
    wlen = 6;
    print("Write[%02d]: %.*s\r\n", wlen, wlen, wbuf);
    ret = buffer_write(&buf, wbuf, wlen);
    if (ret != wlen)
    {
        printf("ERROR:write fail!\r\n");
    }
    wlen = 1;
    print("Write[%02d]: %.*s\r\n", wlen, wlen, wbuf);
    ret = buffer_write(&buf, wbuf, wlen);
    if (ret != wlen)
    {
        printf("ERROR:write fail!\r\n");
    }

    rlen = MAX_LEN - 4;
    memset(rbuf, 0, sizeof(rbuf));
    ret = buffer_read(&rbuf, rbuf, rlen);
    if (ret != rlen)
    {
        printf("ERROR:read fail!\r\n");
    }
    print("Read[%02d]: %.*s\r\n", rlen, rlen, rbuf);

    wlen = 6;
    print("\r\n==3==\r\nWrite[%02d]: %.*s\r\n", wlen, wlen, wbuf);
    ret = buffer_write(&buf, wbuf, wlen);
    if (ret != wlen)
    {
        printf("ERROR:write fail!\r\n");
    }

    rlen = MAX_LEN;
    memset(rbuf, 0, sizeof(rbuf));
    ret = buffer_read(&rbuf, rbuf, rlen);
    if (ret != rlen)
    {
        printf("ERROR:read fail!\r\n");
    }
    print("Read[%02d]: %.*s\r\n", rlen, rlen, rbuf);

    rlen = 5;
    memset(rbuf, 0, sizeof(rbuf));
    ret = buffer_read(&rbuf, rbuf, rlen);
    if (ret != rlen)
    {
        printf("ERROR:read fail!\r\n");
    }
    print("Read[%02d]: %.*s\r\n", rlen, rlen, rbuf);

    wlen = 7;
    print("\r\n==4==\r\nWrite[%02d]: %.*s\r\n", wlen, wlen, wbuf);
    ret = buffer_write(&buf, wbuf, wlen);
    if (ret != wlen)
    {
        printf("ERROR:write fail!\r\n");
    }
 
    rlen = MAX_LEN;
    memset(rbuf, 0, sizeof(rbuf));
    ret = buffer_read(&rbuf, rbuf, rlen);
    if (ret != rlen)
    {
        printf("ERROR:read fail!\r\n");
    }
    print("Read[%02d]: %.*s\r\n", rlen, rlen, rbuf);

    return 0;
}

链表

#include<stdio.h>
#include <malloc.h>

typedef struct Node
{
	int data;
	struct Node* next;
} NODE,*PNODE;//将类型 struct Node 重命名为 Node_t

PNODE create_node(int x)
{
	printf("---create_node---\r\n");
	PNODE newnode = (PNODE)malloc(sizeof(NODE));	
    if (NULL == newnode) //内存分配失败
    {
        printf("fail to distribute memory,the procedure is over!\n");
		return (PNODE)1;
    }
    newnode->data = x;
	newnode->next = NULL;
	return newnode;	
}

PNODE create_list_scanf(void)
{
	printf("---create_list_scanf---\r\n");
	PNODE head=NULL, tail=NULL, p;//指针必须初始化，否则出错（野指针） 
	int x;
	
    while(scanf("%d", &x) == 1)//当输入不为整数时结束
    {
    	p=create_node(x);    
        if(head == NULL)
        {
    		head=tail= p;
		}
        else
        {
       		tail->next = p;	//先连起来，再把指针放去尾部 
			tail = p;  
		}                       
    }
    return head;	
}

PNODE create_list(void)
{
	printf("---create_list---\r\n");
	PNODE head=NULL;
	PNODE tail=NULL;	
	PNODE p;
	
	p=create_node(1);//头节点 
	head=tail=p;
	
	p=create_node(3);
	tail->next=p;
	tail=p;
	
	p=create_node(6);
	tail->next=p;
	tail=p;

    return head;	
}

void list_print(PNODE head)
{
    PNODE p = head;   //定义一个静态指针变量p指向头节点
	//遍历所有结点
	printf("---list_print---\r\n");
	while( (p->next)!=NULL )
	{
		printf("%d->", p->data);//打印数据
		p=p->next;
	} 
	printf("NULL\r\n");	
}

PNODE list_insert(PNODE head,int i,int x)
{
	PNODE p=head;//p是前驱结点 
	int a=0;
	printf("list_insert\r\n");
	for(a=1;a<i;a++)
	{
		p=p->next;//查找出第i个位置的前驱结点 
	}
	
	PNODE pNew=create_node(x);
	pNew->next=p->next;
	p->next= pNew;
	return head; 
}

//找到值为x，并删掉
PNODE list_delect_value(PNODE head,int x)
{
	printf("---list_delect---\r\n");    
//	注意：踩坑点。创建指针之后，没有初始化指针，导致程序出错死掉。错误做法例如：PNODE p,del;           
    PNODE p = head;  //p是前驱	          
    PNODE del = p->next; //del是找到要删除的结点	  	 
		
    if (del == NULL)
    {
        printf("The linked list is empty!\r\n");
        return;
    }    
    while(del)
	{ //查找数据x的位置 
		if( x == del->data )
		{
//			printf("del->%d\r\n",del->data);			
			p->next=del->next;
			free(del);
			break; //掉坑点：没有加break跳出while循环 
		}
		else
		{
			del=del->next;//指向下一个结点 
		}
    }
   	return head;
}

//找到第几个结点，并删掉
PNODE list_delect_number(PNODE head,int num)
{
	printf("---list_delect---\r\n");    
//	注意：踩坑点。创建指针之后，没有初始化指针，导致程序出错死掉。错误做法例如：PNODE p,del;           
    PNODE p = head;  //p是前驱	          
    PNODE del = p->next; //del是找到要删除的结点	  	 
		
    if (del == NULL)
    {
        printf("The linked list is empty!\r\n");
        return;
    }    
    while(del)
	{ //查找数据x的位置 
		if( num == del->data )
		{
//			printf("del->%d\r\n",del->data);			
			p->next=del->next;
			free(del);
			break; //掉坑点：没有加break跳出while循环 
		}
		else
		{
			del=del->next;//指向下一个结点 
		}
    }
   	return head;
}

int main()
{
	PNODE head=NULL;	
		
//	head=create_list_scanf();	
	head=create_list();	
	list_print(head);	
	
	list_delect(head,3);
	list_print(head);
}