数据结构 普通链表、企业链表和循环链表

已于 2023-08-27 11:16:59 修改
阅读量213 收藏
点赞数
分类专栏： 数据结构 文章标签： list 普通链表 企业链表
于 2020-09-18 13:51:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CodeHouse/article/details/108663552
版权 
//普通有头结点链表
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

//有头结点的单向链表
typedef struct MyNode{
    int num;
    struct MyNode *next;
}STNode_def;

#define NODE_SIZE sizeof(STNode_def)
#define SUCCESS 0
#define FAILURE -1


//链表初始化
STNode_def* list_init()
{
    STNode_def* head_ptr = (STNode_def*)malloc(NODE_SIZE);  /* 指向第一个节点的头指针 */
    
    if (head_ptr == NULL)
    {
        perror("malloc");
        return NULL;
    }
    
    memset(head_ptr, 0x00, NODE_SIZE);
    
    head_ptr->next = NULL;
    return head_ptr;
}

//遍历链表中每一个数据域
void list_print(STNode_def* head)
{
    STNode_def* p = head->next;
    while (p != NULL)
    {
        printf("%d ", p->num);
        p = p ->next;
    }

	printf("\n");
}


//链表的元素个数
int list_size(STNode_def* head)
{
    STNode_def* p = head;
    int size = 0;
    
    while (p->next != NULL)
    {
        p = p->next;
        size++;
    }

    return size;
}

//尾插入
int list_push_back(STNode_def* head, int value)
{
    STNode_def* p = head; //头结点的下一个节点
    STNode_def* pnew_node = (STNode_def*)malloc(NODE_SIZE);
    if (pnew_node == NULL)
    {
        printf("param is null\n");
        return FAILURE;
    }
    
    memset(pnew_node, 0x00, sizeof(NODE_SIZE));
    pnew_node->num = value;
    while (p->next != NULL)
    {
        p = p->next;
    }

    p->next = pnew_node;
    pnew_node->next = NULL;
    return SUCCESS;
}

//头插入
int list_push_front(STNode_def* head, int value)
{
    //STNode_def* p = head;
    STNode_def* pnew_node = (STNode_def*)malloc(NODE_SIZE);
    if (pnew_node == NULL)
    {
        printf("param is null\n");
        return FAILURE;
    }
    
    memset(pnew_node, 0x00, sizeof(NODE_SIZE));
    pnew_node->num = value;

    pnew_node->next = head->next;   //没有元素时，pnew_node->next = NULL也符合;
    head->next = pnew_node;
    
    return SUCCESS;
}


//尾删
void list_pop_back(STNode_def* head)
{
    STNode_def* p = head;
    
    int size = list_size(head);
    int cnt = 0;
    
    //找到需要删除结点的前驱结点
    while(p->next != NULL && cnt < size-1)
    {
        cnt++;
        p = p->next;
    }
    
    free(p->next);      //释放删除结点
    p->next = NULL;
}


//尾删
void list_pop_back1(STNode_def* head)
{
    STNode_def* curr = head->next;
    if (curr && curr->next == NULL) {
		free(curr);
		head->next = NULL;
		return;
	}
	STNode_def* pre = NULL;
    //找到需要删除结点的前驱结点
    while(curr != NULL && curr->next != NULL)
    {
    	pre = curr;
    	curr = curr->next;
    }
    if (pre == NULL) return; // empty list
	pre->next = NULL;
	free(curr);
}



//头删
void list_pop_front(STNode_def* head)
{
    STNode_def* p = head->next;
    
    if (head->next != NULL)
    {
        head->next = head->next->next; //找到删除结点的后驱结点
        free(p);
    }
}

//反转链表，使用结点的指针指向反转，最后将尾结点赋值给head->next
void list_reverse(STNode_def* head)
{
    int size = list_size(head);
    if (size <= 1)
    {
        return;
    }

    STNode_def *p = head->next;
    STNode_def *ppre = head->next;
    STNode_def *ptemp = NULL;
    while(p != NULL)
    {
        ptemp = p->next;
        if (head->next == p)
        {
            ppre = NULL;
        }
        p->next = ppre;
        ppre = p;
        p = ptemp;
    }
    head->next = ppre;
}


