List单链表封装

最新推荐文章于 2022-08-27 14:57:04 发布
最新推荐文章于 2022-08-27 14:57:04 发布
阅读量609 收藏 1
点赞数
分类专栏： CodeUtils Unix编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangwenwen/article/details/38705697
版权 
#include <stdlib.h>
#include <string.h>

#define MAX_PHONE_NUM 65
#define CON_OK   1
#define CON_FAIL 0


typedef struct T_RelayCallItem
{
    char caller[MAX_PHONE_NUM];
    char callee[MAX_PHONE_NUM];
    int call_type;
    struct T_RelayCallItem *pNext;
}tRelayCallItem;


typedef struct T_RelayCallList
{
    int lens;
    tRelayCallItem *pHead;
    tRelayCallItem *pRear;
}tRelayCallList;

tRelayCallList g_RelayCallList;

void InitRelayCallList()
{
    tRelayCallList *pList = &g_RelayCallList;
    pList->lens  = 0;
    pList->pHead = NULL;
    pList->pRear = NULL;
}

tRelayCallItem *AddRelayCallIntoList(tRelayCallItem*pNew)
{
    tRelayCallList *pList = &g_RelayCallList;
    tRelayCallItem *pRear = pList->pRear;
    
    if (pRear == NULL)
    {
        pList->pHead = pList->pRear = pNew;
    }
    else
    {
        pList->pRear->pNext = pNew;
        pList->pRear = pNew;
    }
    pList->lens++;

    return pNew;
}

tRelayCallList *DestroyRelayCallList()
{
    tRelayCallList *pList = &g_RelayCallList;
    tRelayCallItem *pHead = pList->pHead;
    
    while(pHead)
    {
        tRelayCallItem *pTmp = pHead->pNext;
        free(pHead);
        pHead = pTmp;     
    }

    pList->pHead = pList->pRear = NULL;
    pList->lens = 0;

    return pList;
}

int DeleteRelayCallItemFromList(tRelayCallItem *pNew)
{
    tRelayCallList *pList = &g_RelayCallList;
    tRelayCallItem *curr_node;
    tRelayCallItem *pre_node;
	
    if((pList == NULL) || (pNew == NULL))
    {
        return CON_FAIL;
    }
    
    if(pList->pHead == pNew)
    {
        pList->pHead = pNew->pNext;
        if(pNew == pList->pRear)
        {
        	pList->pRear = NULL;
        }
        free(pNew);
        pList->lens--;
        return CON_OK;
    }

    curr_node = pList->pHead;
    pre_node = curr_node;
    while(curr_node != NULL)
    {
        if(curr_node == pNew)
        {
        	pre_node->pNext = curr_node->pNext;
        	if(pNew == pList->pRear)
        	{
        		pList->pRear = pre_node;
        	}
        	free(pNew);
        	pList->lens--;
        	return CON_OK;
        }

        pre_node = curr_node;
        curr_node = curr_node->pNext;
    }

    return CON_FAIL;
}

int DeleteRelayCallItemByCallerCallee(char *caller, char *callee)
{
    tRelayCallList *pList = &g_RelayCallList;
    tRelayCallItem *curr_node;
    tRelayCallItem *tmp_node;  
    tRelayCallItem *pre_node;
	
    if((caller == NULL) || (callee == NULL))
    {
        printf("Input pointer is NULL");
        return CON_FAIL;
    }
    curr_node = pList->pHead;
    while(curr_node != NULL)
    {
        if((!strcmp(curr_node->caller,caller) && !strcmp(curr_node->callee,callee))
                || (!strcmp(curr_node->caller,callee) && !strcmp(curr_node->callee,caller)))
        {
            tmp_node = curr_node->pNext;
            if (pList->pHead == curr_node)
            {
                pList->pHead = tmp_node;
            }
            if (pList->pRear == curr_node)
            {
                pList->pRear = NULL;
            }
            free(curr_node);
            pList->lens--;
            
            curr_node = tmp_node;
            tmp_node = tmp_node->pNext;            
        }
        else
        {
            tmp_node = NULL;
            break;
        }
    }

    pre_node = curr_node;
    curr_node = curr_node->pNext;
    while(curr_node != NULL)
    {
        if((!strcmp(curr_node->caller,caller) && !strcmp(curr_node->callee,callee))
                || (!strcmp(curr_node->caller,callee) && !strcmp(curr_node->callee,caller)))
        {
        	pre_node->pNext = curr_node->pNext;
        	if(curr_node == pList->pRear)
        	{
        		pList->pRear = pre_node;
        	}
        	free(curr_node);
        	pList->lens--;

            curr_node = pre_node->pNext;
        }
        else
        {
            pre_node = curr_node;
            curr_node = curr_node->pNext;            
        }
    }    
    
    return CON_OK;
}

void PrintList()
{
    tRelayCallItem *item = g_RelayCallList.pHead;
	while (item != NULL)
	{
		printf("-------caller:%s,callee:%s\n",item->caller,item->callee);
		item = item->pNext;
	}

}

