数组、链表和树（内核数组和链表实现原理及代码）

最新推荐文章于 2025-04-15 10:15:14 发布
原创 最新推荐文章于 2025-04-15 10:15:14 发布 · 605 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构

本文深入探讨了数据结构中的栈、队列和树的实现，包括数组和链表两种基本存储方式。详细介绍了栈的先进后出原则，链表实现的栈、队列以及树的结构。通过C语言代码展示了数组和链表在实现栈的入栈、出栈、遍历，队列的入队、出队以及树的遍历等操作。同时，文章还讨论了循环链表在队列实现中的应用，以及链表在存储树结构时的优势。此外，补充了数组和链表实现的一般操作，如动态数组的增删查改以及链表的插入、删除等操作。

内核数组和链表实现栈，队列，树


系统学习完数组和链表后，才了解道其重要性，对于栈和链表以及树等结构，其内核分为数组实现和链表实现两种方式，为防止遗忘，特意整理如下，部分C代码暂时未补全，随后会更新全部，希望大家有问题可以及时评论，共同进步!!!

线性存储

栈

数组实现原理

在这里插入图片描述
栈：先进后出

数组由前向后存储数据，从后向前读取数据，实现栈的要求

链表实现原理

在这里插入图片描述

通过两个指针确定链表的储存内容，Bottom指向栈底，Top指向栈顶，无论是入栈还是出栈，只有Top指针在改变，Bottom指针始终不变。

C语言代码实现

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

typedef struct Node
{
	int data;
	struct Node* pNext;
}NODE, * PNODE;

typedef struct Stack
{
	PNODE pTop;
	PNODE pBottom;
}STACK, * PSTACK;

void init(PSTACK);
void push(PSTACK, int);
void traverse(PSTACK);
bool pop(PSTACK, int*);
void clear(PSTACK pS);

int main(void)
{
	STACK S;
	int val=5;

	init(&S);
	push(&S, 1);
	push(&S, 2);
	push(&S, 3);
	push(&S, 4);
	push(&S, 5);
	traverse(&S);

	pop(&S, &val);
	/*printf("出栈的元素是：%d\n", val);*/
	clear(&S);
	traverse(&S);

	return 0;
}

void init(PSTACK pS)
{
	pS->pTop = (PNODE)malloc(sizeof(NODE));
	if (NULL == pS->pTop)
	{
		printf("动态内存分配失败！\n");
		exit(-1);
	}
	else
	{
		pS->pBottom = pS->pTop;
		pS->pBottom->pNext = NULL;
	}
}

void push(PSTACK pS, int val)
{
	PNODE pNew = (PSTACK)malloc(sizeof(NODE));
	pNew->data = val;
	pNew->pNext = pS->pTop;
	pS->pTop = pNew;

	return;
}

void traverse(PSTACK pS)
{
	PNODE p = pS->pTop;
	
	while (p != pS->pBottom)
	{
		printf("%d  ", p->data);
		p = p->pNext;
	}
	printf("\n");

	return;
}

bool is_empty(PSTACK pS)
{
	if (pS->pBottom == pS->pTop)
	{
		return true;
	}
	else
	{
		return false;
	}
}

bool pop(PSTACK pS, int* pVal)
{
	if (is_empty(pS))
	{
		return false;
	}
	else
	{
		PNODE r = pS->pTop;
		pVal = pS->pTop->data;
		pS->pTop = r->pNext;
		free(r);
		r = NULL;

		return true;
	}
}

void clear(PSTACK pS)
{
	if (is_empty(pS))
	{
		return;
	}
	else
	{
		while(pS->pTop != pS->pBottom)
		{
			PNODE r = pS->pTop;
			pS->pTop = pS->pTop->pNext;
			free(r);
			r = NULL;
		}
	}
}

队列

数组实现原理

在这里插入图片描述

从数组的后方入队，从前方出队。
问题：出队后前部空间释放后，无法入队，整体操作在向后方移动，造成前方资源浪费，后方资源不足
解决方法：通过采用循环链式结构，保证数组合理利用。