void swap(int *var1, int *var2)
{
    int temp = *var1;
    *var1 = *var2;
    *var2 = temp;
}

//链表元素排序flag：真为递增，假为递减
void list_sort(STNode_def* head, int flag)
{
    STNode_def* p = NULL;
    STNode_def* q = NULL;
    
    for (p =head->next; p->next != NULL; p = p->next)
    {
        for (q=head->next; q->next != NULL; q = q->next)
        {
            if (flag)
            {
                if (q->num > q->next->num)
                {
                    swap(&(q->num), &(q->next->num));
                }
            }
            else 
            {
                if (q->num < q->next->num)
                {
                    swap(&(q->num), &(q->next->num));
                }
            }
            
        }
    }
}
//释放链表
void list_destory(STNode_def* head)
{
	STNode_def* p = head;
	STNode_def* p_tmp = NULL;
	while(p != NULL)
	{
		p_tmp = p;
		p = p->next;
		free(p_tmp);
	}
}
int main()
{
    STNode_def* head = list_init();
    int i = 0;
    for (i=0; i<10; i++)
    {
        list_push_back(head, i);
    }

    list_sort(head, 1);
    printf("size:%d\n", list_size(head));
    list_print(head);

	
	list_destory(head);
    return 0;
}

在这里插入图片描述

#include <stdio.h>
#include <stdlib.h>
/**
*企业链表，与常规链表不同是，链表数据类型和链表进行分离(解耦)
*当业务发生变化，需要新的数据类型时，不需要写新的链表
*/

//与自定义数据类型node进行对应
typedef struct Node{
	struct Node *next;
}STNode_def;

//链表头结点
typedef struct LinkList{
	struct Node head;
	int size;				//包含链表大小因为获取链表大小时不需要每次遍历(链表结点数量过多会消耗时间)
}STLinkList_def;


#define SUCCESS 0
#define FAILURE -1

typedef void (*PRINTLIST)(STNode_def* node);
//链表初始化
STLinkList_def* linklist_init()
{
	STLinkList_def* list_ptr = (STLinkList_def*)malloc(sizeof(STLinkList_def));
	list_ptr->head.next = NULL;
	list_ptr->size = 0;

	return list_ptr;
}

//尾插入
int linklist_push_back(STLinkList_def* list_ptr, STNode_def* data)
{
	if (list_ptr == NULL || data == NULL)
	{
		return FAILURE;
	}
	
	//辅助结点指针，头结点指针赋值给赋值结点
	STNode_def* p = &(list_ptr->head);
	while (p->next != NULL)
	{
		p = p->next;
	}

	p->next = data;
	data->next = NULL;
	
	list_ptr->size++;
	return SUCCESS;
}


//头插入
int linklist_push_front(STLinkList_def* list_ptr, STNode_def* data)
{
	if (list_ptr == NULL || data == NULL)
	{
		return FAILURE;
	}
	
	data->next = list_ptr->head.next;
	list_ptr->head.next = data;
	
	list_ptr->size++;
	
	return SUCCESS;
}


//根据pos位置进行插入
int linklist_push_bypos(STLinkList_def* list_ptr, int pos, STNode_def* data)
{
	if (list_ptr == NULL || data == NULL)
	{
		return FAILURE;
	}
	if (pos < 0 || pos >= list_ptr->size)
	{
	    pos = list_ptr->size;   //pos位置不合法时，默认尾部插入  
	    printf("pos=%d\n", pos);  
	}
	int i = 0;
	STNode_def* p = &(list_ptr->head);
	
	//指定位置插入节点，需找出前驱结点
	while (p->next != NULL && i<pos) 
	{
        p = p->next;
        i++;
    }
    data->next = p->next;
    p->next = data;
    
    list_ptr->size++;
    
	return SUCCESS;
}