int main(int argc, char* argv[])
{
    tRelayCallItem *item;

	int i;
	for (i = 0; i < 10 ; i ++)
	{
		item = (tRelayCallItem *)malloc(sizeof(tRelayCallItem));
		memset(item,0,sizeof(tRelayCallItem));
		if (i%4 == 0)
		{
			strcpy(item->caller,"35");
			strcpy(item->callee,"36");
			item->call_type = 1;
		}
		else if (i%4 == 1)
		{
			strcpy(item->caller,"6051");
			strcpy(item->callee,"6052");
			item->call_type = 1;
		}
		else if (i%4 == 2)
		{
			strcpy(item->caller,"36");
			strcpy(item->callee,"35");
			item->call_type = 2;
		}
		else
		{
			strcpy(item->caller,"6051");
			strcpy(item->callee,"6052");
			item->call_type = 2;
		}

		AddRelayCallIntoList(item);	
	}

	PrintList();
	DeleteRelayCallItemByCallerCallee("35","36");
	PrintList();
	
	return 0;
}
extern int g_dbg_level;
extern FILE *g_log_fp;
/* debug level */
#define DBG_INFOR  	0x01  // call information
#define DBG_WARNING	0x02  // paramters invalid,  
#define DBG_ERROR  	0x04  // process error, leading to one call fails
#define DBG_CRITICAL	0x08  // process error, leading to voip process can't run exactly or exit
/* debug macro */
#define DBG(level, fmt, para...) 	\
	{ \
		time_t t = time(NULL);  \
		struct tm *tmm = localtime(&t); \
		if(g_dbg_level & level) 	\
			printf("[%d-%02d-%02d %02d:%02d:%02d][%s][%s:%d]" fmt "\n",tmm->tm_year+1900,tmm->tm_mon+1,tmm->tm_mday,tmm->tm_hour,tmm->tm_min,tmm->tm_sec,__FUNCTION__,__FILE__,__LINE__,##para); \
		if((g_log_fp != NULL) && (level == DBG_CRITICAL))	\
			fprintf(g_log_fp, "[%d-%02d-%02d %02d:%02d:%02d][%s][%s:%d]" fmt "\n",tmm->tm_year+1900,tmm->tm_mon+1,tmm->tm_mday,tmm->tm_hour,tmm->tm_min,tmm->tm_sec,__FUNCTION__,__FILE__,__LINE__,##para); \
	}


wangwenwen
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
单向链表的封装
03-24 165
#include<iostream>typedef int DataType;typedef int Status;typedef struct Node{ DataType data; struct Node *Next;}Node,*LinkList;#define TRUE 1#define FALSE 0#define OK 1#define E...
链表封装
weixin_30764137的博客
10-03 765
// 链表 function LinkedList () { function Node(value) { this.next = null this.value = value } this.head = null this.length = 0 //在链表尾部追加元素 LinkedL...
链表_链表封装
october_autumn的博客
03-24 675
链表结构本身就是一种可以代替数组的结构，所以它的操作与数组的操作非常类似。 与数组比较，它们都可以存储一系列的元素，但是实现的机制完全不同。 数组有很多缺点： 数组需要申请一段连续的内存空间，并且大小是固定的（大多数编程语言），所以在数组增加元素时需要扩容。（一般情况下是申请一个更大的连续内存空间，比如2倍，再将元素复制过去） 在数组的中间或末尾插入元素成本很高，因为它内部需要改变插入位置后面的...
一个封装的链表模板类
孤身我路
02-25 1040
由于工作中经常用到链表，所以自己封装了个简单的链表模板类。以便使用/**    链表模板*/#pragma once#define NULL 0template class PtrList{ public:  PtrList() { pFirst = 0; }  PtrList(PtrList &p) { pFirst = p.pFirst; }  void AddNode (T &t)
链表接口的封装
春秋繁露
04-18 709
实现链表的基本功能，包括增加，删除，查找，排序，逆转。并对接口进行了封装。
带头结点单链表.zip
03-09
在实际应用中，为了提高代码的可读性和复用性，通常会封装这些功能到一个链表类或结构中。 总之，带头结点的单链表是数据结构中的一种基础类型，它在实现动态数据结构和算法中发挥着重要作用。理解和掌握其原理及...
用C++实现一个单链表
04-15
在`cpp_single_linked_list`这个压缩包文件中，可能包含了实现上述功能的源代码文件，如`LinkedList.cpp`和`LinkedList.h`，以及可能的测试文件。通过阅读和理解这些代码，你可以深入学习C++中单链表的实现细节和...
Java单链表的实现代码
01-04
首先，我们需要定义一个Node类来封装数据和指针： ```java public class Node<T> { T data; Node<T> next; public Node(T data) { this.data = data; this.next = null; } } ``` 接下来，我们创建一个...
单链表（c++）
07-30
C++标准库虽然不直接提供链表的实现，但可以使用STL（Standard Template Library）中的`std::list`容器，它是双向链表的实现，但这里选择自定义单链表，可能是为了更好地理解和控制底层数据结构。 单链表的基本操作...
C++ 实现单链表
04-10
接下来，我们需要创建一个链表类来封装链表的操作。这个类可能包含以下方法： 1. **构造函数**：初始化空链表。 2. **插入操作**：在链表的特定位置（如头部、尾部或指定位置）插入新节点。 3. **删除操作**：根据...
C++链表封装
qq_41958529的博客
06-09 470
头文件 mylist.h #ifndef MYLIST_H #define MYLIST_H typedef struct node { int data; //数据域 struct node *next; //指针域 }Node; class mylist { public: mylist(); ~mylist(); void insertLis...
链表的基本操作封装
qq_31424423的博客
02-27 184
下面为单链表的基本操作： #include <iostream> using namespace std; struct NODE { int data; NODE*pNext; NODE(int value) { data=value; pNext=NULL; } }; class List { public: List() { m_head=NULL; count=0; } ~List(); void insert(NODE*
双向链表封装
weixin_30764137的博客
10-07 638
//双向链表 functionDoubleLinkedList(){ functionNode(value){ this.value=value this.next=null this.prev=null } //链表头节点 this.head=null ...
C语言之单向链表封装
Ucare1990的博客
03-23 767
Copyright@Ucare1990-2017.03.23 于南山大学城 ===一图解决所有问题=== 时间仓促，暂给大家分享内存模型，以后有时间再详细追加 个人认为，只有脑袋里时刻有内存模型，才能很好的解决数据结构问题 附;对于链表的操作，无非 增/减/删/查/文件IO/遍历/摧毁 内粗模型+基本操作， 函数原型自然闪现(砰。。。)
List链表常用操作方法
dengbaji的博客
07-19 282
List import java.util.LinkedList; /* 特点：有序的（存储和读取的顺序是一致的） 有整数索引 允许重复的 */ public class _List { public static void main(String[] args) { //创建链表 LinkedList<Integer> list = new LinkedList<>(); //添加元素，时间复杂度：O(1)
GoLang学习笔记（二十六）list的声明、遍历及常用方法
热门推荐
ynzcxx的博客
08-21 1万+
list是列表，一种非连续存储的容器，由多个节点组成，节点通过一些变量记录彼此之间的关系。list有多种实现方法，如单向链表、双向链表等。 Go语言中的list的实现原理是双向链表，list能高效地进行任意位置的元素插入和删除操作。 Golang的标准库提供了高级的数据结构List，具体在包container/list。 container/list包里主要有两个数据结构类型：“Element”、...
【JS数据结构与算法】单向链表的封装及其方法
29的博客
07-29 679
目录 一、什么是链表？ 二、链表的封装 三、追溯方法append(element) 四、toString() 五、inset(position, element) 六、get(position) 七、indexOf(element) 八、upDate(position, element) 九、removeAt(position) 十、remove(element) 十一、判断...
单链表之C++封装
小米的修行之路
07-18 1144
前面的顺序表是用一组地址连续的存储单元来保存数据的，所以它具有随机存取的特点。即查找快速，但是做插入或删除动作是，需要移动大量元素，效率较低。 链表 链表是线性表的链式存储结构，它相比于顺序表，在插入和删除元素时，效率要高很多。 链表，是用一组任意的存储单元存储线性表的数据元素（这组存储单元可以是连续的，也可以是不连续的）。 每个数据单元有两部分组成，一个是数据域，存储数据值；另一个是
数据结构——链表的封装
m0_59200231的博客
08-27 396
数据结构中链表封装的基本架构
将面向过程的单链表程序封装成为类，包括俩个文件，.h头文件.cpp文件
最新发布
07-09
当然可以！下面是将面向过程的单链表程序封装成类的示例： 头文件 LinkedList.h： ```cpp #ifndef LINKEDLIST_H #define LINKEDLIST_H struct Node { int data; Node* next; }; class LinkedList { private: Node* head; public: LinkedList(); ~LinkedList(); void insert(int value); void remove(int value); void display(); }; #endif ``` 实现文件 LinkedList.cpp： ```cpp #include "LinkedList.h" #include <iostream> LinkedList::LinkedList() { head = nullptr; } LinkedList::~LinkedList() { Node* current = head; while (current != nullptr) { Node* next = current->next; delete current; current = next; } } void LinkedList::insert(int value) { Node* newNode = new Node; newNode->data = value; newNode->next = nullptr; if (head == nullptr) { head = newNode; } else { Node* current = head; while (current->next != nullptr) { current = current->next; } current->next = newNode; } } void LinkedList::remove(int value) { if (head == nullptr) { std::cout << "List is empty." << std::endl; return; } if (head->data == value) { Node* temp = head; head = head->next; delete temp; return; } Node* prev = nullptr; Node* current = head; while (current != nullptr && current->data != value) { prev = current; current = current->next; } if (current == nullptr) { std::cout << "Value not found in the list." << std::endl; return; } prev->next = current->next; delete current; } void LinkedList::display() { if (head == nullptr) { std::cout << "List is empty." << std::endl; return; } Node* current = head; while (current != nullptr) { std::cout << current->data << " "; current = current->next; } std::cout << std::endl; } ``` 这样，你就可以在其他文件中包含 LinkedList.h 头文件，并使用 LinkedList 类来操作单链表了。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值