C语言代码实现

//循环链表，数组实现
#include <stdio.h>
#include <malloc.h>
#include <stdbool.h>

typedef struct Queue
{
	int* pBase;
	int front;
	int rear;
}QUEUE;

void init(QUEUE*);
bool en_queue(QUEUE*, int val);
void traverse_queue(QUEUE*);
bool out_queue(QUEUE*, int*);

int main()
{
	QUEUE Q;
	int val;

	init(&Q);
	en_queue(&Q, 1);
	en_queue(&Q, 2);
	en_queue(&Q, 3);
	en_queue(&Q, 4);
	en_queue(&Q, 5);
	en_queue(&Q, 6);
	en_queue(&Q, 7);
	traverse_queue(&Q);

	out_queue(&Q, &val);
	printf("出队的元素为：%d\n", val);
	traverse_queue(&Q);
		
	return 0;
}

void init(QUEUE* pQ)
{
	pQ->pBase = (int*)malloc(sizeof(int) * 6);
	pQ->front = 0;
	pQ->rear = 0;
}

bool full_queue(QUEUE* pQ)
{
	if (pQ->front == (pQ->rear + 1) % 6)
	{
		return true;
	}
	else
	{
		return false;
	}
}

bool en_queue(QUEUE* pQ, int val)
{
	if (full_queue(pQ))
	{
		return false;
	}
	else
	{
		pQ->pBase[pQ->rear] = val;
		pQ->rear = (pQ->rear + 1) % 6;

		return true;
	}
}

void traverse_queue(QUEUE* pQ)
{
	int i = pQ->front;
	while (i != pQ->rear)
	{
		printf("%d  ", pQ->pBase[i]);
		i = (i + 1) % 6;
	}
	printf("\n");
}

bool emput_queue(QUEUE* pQ)
{
	if (pQ->front == pQ->rear)
	{
		return true;
	}
	else
	{
		return false;
	}
}


bool out_queue(QUEUE* pQ, int* pVal)
{
	if (emput_queue(pQ))
	{
		return false;
	}
	else
	{
		*pVal = pQ->pBase[pQ->front];
		pQ->front = (pQ->front + 1) % 6;

		return true;
	}
}

链表实现原理

在这里插入图片描述

通过两个指针pHead和pTail，可实现入队和出队操作，同时也避免了出现队满现象，使用时利用动态指针操作，实时使用和释放。

C++代码实现

#include <iostream>
using namespace std;

typedef struct node
{
	int data;
	struct node* pNext;
}NODE, *PNODE;

class Queue
{
public:
	Queue()
	{
		this->pHead = this->pTail = new NODE; // 初始化
		this->pHead->pNext = NULL;
	}
	
	//链式存储不用判断是否为满！
	void InQueue(int val)
	{
		PNODE pNew = new NODE;

		pNew->data = val;
		pNew->pNext = NULL;

		pTail->pNext = pNew;  //链表链接
		pTail = pNew; // 指针下移

		return;
	}

	bool Empty()const
	{
		if (this->pHead == pTail)
		{
			return true;
		}
		else
		{
			return false;
		}
	}

	int OutQueue()
	{
		if (Empty())
		{
			cout << "队列为空，无法出队！" << endl;
		}
		else
		{
			PNODE pTemp = pHead->pNext;
			pHead->pNext = pTemp->pNext;
			int val = pTemp->data;
			delete pTemp;
			pTemp = NULL;
			
			if (NULL == pHead->pNext) //如果队列为空
			{
				pTail = pHead;//尾指针也指向无用的头结点
			}
			return val;
		}
	}

	//遍历队列
	void Travers(void)const
	{
		PNODE pTemp = pHead->pNext;

		while (pTemp != NULL)
		{
			cout << pTemp->data << " ";
			pTemp = pTemp->pNext;
		}
		cout << endl;
	}

	void Clear()
	{
		while (!this->Empty())
		{
			OutQueue();
		}
	}