//尾删
int linklist_pop_back(STLinkList_def* list_ptr)
{
	if (list_ptr == NULL)
	{
		return FAILURE;
	}
	
	//辅助结点指针，需找到删除结点的前驱结点
	int i = 0;
	STNode_def* p = &(list_ptr->head);
	while (p->next != NULL && i < list_ptr->size-1)
	{
		p = p->next;
		i++;
	}

	p->next = NULL;
	list_ptr->size--;
	
	return SUCCESS;
}


//头删
int linklist_pop_front(STLinkList_def* list_ptr)
{
	if (list_ptr == NULL)
	{
		return FAILURE;
	}
	
	//辅助结点指针，需找到删除结点的前驱结点
    
	list_ptr->head.next = list_ptr->head.next->next;
	list_ptr->size--;
	
	return SUCCESS;
}


//指定pos位置删除
int linklist_pop_bypos(STLinkList_def* list_ptr, int pos)
{
	if (list_ptr == NULL)
	{
		return FAILURE;
	}
	
	//空链表删除也报错
	if (pos < 0 || pos > list_ptr->size -1 || list_ptr->size == 0)
	{
	    return FAILURE;
	}
	
	//辅助结点指针，需找到删除结点的前驱结点
	int i = 0;
	STNode_def* p = &(list_ptr->head);
	while (p->next != NULL && i < pos)
	{
		p = p->next;
		i++;
	}
    
	p->next = p->next->next;
	list_ptr->size--;
	
	return SUCCESS;
}

//遍历链表
void list_print(STLinkList_def* list_ptr, void (*PRINTLIST)(STNode_def*))
{
    if (list_ptr == NULL || PRINTLIST == NULL)
    {
        return;
    }
    STNode_def* p = &(list_ptr->head);
    while (p->next != NULL) 
    {
        p = p->next;
        PRINTLIST(p);
    }
}

//销毁链表
void list_destory(STLinkList_def* list_ptr)
{
    if (list_ptr == NULL)
    {
        return;
    }
    
    free(list_ptr);
    list_ptr = NULL;
}
//自定义数据类型
typedef struct Student{
    STNode_def node;
    char name[64];
    int age;
}STStudent_def;


//自定义数据输出函数
void student_info_print(STStudent_def* node)
{
    printf("name:%s, age=%d\n", node->name, node->age);
}

int main()
{
    STStudent_def p1;
    STStudent_def p2;
    STStudent_def p3;
    STStudent_def p4;
    STStudent_def p5;
    strcpy(p1.name, "刘备");
    strcpy(p2.name, "关羽");
    strcpy(p3.name, "张飞");
    strcpy(p4.name, "赵云");
    strcpy(p5.name, "诸葛亮");

    p1.age = 40;
    p2.age = 38;
    p3.age = 35;
    p4.age = 30;
    p5.age = 45;
    
    STLinkList_def * list_ptr = linklist_init();
    linklist_push_front(list_ptr, &p1);
    linklist_push_front(list_ptr, &p2);
    linklist_push_front(list_ptr, &p3);
    linklist_push_front(list_ptr, &p4);
    linklist_push_front(list_ptr, &p5);
    
    list_print(list_ptr, student_info_print);
    printf("size:%d\n", list_ptr->size);
    
    STStudent_def p6;
    strcpy(p6.name, "曹操");
    p6.age = 50;
    /*
    linklist_push_back(list_ptr, &p6);
    
    list_print(list_ptr, student_info_print);
    printf("size:%d\n", list_ptr->size);
    
    linklist_pop_back(list_ptr);
    
    list_print(list_ptr, student_info_print);
    printf("size:%d\n", list_ptr->size);

    linklist_pop_front(list_ptr);
    
    list_print(list_ptr, student_info_print);
    printf("size:%d\n", list_ptr->size);
    
    */
    linklist_push_bypos(list_ptr, 3, &p6);
    
    list_print(list_ptr, student_info_print);
    printf("size:%d\n", list_ptr->size);
    
    linklist_pop_bypos(list_ptr, 2);
    list_print(list_ptr, student_info_print);
    printf("size:%d\n", list_ptr->size);
    
    list_destory(list_ptr);
	return 0;
}