	~Queue()
	{
		this->Clear();
		delete pHead;
	}

private:
	PNODE pHead;
	PNODE pTail;
};

int main()
{
	Queue Q;
	for (int i = 0; i < 5; i++)
	{
		Q.InQueue(i + 1);
	}
	Q.Travers();

	Q.OutQueue();
	Q.OutQueue();
	Q.Travers();


	system("pause");

	return 0;
}

非线性结构

树

数组实现原理

在这里插入图片描述

一般采用完全二叉树，如上图所示，存在特定的规律进行一维数组的存储

链表实现原理

在这里插入图片描述

首先，必须要明确排序的方式：先序，中序，后序。其次，根据排列方式，我们可以通过该方式实现对树的内容实现

C语言代码实现

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

struct BTNode
{
	int data;
	struct BTNode* pLchild;
	struct BTNode* pRchild;
};

struct BTNode* CreateBTree(void);
void PreTraverseBTree(struct BTNode* pT);
void InTraverseBTree(struct BTNode* pT);

int main(void)
{
	struct BTNode* pT = CreateBTree();
	//PreTraverseBTree(pT);
	InTraverseBTree(pT);
	//PostTraverseBTree(pT);

	return 0;
}

struct BTNode* CreateBTree(void)
{
	struct BTNode* pA = (struct BTNode*)malloc(sizeof(struct BTNode));
	struct BTNode* pB = (struct BTNode*)malloc(sizeof(struct BTNode));
	struct BTNode* pC = (struct BTNode*)malloc(sizeof(struct BTNode));
	struct BTNode* pD = (struct BTNode*)malloc(sizeof(struct BTNode));
	struct BTNode* pE = (struct BTNode*)malloc(sizeof(struct BTNode));

	pA->data = 'A';
	pB->data = 'B';
	pC->data = 'C';
	pD->data = 'D';
	pE->data = 'E';

	pA->pLchild = pB;
	pA->pRchild = pC;
	pB->pLchild = pB->pRchild = NULL;
	pC->pLchild = pD;
	pC->pRchild = NULL;
	pD->pLchild = NULL;
	pD->pRchild = pE;
	pE->pLchild = pE->pRchild = NULL;

	return pA;
}

void PreTraverseBTree(struct BTNode* pT)
{
	if (NULL != pT)
	{
		printf("%c\n", pT->data);
		if (NULL != pT->pLchild)
		{
			PreTraverseBTree(pT->pLchild);
		}
		if (NULL != pT->pRchild)
		{
			PreTraverseBTree(pT->pRchild);
		}
	}
}

void InTraverseBTree(struct BTNode* pT)
{
	if (NULL != pT)
	{
		if (NULL != pT->pLchild)
		{
			InTraverseBTree(pT->pLchild);
		}

		printf("%c\n", pT->data);

		if (NULL != pT->pRchild)
		{
			InTraverseBTree(pT->pRchild);
		}
	}
}

void ProTraverseBTree(struct BTNode* pT)
{
	if (NULL != pT)
	{
		if (NULL != pT->pLchild)
		{
			ProTraverseBTree(pT->pLchild);
		}

		if (NULL != pT->pRchild)
		{
			ProTraverseBTree(pT->pRchild);
		}

		printf("%c\n", pT->data);
	}
}

补充

数组C语言实现代码

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdbool.h>
#include <malloc.h>
#include <stdlib.h> 

struct Arr
{
	int len; //数组的长度
	int cnt; //有效位数
	int * pBase;// 指针
};

void init_arr(struct Arr* pArr);
void append_arr(struct Arr* pArr);
void insert_arr(struct Arr* pArr);
void delete_arr(struct Arr* pArr);
void get(struct Arr* pArr);
bool is_empty(struct Arr* pArr);
bool is_full(struct Arr* pArr);
void sort_arr(struct Arr* pArr);
void show_arr(struct Arr* pArr);
void inversion_arr(struct Arr* pArr);

int main()
{
	struct Arr arr;

	init_arr(&arr);
	append_arr(&arr);
	append_arr(&arr);
	append_arr(&arr);
	//append_arr(&arr);
	show_arr(&arr);
	//insert_arr(&arr);
	//delete_arr(&arr);
	//sort_arr(&arr);
	inversion_arr(&arr);

	return 0;
}

void init_arr(struct Arr * pArr)
{
	int length;

	printf("请输入需要开辟数组的总长度：");
	scanf_s("%d", &length);
	
	pArr->pBase = (int*)malloc(sizeof(int) * length);
	if (NULL == pArr->pBase)
	{
		printf("动态内存分配失败!\n");
		exit(-1);
	}
	else 
	{
		pArr->len = length;
		pArr->cnt = 0;
	}
	return;
}

bool is_empty(struct Arr* pArr)
{
	if (0 == pArr->cnt)
	{
		return true;
	}
	else
	{
		return false;
	}
}

void show_arr(struct Arr* pArr)
{
	if (is_empty(pArr))
	{
		printf("数组为空！");
	}
	else
	{
		for (int i = 0; i < pArr->cnt; i++)
		{
			printf("%d  ", pArr->pBase[i]);
		}
		printf("\n");
	}
}

bool is_full(struct Arr* pArr)
{
	if (pArr->cnt == pArr->len)
	{
		return true;
	}
	else
	{
		return false;
	}
}

void append_arr(struct Arr* pArr)
{
	int val;

	if (is_full(pArr))
	{
		printf("数组已满，添加失败！\n");
	}
	else
	{
		printf("请输入添加的元素：");
		scanf_s("%d", &val);
		
		pArr->pBase[pArr->cnt] = val;
		pArr->cnt++;
	}
}

void insert_arr(struct Arr* pArr)
{
	int pos;
	int val;

	if (is_full(pArr))
	{
		printf("插入失败，数组已满！\n");
	}
	else
	{
		printf("请输入元素插入的位置（默认从1开始）：");
		scanf_s("%d", &pos);
		
		if (pos<1 || pos>pArr->len)
		{
			printf("插入失败，输入有误！\n");
		}
		else
		{
			printf("请输入插入的元素：");
			scanf_s("%d", &val);

			for (int i = pArr->cnt; i > pos - 1; i--)
			{
				pArr->pBase[i] = pArr->pBase[i - 1];
			}

			pArr->pBase[pos - 1] = val;
			pArr->cnt++;

			printf("添加后的数组为：\n");
			show_arr(pArr);
		}
	}
}

void delete_arr(struct Arr* pArr)
{
	int pos;

	if (is_empty(pArr))
	{
		printf("删除失败，数组为空！\n");
	}
	else
	{
		printf("请输入删除元素的位置（默认从1开始）：");
		scanf_s("%d", &pos);

		if (pos<1 || pos>pArr->cnt)
		{
			printf("删除失败，输入有误!");
		}
		else
		{
			for (int i = pos; i < pArr->cnt; i++)
			{
				pArr->pBase[i - 1] = pArr->pBase[i];
			}
			pArr->cnt--;

			printf("删除后的数组排序为：");
			show_arr(pArr);
		}
	}
}
void get(struct Arr* pArr)
{
	int pos;

	printf("请输入元素的位置：（默认从1开始）：");
	scanf_s("%d", &pos);

	if (pos<1 || pos>pArr->cnt)
	{
		printf("获取，输入有误！\n");
	}
	else
	{
		printf("该位置的元素为：%d\n", pArr->pBase[pos - 1]);
	}
}

void sort_arr(struct Arr* pArr)
{
	int temp;

	for (int i = 0; i < pArr->cnt-1; i++)
	{
		for (int j = 0; j < pArr->cnt - 1 - i; j++)
		{
			if (pArr->pBase[j] > pArr->pBase[j + 1])
			{
				temp = pArr->pBase[i];
				pArr->pBase[i] = pArr->pBase[i + 1];
				pArr->pBase[i + 1] = temp;
			}
		}
	}

	printf("排序后的结果为：\n");
	show_arr(pArr);
}