循环链表

#include <stdio.h>
#include <stdlib.h>
/**
*循环企业链表
*/

//与自定义数据类型node进行对应
typedef struct Node{
	struct Node *next;
}STNode_def;

//链表头结点
typedef struct CicLinklist{
	struct Node head;
	int size;				//包含链表大小因为获取链表大小时不需要每次遍历(链表结点数量过多会消耗时间)
}STCicLinklist_def;


#define SUCCESS 0
#define FAILURE -1

typedef void (*PRINTLIST)(STNode_def* node);
//循环链表初始化
STCicLinklist_def* ciclinklist_init()
{
	STCicLinklist_def* list_ptr = (STCicLinklist_def*)malloc(sizeof(STCicLinklist_def));
	list_ptr->head.next = &(list_ptr->head);
	list_ptr->size = 0;

	return list_ptr;
}

//尾插入
int ciclinklist_push_back(STCicLinklist_def* list_ptr, STNode_def* data)
{
	if (list_ptr == NULL || data == NULL)
	{
		return FAILURE;
	}
	
	//辅助结点指针，头结点指针赋值给赋值结点
	STNode_def* p = &(list_ptr->head);
	while (p->next != &(list_ptr->head))
	{
		p = p->next;
	}

	p->next = data;
	data->next = &(list_ptr->head);
	
	list_ptr->size++;
	return SUCCESS;
}


//头插入
int ciclinklist_push_front(STCicLinklist_def* list_ptr, STNode_def* data)
{
	if (list_ptr == NULL || data == NULL)
	{
		return FAILURE;
	}
	
	data->next = list_ptr->head.next;
	list_ptr->head.next = data;
	
	list_ptr->size++;
	
	return SUCCESS;
}


//根据pos位置进行插入
int ciclinklist_push_bypos(STCicLinklist_def* list_ptr, int pos, STNode_def* data)
{
	if (list_ptr == NULL || data == NULL)
	{
		return FAILURE;
	}
	if (pos < 0 || pos >= list_ptr->size)
	{
	    pos = list_ptr->size;   //pos位置不合法时，默认尾部插入  
	    printf("pos=%d\n", pos);  
	}
	int i = 0;
	STNode_def* p = &(list_ptr->head);
	
	//指定位置插入节点，需找出前驱结点
	while (p->next != &(list_ptr->head) && i<pos) 
	{
        p = p->next;
        i++;
    }
    data->next = p->next;
    p->next = data;
    
    list_ptr->size++;
    
	return SUCCESS;
}


//尾删
int ciclinklist_pop_back(STCicLinklist_def* list_ptr)
{
	if (list_ptr == NULL)
	{
		return FAILURE;
	}
	if (list_ptr->size == 0)
	{
	    return FAILURE;
	}
	//辅助结点指针，需找到删除结点的前驱结点
	int i = 0;
	STNode_def* p = &(list_ptr->head);
	while (p->next != &(list_ptr->head) && i < list_ptr->size-1)
	{
		p = p->next;
		i++;
	}

	p->next = &(list_ptr->head);
	list_ptr->size--;
	
	return SUCCESS;
}


//头删
int ciclinklist_pop_front(STCicLinklist_def* list_ptr)
{
	if (list_ptr == NULL)
	{
		return FAILURE;
	}
	if (list_ptr->size == 0)
	{
	    return FAILURE;
	}
	//辅助结点指针，需找到删除结点的前驱结点
	list_ptr->head.next = list_ptr->head.next->next;
	list_ptr->size--;
	
	return SUCCESS;
}