void inversion_arr(struct Arr* pArr)
{
	int i = 0;
	int j = pArr->cnt-1;
	int temp;

	while (i < j)
	{
		temp = pArr->pBase[i];
		pArr->pBase[i] = pArr->pBase[j];
		pArr->pBase[j] = temp;
		i++;
		j--;
	}

	printf("数组倒置后的结果为：\n");
	show_arr(pArr);
}

链表C语言实现代码

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

typedef struct Node
{
	int data; //数据域
	struct  Node* pNext; //指针域
}NODE, *PNODE;

PNODE create_list();
void traverse_list(PNODE pHead);
bool is_empty(PNODE pHead);
int length_list(PNODE);
bool insert_list(PNODE, int, int);
bool delete_list(PNODE, int, int*);
void sort_list(PNODE);

int main()
{
	PNODE pHead = NULL;
	int val;

	pHead = create_list();
	traverse_list(pHead);
	/*int len = length_list(pHead);
	printf("链表的长度是%d\n", len);*/
	//sort_list(pHead);
	
	if (!insert_list(pHead, 1, 3))
	{
		printf("失败！");
	}
	traverse_list(pHead);

	delete_list(pHead, 2, &val);
	printf("删除的元素为：%d", val);

	return 0;
}

PNODE create_list(void)
{
	int len;
	int i;
	int val;

	PNODE pHead = (PNODE)malloc(sizeof(NODE));
	PNODE pTail = pHead;
	pTail->pNext = NULL;

	if (NULL == pHead)
	{
		printf("分配失败，程序终止！\n");
		exit(-1);
	}

	printf("请输入您需要生成的链表节点的个数：len = ");
	scanf_s("%d", &len);

	for (i = 0; i < len; i++)
	{
		printf("请输入第%d个节点的值：", i+1);
		scanf_s("%d", &val);

		PNODE pNew = (PNODE)malloc(sizeof(NODE));
		if (NULL == pNew)
		{
			printf("分配失败，程序终止!\n");
			exit(-1);
		}

		pNew->data = val;
		pTail->pNext = pNew;
		pNew->pNext = NULL;
		pTail = pNew;
	}
	return pHead;
}

void traverse_list(PNODE pHead)
{
	PNODE p = pHead->pNext;
	
	while (NULL != p)
	{
		printf("%d  ", p->data);
		p = p->pNext;
	}
	printf("\n");

	return;
}

bool is_empty(PNODE pHead)
{
	if (NULL == pHead->pNext)
	{
		return true;
	}
	else
	{
		return false;
	}	
}

int length_list(PNODE pHead)
{
	PNODE p = pHead->pNext;
	int len = 0;

	while (NULL != p)
	{
		len++;
		p = p->pNext;
	}
	return len;
}

void sort_list(PNODE pHead)
{
	int i, j, t;
	PNODE p, q;

	for (i = 0, p=pHead->pNext; i < length_list(pHead) - 1; i++, p=p->pNext)
	{
		for (j = i + 1, q = p->pNext; j < length_list(pHead); j++, q = q->pNext)
		{
			if (p->data > q->data)
			{
				t = p->data;
				p->data = q->data;
				q->data = t;
			}
		}
	}
}

bool insert_list(PNODE pHead, int pos, int val)
{
	int i = 0;
	PNODE p = pHead;
	
	//将指针位置定到pos前
	while (NULL != p && i < pos - 1)
	{
		p = p->pNext;
		++i;
	}

	//检查指针位置是否合适
	if (i > pos - 1 || NULL == p)
	{
		return false;
	}

	PNODE pNew = (PNODE)malloc(sizeof(NODE));
	if (NULL == pNew)
	{
		printf("动态分配内存失败！\n");
		exit(-1);
	}
	pNew->data = val;
	PNODE q = p->pNext;
	p->pNext = pNew;
	pNew->pNext = q;

	return true;
}