//指定pos位置删除
int ciclinklist_pop_bypos(STCicLinklist_def* list_ptr, int pos)
{
	if (list_ptr == NULL)
	{
		return FAILURE;
	}
	
	//空链表删除也报错
	if (pos < 0 || pos > list_ptr->size -1 || list_ptr->size == 0)
	{
	    return FAILURE;
	}
	
	//辅助结点指针，需找到删除结点的前驱结点
	int i = 0;
	STNode_def* p = &(list_ptr->head);
	while (p->next != NULL && i < pos)
	{
		p = p->next;
		i++;
	}
    
	p->next = p->next->next;
	list_ptr->size--;
	
	return SUCCESS;
}

//遍历链表
void list_print(STCicLinklist_def* list_ptr, void (*PRINTLIST)(STNode_def*))
{
    if (list_ptr == NULL || PRINTLIST == NULL)
    {
        return;
    }
    STNode_def* p = &(list_ptr->head);
    while (p->next != &(list_ptr->head)) 
    {
        p = p->next;
        PRINTLIST(p);
    }
}

//销毁链表
void list_destory(STCicLinklist_def* list_ptr)
{
    if (list_ptr == NULL)
    {
        return;
    }
    
    free(list_ptr);
    list_ptr = NULL;
}
//自定义数据类型
typedef struct Student{
    STNode_def node;
    char name[64];
    int age;
}STStudent_def;


//自定义数据输出函数
void student_info_print(STStudent_def* node)
{
    printf("name:%s, age=%d\n", node->name, node->age);
}

int main()
{
    STStudent_def p1;
    STStudent_def p2;
    STStudent_def p3;
    STStudent_def p4;
    STStudent_def p5;
    strcpy(p1.name, "刘备");
    strcpy(p2.name, "关羽");
    strcpy(p3.name, "张飞");
    strcpy(p4.name, "赵云");
    strcpy(p5.name, "诸葛亮");

    p1.age = 40;
    p2.age = 38;
    p3.age = 35;
    p4.age = 30;
    p5.age = 45;
    
    STCicLinklist_def * list_ptr = ciclinklist_init();
    ciclinklist_push_back(list_ptr, &p1);
    ciclinklist_push_back(list_ptr, &p2);
    ciclinklist_push_back(list_ptr, &p3);
    ciclinklist_push_back(list_ptr, &p4);
    ciclinklist_push_back(list_ptr, &p5);
    
    list_print(list_ptr, student_info_print);
    printf("size:%d\n", list_ptr->size);
    
    STStudent_def p6;
    strcpy(p6.name, "曹操");
    p6.age = 50;
    /*
    ciclinklist_push_front(list_ptr, &p6);
    
    list_print(list_ptr, student_info_print);
    printf("size:%d\n", list_ptr->size);
    
    ciclinklist_pop_back(list_ptr);
    
    list_print(list_ptr, student_info_print);
    printf("size:%d\n", list_ptr->size);

    ciclinklist_pop_front(list_ptr);
    
    list_print(list_ptr, student_info_print);
    printf("size:%d\n", list_ptr->size);
    */
    
    
    ciclinklist_push_bypos(list_ptr, 3, &p6);
    
    list_print(list_ptr, student_info_print);
    printf("size:%d\n", list_ptr->size);
    
    ciclinklist_pop_bypos(list_ptr, 2);
    list_print(list_ptr, student_info_print);
    printf("size:%d\n", list_ptr->size);
    
    list_print(list_ptr, student_info_print);
    printf("size:%d\n", list_ptr->size);
    list_destory(list_ptr);
	return 0;
}
最后冰吻free
关注
专栏目录
数据结构之普通链表实现
qq_45724328的博客
09-13 90
数据结构之普通链表实现 #include #include #include<stdlib.h> using namespace std; typedef struct _LinkNode { int data; //结点的数据域 struct _LinkNode* next; //下一个结点的指针域 }LinkNode, LinkList; //LinkList为指向结构体LNode的指针类型 bool InitList(LinkList*& L) { //链表的初始化 L
02-普通链表、企业链表
qq_43788522的博客
07-12 336
链表的两种实现方式一、普通链表的实现（1）头文件（2）函数的实现（3）测试二、企业链表的实现（1）头文件（2）函数的实现（3）测试 一、普通链表的实现 普通链表也就是我门平常上数据结构所写的一样。 （1）头文件 #ifndef LINKLIST #define LINKLIST //链表结点 typedef struct LINKNODE{ void* data;//指向任何类型数据 struct LINKNODE* next; }LinkNode; //打印函数指针(因为链表结点是void* 形指
C++ 数据结构 *** 普通链表
treeshy的博客
11-17 472
昨晚想看图的数据结构，于是打开了书。。恶补链表。。。 才意识到一个结点里指向下一个结点是指针，每次改变节点的指向时需要一个中间变量。。我真是太愚蠢了。。。上代码。。 代码如下: #pragma warning(disable:4996) #include #include #include #include #include #include #include
企业级的使用链表
永远积极向上、永远热泪盈眶、永远豪情满怀、永远坦坦荡荡
09-05 1657
一，企业级链表的设计数据结构的设计//链接链表的指针 struct LinedNode { struct LinedNode* next; } LinedNode;//保存链表的信息 struct LList { struct LinedNode toppoter; int m_size; }LList;typedef void* ListNode; 1,链表的初始化List
数据结构：静态链表、企业链表实现及使用
Rain的博客
02-28 333
文章目录一、静态链表二、循环链表三、双向链表四、企业链表 一、静态链表 二、循环链表 三、双向链表 四、企业链表 企业链表：如果我们使用原始的C语言写链表的话，数据类型是被固定死的，如果业务换了，需要另一种数据类型，我们又得重新在写一个链表，十分麻烦！因此为了方便使用，我们引出了企业链表。 作用：将实际的数据类型和链表相分离，实现实际的数据类型和链表的解耦。 那么什么是企业链表呢？我们之前学的单链...
JavaScript数据结构之单链表和循环链表
11-30
本文将主要讨论两种链表类型：单链表和循环链表。 单链表是由一系列节点组成的，每个节点包含两部分：数据域（存储实际数据）和指针域（存储指向下一个节点的引用）。在JavaScript中，我们可以定义一个Node类来表示...
数据结构-循环链表-C语言实现循环链表功能-数据结构学习
最新发布
05-26
C语言实现的数据结构中的循环链表 包含源码（.c文件），linux环境下编译生成的可执行文件，头文件 用于C语言以及数据结构的学习，熟练对循环链表边界的判定 实现了以下功能： 创建无头循环链表 向循环链表中插入...
C语言演示链表操作.rar_C语言_双向循环链表_数据结构_链表 list_链表操作
09-19
学习和掌握链表操作，尤其是双向循环链表，对于理解和编写复杂的数据结构和算法至关重要，这对于软件开发人员来说是必不可少的技能。在实际应用中，链表常用于实现如队列、栈、哈希表等高级数据结构，以及解决各种...
JAVA 数据结构链表操作循环链表
09-01
在Java编程中，数据结构是程序设计的基础，链表是一种常用的数据结构，它不依赖于数组的物理位置，而是通过节点间的引用关系进行组织。循环链表是链表的一种变体，它的特点是最后一个节点指向了链表的第一个节点，...
C语言数据结构之双向循环链表的实例
08-30
C语言数据结构之双向循环链表的实例 在计算机科学中，链表是一种常用的数据结构，它可以动态地分配内存来存储数据，且可以随机访问和插入、删除数据。双向循环链表是一种特殊的链表，它可以同时在链表的头部和尾部...
企业链表
Mr_Csyn的博客
12-04 314
企业链表 企业链表其实也就是传统链表的改进版本 链表结点有数据域和指针域 指针域是一个结构体，结构体有一个next指针，可以把结点关联起来 typedef struct LINKNODE { struct LINKNODE* next; }LinkNode; typedef struct MyData { LinkNode node; char name[64]; int age; }Mydata; 传统链表 跟企业链表相比，传统链表同样是一个数据域一个指针域 链表结构体包含的是链表信息,
数据结构与算法系列——链表详解
KeepUP
03-03 265
上次我们简单的对比了一下数组和链表的区别和各自的优缺点，今天我们来详细看一下链表这个结构。 链表的结构五花八门，我们几天主要看一下三种最常用的链表结构：单链表、双向链表和循环列表。 单链表 我们首先来看一下最简单、最常用的单链表。前边我们已经知道链表是通过指针将一些分散的内存块连接到一起。其中，我们把每个内存块叫做链表的一个结点。为了将每个结点连接到一起，每个结点不仅存储数据，而且还需要记录下...
数据结构之_单链表加强版企业链表的实现
weixin_30477797的博客
07-18 234
数据结构之_单链表加强版企业链表的实现 1.传统链表参见博文 https://www.cnblogs.com/wanghui1234/p/11196467.html 2.原理图 3.企业链表/通用链表(单向链表)案例代码 LinkList.h #ifndef LINKLIST_H #define LINKLIST_H #include<stdlib.h&...
C++之内核链表和企业链表
suren_jun的博客
10-13 563
作为数据结构中的基础结构之一，链表的优点就是可以不要求连续的存储空间，但是没有了随机访问，在按索引增删改查，似乎效率没有数组快，但是链表也有它优势的地方，linux内核和企业上，对于链表的时候，和我们一般学的方法有所不同，这里详细讲解一下。废话说到这里，开始上干货。
数据结构 (四) 线性表_企业链表
Fioman_GYM的博客
04-22 570
文章目录一. 企业链表概述① 企业链表简介 一. 企业链表概述 ① 企业链表简介 企业链表出现的原因: 我们在写传统的链表的时候,节点里面存放的有数据,如果数据的类型固定死了,再我们需要另外一种数据类型的时候,就需要重新写一个链表. 我们也可以使用void*万能指针不固定死数据类型,当然我们还有另外一种实现方式,就是使用企业链表,链表的node里面不存放具体的业务数据类型,这样我们的链表就不受业务数据的限制. 企业链表如何实现 业务数据分离出来,也就是说链表中的节点只保存指针域. 你定义的数据一般
C++企业链表
qq_41973378的博客
07-18 397
C++企业链表 开发工具与关键技术：C++、VisualStudio 作者：何任贤 撰写时间：2019年07月10日 所谓的企业链表其实只是因为企业经常用到，所以叫企业链表，它相当于linux内核链表的升级版， 那么这两种链表和传统链表有什么区别，它们和传统链表的区别就在于它们的指针域， 也就链表节点中的next指针，至于区别在哪里呢？ 就是传统链表的指针域在linux内核链表和企业链表...
【线性表——企业链表】
piano_diano的博客
12-01 188
企业链表 企业链表与普通的链表的区别是，后者的结点包含数据域和指针域，而前者只有指针域。 因为指针的灵活性，只要将指针强转为任意一种数据结构的指针，便能拥有想要的数据元素。 例如: 以下是两种不同的数据结构 typedef struct LINKNODE{ struct LINKNODE* next; }LinkNode; typedef struct PERSON{ char*...
.内核链表和普通链表的区别
02-29 5308
.内核链表和普通链表的区别          内核链表是一个双向链表，但是与普通的双向链表又有所区别。内核链表中的链表元素不与特定类型相关，具有通用性。          我们先来看一幅图          kernel list展示的是内核链表的结构，normallist展示的是普通链表的结构。head是链表头，p1,p2,p3是链表节点。从图中可以看出普通链表的p1的n
顺序表、单链表、循环单链表、循环双链表、有序单链表的排序的实现
weixin_34186950的博客
10-07 1515
一、单链表、循环单链表、循环双链表各自特点 链表是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每个节点里存到下一个节点的指针。由于不须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比顺序表O(logn)快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而顺序表的时间复杂度是O(1)。链表结构可以充分利用计算机内存空间...
数据结构讲解：循环链表与双向链表操作
在数据结构与算法的学习中，循环链表和双向链表是两种重要的链式存储结构，它们扩展了单链表的功能，为数据操作提供了更多的便利。 5.1 带头结点的链表 带头结点的链表是在线性链表的第一个元素前增加一个特殊的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值