bool delete_list(PNODE pHead, int pos, int* pVal)
{
	int i = 0;
	PNODE p = pHead;

	//将指针位置定到pos前
	while (NULL != p->pNext && i < pos - 1)
	{
		p = p->pNext;
		++i;
	}

	//检查指针位置是否合适
	if (i > pos - 1 || NULL == p->pNext)
	{
		return false;
	}

	PNODE q = p->pNext;
	*pVal = q->data;

	p->pNext = p->pNext->pNext;
	free(q);
	q = NULL;

	return true;
}
直击高频编程考点：链表知识及经典算法题总结
曾经“等你生日那天”都遥远得像未来，如今却可欢愉的挥手说“下个十年见”
10-24 5万+
了解链表结构，并在单链表或双链表中实现遍历、插入和删除以及分析在单链表或双链表中的各种操作的复杂度，同时附上相关面试考点的基本分类试题库（反转链表、链表中环的检测、链表中环的入口点、删除链表中倒数第K个节点、两个链表的第一个公共节点、链表的中间节点、合并两个有序链表、删除链表中的重复元素、排序链表、K 个一组翻转链表、旋转链表、分隔链表、奇偶链表、合并k个排序链表、链表相加、回文链表判定、回文链表重排、交换相邻节点、删除指定元素、反转链表指定部分、存在回文链表、链表最长递增子序列）
【内核链表】数据结构——深入理解内核链表的概念和操作&笔记
皮皮不调皮的博客
03-24 4539
内核链表一、内核链表的前置概念1、容器2、通用解决方案二、通用型链表节点的设计1、初始化2、增删操作3、查找节点4、遍历链表5、示例代码三、内核链表1、普通链表弊端2、内核链表2.1内核链表结构2.2内核链表的节点设计2.3内核链表的相关函数1）内核链表的初始化—— INIT_LIST_HEAD2）插入节点3）内核链表的遍历——list_for_each_entry（宏函数 就是一个for循环）4）内核链表节点删除——list_del5）内核链表的销毁——先把除了头结点的所有地址是否，最后释放头结点6）示例
数组、链表、树
LuckyRascal的博客
04-06 336
数据结构数组链表双向链表树红黑树 数组 特点： 1、内存地址连续，使用之前必须指定数组长度 2、可以通过下坐标的方式访问成员，查询效率高 3、增删操作会给系统带来性能的消耗（保证数组下坐标越界问题，需要动态扩容） 链表 单向链表和双向链表 双向链表：LinkList等 单项链表：哈希表 双向链表 特点： 1、灵活的空间需求，存储空间不需要连续 2、不支持下坐标的访问，支持顺序遍历检索 3、针对增删效率更高些，只和操作节点的前后节点有关系，无效移动元素 树 红黑树 红黑树 Red-Black Tree
链表和树的基本操作
06-23
很详细的链表和树的操作，包括二叉搜索树的建立与遍历。链表就是一个双向链表的操作
java模拟实现数组链表树图等数据结构
09-21
自己写的一个小项目。用数组模拟实现java的数据结构，性能还行。和源码思路比较接近。可以看看，有助于初学者了解数据结构与算法。
链表和树
ITnewpig的博客
10-28 5147
1.什么是单链表 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成:元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。 链表中的数据是以结点来表示的，每个结点的构成:元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存
poll为什么使用poll_list链表结构而不是数组 - 深入内核源码分析
CppPlayer
04-15 1173
动态扩展性：链表可以根据实际需要动态分配和释放内存，避免了固定大小数组带来的内存浪费或不足问题。高效的插入和删除操作：链表在插入和删除节点时具有常数时间复杂度，而数组需要移动大量元素，导致性能下降。优化内存管理：页对齐的内存分配可以简化内存管理操作，提高内存管理的效率。
linux内核链表与测试代码
09-22
在Linux内核中，链表主要用于动态数据结构，例如进程列表、设备驱动列表等，因为它们需要快速插入和删除操作，而这些操作在链表中比数组更为灵活。 Linux内核链表的核心结构是`list_head`，它定义了一个双向循环...
嵌入式实时操作系统内核任务调度核心组件_就绪表实现与优先级任务管理_基于静态数组和双向链表的就绪表数据结构设计与优化_用于RTOS任务调度的高效就绪表实现_包含优先级分组任务TC.zip
最新发布
08-03
在本压缩包文件中，提出了一种基于静态数组和双向链表的就绪表数据结构设计与优化方法。静态数组能够快速定位任务，而双向链表则可以有效地管理任务的增删。这种结构的设计目的是为了提供一个高效的任务调度机制，使...
链表与树
cindernat的博客
04-21 920
链表：将数据元素作为一个节点，用指针将节点连接起来的一种非顺序存储结构但逻辑顺序连续的线性表。 链表的基本结构 template struct PointNode { T data; PointNode*Pr,*Nx; } 链表的查找： 按位查找： template T LinkList::Get(int i)  {      Node *p; int
树、链表
lxj的博客
09-26 871
1. 树 1.1. 树（Tree）是n(n>=0)个结点的有限集。n=0时成为空树。 在任意有一颗非空树中： 有且仅有一个特定的结点被称为根的结点（结点都应包括两个部分：一个是需要用的实际数据data；另一个就是存储下一个结点地址的指针，即数据域和指针域。） 除根结点之外的其余数据元素被分为m（m≥0）个互不相交的集合T1，T2，……Tm-1，其中每一个集合Ti（1<=i&lt...
树和链表
u011932807的专栏
08-03 480
链表和树小结 链表和树都是数据结构的一种，它们的结构有类似的地方，节点中都由两个部分组成，一个时数据区域，一个指向其他节点的引用。 对于链表来说，它一般可以分为单链表，循环链表和双向链表。下面是单链表的具体java实现。 单链表中节点类有两个属性，一个是节点的数据内容，另一个是节点的引用。剩下的就是设置节点数据和引用之类的方法。 public class LinkNode{ ...
链表与树 python
文选的blog
11-22 1110
链表与树是面试中出现频率最高的数据结构。 链表 之所以频率比较高，是因为在面试那中时长控制下，时间上是不允许面试官有太多的时间考察算法题，所以一些高难度的算法题一般都是说出一些思路或者写出核心算法就好，而难度太低的数组和字符串考察难度太低而被很多面试官选择性的放弃，再说链表这种数据结构，结构简单，但是可以考察的点会很多，简单点的像写出链表的插入和删除方法，难点的直接一道相关算法题，但是整体的代码量都不是很大，难度也不会很简单。整体来说之所以面试考察的比较频繁，就是因为代码量少而精，有一定难度从而有了一定
数据结构 之 链表、树
星星点灯
04-12 222
链表 typedef struct LNode { int data; struct LNode* next; }LNode; LNode* p = (LNode)malloc(sizeof(LNode)); p->next=NULL; //c++ class LNode { public: int data; LNode* next; }; LNode* p = new LNode...
03、字节跳动-链表与树
applehub的博客
12-10 497
1、合并两个有序链表 public ListNode mergeTwoLists(ListNode l1, ListNode l2) { ListNode listNode = new ListNode(0); ListNode firstNode = listNode; while (l1 != null &amp;&amp; l2 != null) { ...
[链表与树]排序链表
邓乐来Jacob的博客
09-05 183
在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序。 示例 1: 输入: 4->2->1->3 输出: 1->2->3->4 示例 2: 输入: -1->5->3->4->0 输出: -1->0->3->4->5 /** * Definition for singly-linked list...
内核数组
fengkuangfj的专栏
05-06 770
static unsigned int hello[10]; for(int i = 0; i < 10; i++) cout<< hello[i]<< " "; cout<<endl;//输出结果是一串0 int another[10] = {5}; for(int i = 0; i < 10; i++) cout<< another[i]
链表和树总结
oemmm的博客
08-01 320
算法
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Fighting_1997

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值