什么是线性数据结构？

18 Mar 2025 | 23 分钟阅读

数据结构

数据结构是组织数据元素以特定形式的特殊方式。以特定顺序排列数据对于在较少的时间内轻松访问特定数据元素非常重要，而无需付出太多努力。

例如，在我们日常生活中，当我们把衣服整齐地放在一个抽屉里时，特别是按顺序放好，这样当我们想穿某件衣服时，就不需要费力去寻找它，节省了浪费时间。

同样，计算机系统也以特定的方式组织数据，以便轻松访问任何特定数据元素、删除它或对其执行任何其他操作，而无需付出太多努力，并且也可以在较短的时间内完成。

我们甚至可以进一步安排进入数据结构的数据元素，例如按升序或降序对元素进行排序。

数据结构类型

数据结构分为两类

原始数据结构
非原始数据结构

让我们看看它是什么以及它如何引出非线性数据结构。

1. 原始数据结构

原始数据结构就是预定义的数据结构，我们不需要给出特定的定义。为了导出非原始数据结构，我们将使用这些原始数据结构来轻松收集大量数据。这些数据结构包括 int、float、char 等。'int' 是一个数据类型，用于将我们的数据类型设置为整数类型；类似地，float 用于为用于存储小数位的我们使用的数据分配浮点类型，依此类推。

2. 非原始数据结构

非原始数据结构就是用来通过使用原始数据结构来创建特定数据结构定义的。它主要用于存储元素集合；它们可以是相同的数据类型，也可能根据程序的需要而有所不同。在非原始数据结构中，我们有一个抽象数据类型的概念。它是一种用户派生的数据类型，由用户定义。我们必须为在多个地方使用它而创建一个抽象数据类型。有各种非原始数据结构，如数组、链表、队列、栈等。

非原始数据结构类型

现在让我们简要了解一下线性数据结构和非线性数据结构。

线性数据结构

线性数据结构就是将数据元素一个接一个地线性排列。在这里，我们不能像在分层顺序中那样随机排列数据元素。
这种线性数据结构将遵循插入各种数据元素的顺序。同样，我们对元素执行删除操作。线性数据结构易于实现，因为计算机内存是线性排列的。其示例如数组、栈、队列、链表等。

让我们讨论其中一些类型

Array

数组是由主要相同数据类型的同质数据元素组成的集合。
数组由存在于连续内存位置的相似类型的数据元素组成。这里的连续意味着连续的地址位置。假设我们的特定数组从地址位置 1000 开始。根据其类型，下一个元素位于数据类型大小差异的连续内存位置。

Stack

栈也是一种基于 LIFO（后进先出）原理的重要线性数据结构。许多计算机应用程序以及操作系统和其他地方使用的各种策略本身都基于 LIFO 原理。在此原理中，最后进入的数据元素必须首先从中弹出，而最先压入栈中的元素最后弹出。在此方法中，我们将数据元素压入栈，直到达到其结束限制；之后，我们将弹出相应的值。

Queue

队列是一种重要的线性数据结构，广泛用于各种计算机应用，并且它也基于FIFO（先进先出）原理。它遵循执行操作的数据的特定顺序。在此数据结构中，数据从一端进入，即REAR端，而下一个数据在前一个之后进入队列。删除操作在另一端执行，即FRONT。

链表

链表是用于各种程序的另一种主要数据结构，甚至许多非线性数据结构也是使用这种链表数据结构实现的。顾名思义，它由一个通过持有下一个节点地址的节点链接组成。它属于线性数据结构的一部分，因为它形成了一个链式结构，一个数据节点通过携带该节点的地址与另一个节点顺序连接。
此数据不像数组中那样按顺序连续排列。同质数据元素放置在连续内存位置，以便检索数据元素更简单。

现在，让我们开始介绍非线性数据结构。在这里，我们还将详细讨论编码部分。

非线性数据结构

非线性数据结构是另一种重要类型，其中数据元素不是按顺序排列的；主要地，数据元素以随机顺序排列，而不形成线性结构。
数据元素存在于多层中，例如树。
在树中，数据元素以分层形式排列，而在图 G(V,E) 中，数据元素使用边和顶点以随机顺序排列。
需要多次遍历才能完全遍历所有元素。单次遍历不可能遍历整个数据结构。
每个元素可以有多个路径到达另一个元素。
数据项未按顺序组织的数据结构称为非线性数据结构。换句话说，非线性数据结构的数据元素可以连接到多个元素，以反映它们之间的特殊关系。

让我们讨论其中一些类型

树和图是非线性数据结构的类型。

Tree

树是一种非线性数据结构，由各种节点组成。树数据结构中的节点按分层顺序排列。

它包含一个根节点，对应于其各种子节点，位于下一层。树是按级别生长的，根节点的子节点数量有限，具体取决于树的阶数。
例如，在二叉树中，根节点的阶是 2，这意味着每个节点最多可以有 2 个子节点，不能更多。
非线性数据结构不能直接实现，而是使用数组和链表等线性数据结构来实现。
树本身是一个非常广泛的数据结构，分为各种类别，如二叉树、二叉搜索树、AVL 树、堆、最大堆、最小堆等。
上述所有类型的树根据其属性有所不同。

Graph

图是一种非线性数据结构，具有有限数量的顶点和边，这些边用于连接顶点。
图本身根据某些属性进行分类；如果我们谈论一个完全图，它由顶点集组成，并且每个顶点都与其他顶点连接，它们之间存在边。
顶点存储数据元素，而边表示顶点之间的关系。
图在各个领域都非常重要；网络系统使用图论及其原理在计算机网络中表示。
即使在地图中，我们也认为每个位置都是一个顶点，而两个位置之间的路径被视为边。
图表示的主要动机是找到两个顶点之间的最小距离，通过最小的边权重。

非线性数据结构的属性

当数据元素不存在于连续内存位置时，它用于组合存储数据元素。
它是组织和正确保存数据的有效方式。
它通过为每个数据元素提供足够的内存来减少内存空间的浪费。
与数组不同，我们必须定义数组的大小，然后为该数组分配后续内存空间；如果我们不想存储到数组范围内的元素，那么剩余的内存就会浪费。
因此，为了克服这个因素，我们将使用非线性数据结构，并且有多种选择可以从一个节点遍历到另一个节点。
数据以随机顺序存储在内存中。
它的实现相对困难。
涉及多个级别。
内存利用率高。

什么是树数据结构？

树：与数组、栈、链表和队列等线性数据结构不同，树是分层的。

树数据结构是称为节点的对象或实体的集合，它们链接在一起以表示或模拟层次结构。
此数据不像我们在数组中观察到的那样按顺序连续排列，同质数据元素放置在连续内存位置，以便检索数据元素更简单。
树数据结构是非线性的，因为它不按顺序存储。它是一个分层结构，因为树中的元素按多个级别排列。
树数据结构中的最高节点称为根节点。每个节点包含一些数据，数据可以是任何类型。树结构中的节点包含员工姓名，因此数据类型将是字符串。
每个节点都包含一些数据以及可以称为子节点的其他节点的链接或引用。

树中使用的术语

根节点：树由根节点组成；它是树的起始节点，从该节点开始生长任何树。根节点位于任何树的第 0 层。根据树的阶数，它可以拥有相应数量的子节点。例如，如果树的阶是 3，那么它最多可以有三个子节点，最少可以有 0 个子节点。
子节点：子节点是跟在根节点后面的节点，它有一个父节点并有一些祖先。它是位于其父节点下一级的节点。例如，如果任何节点位于第 5 层，那么可以肯定它的父节点位于第 4 层，就在其上一级。
边：边就是父节点和子节点之间的链接，称为两个节点之间的链接或边连接。
兄弟节点：具有相同父节点的节点称为彼此的兄弟节点。相同的祖先不是兄弟节点，只有父节点必须相同，才定义为兄弟节点。例如，如果节点 A 有两个子节点 B 和 C，则 B 和 C 称为兄弟节点。
叶子节点：叶子节点是没有子节点的节点。它是任何树的终止点。它也称为外部节点。
内部节点：内部节点是非叶子节点，至少有一个子节点。
节点的度：节点的度定义为子节点的数量。叶子节点的度始终为 0，因为它没有子节点，而内部节点至少有一个度，因为它至少有一个子节点。
树的高度：树的高度定义为根节点到最后一级叶子节点的距离。换句话说，高度是树延伸到的最高级别。

树的类型

树按如下类别划分

还有更多。

让我们讨论其中一些类型

1. 普通树 - 普通树就是一个 N 叉树，由一个根节点和多个子节点组成。子节点位于根节点的下一级，在这棵树中，树在生长。我们对根节点的子节点没有限制，我们可以称之为普通树。任何具有分层结构的树都可以称为通用树。通用树的特点是没有任何配置或对节点可以拥有的子节点数量的限制。一个节点可以有任意数量的子节点，树的方向可以是这些的任意组合。节点的度可以从 0 到 n。

2. 二叉树 - 它是普通树的一个非常重要的子类别。顾名思义，我们可以轻松预测二叉树只包含两个子节点。“二元”这个词的意思是“两个数字”，因此二叉树包含可以有两个子节点的节点。二叉树中的任何节点最多可以有 0、1 或 2 个节点。数据结构中的二叉树是高度功能化的 ADT，可以细分为各种类型。

元素最多有 2 个子节点的树称为二叉树。由于二叉树中的每个元素只能有 2 个子节点，我们通常将它们命名为左子节点和右子节点。它们在数据结构中非常常用，原因有两个：

用于获取节点和对其进行分类，如在二叉搜索树中所见。

通过分叉结构表示数据。

3. 二叉搜索树 (BST) 是二叉树的一个子类型，其组织方式是父节点的左子节点始终小于父节点，父节点的右子节点始终大于父节点。同样，整棵树也是这样生长的，它是二叉树的修改版本。在二叉搜索树中，与二叉树相比，我们有更多的限制；在二叉树中，我们必须保持每个节点的 0、1 或 2 个子节点，但在这里，它是一棵二叉树，此外，它必须具有某种插入子节点的顺序。在 BST 中，右子节点总是小于根节点，同样，左子节点大于根节点。在这里，我们将对二叉搜索树进行分类。

4. 完全二叉树：完全二叉树是二叉树的另一种形式，它最多有两个子节点；它包含 0 个或 2 个子节点。节点在完全二叉树中的插入总是从左到右进行的。

C 语言中的二叉树实现 -

// Implementation of the Binary tree in C programming language
#include<stdio.h>
#include<stdlib.h>
struct node               /* Structure of type node which consists of data part, 
the left pointer and the right pointer, which carries
 the addresses of left node and right node correspondingly */
{
	int data ;
	struct node* left ;
	struct node* right ;
} ;
struct node* create ( )
{
	struct node * n ;
	int a ;
	n = malloc ( sizeof ( struct node ) ) ;
	printf ( " Enter data in node : \n  " ) ;
	printf ( " Enter -1 for no node \n " ) ;
	scanf ( "%d " , &a ) ;
	if ( a == -1 )
	{
		return 0 ;
	}
	n -> data = a ;
	printf ( " Enter left part of %d \n " , a ) ;
	n -> left = create ( ) ;
	printf ( " Enter right part of %d \n " , a ) ;
	n -> right = create ( ) ;
	return n ;
}
void preorder ( struct node* n )
{
	if ( n != 0 )
   {
	printf  ( " %d \n " , n -> data ) ;
	preorder ( n -> left ) ;
	preorder ( n -> right ) ;
   }
}

void inorder ( struct node* n )
{
	if ( n != 0 )
	{
		inorder ( n -> left ) ;
		printf ( " %d \n " , n -> data ) ;
		inorder ( n -> right ) ;
	}
}
void postorder ( struct node* n )
{
	if ( n!= 0 )
	{
		postorder ( n -> left ) ;
		postorder ( n -> right ) ;
		printf ( " %d \n " , n -> data ) ;
	}
}

int heightoftree ( struct node *n )
{
	int hl , hr ;
	if ( n == 0 )
	{
		return 0 ;
	}
	else
	{
		hl = heightoftree ( n -> left ) ;
		hr = heightoftree ( n -> right ) ;
		if ( hl > hr ) 
		{
			return hl + 1 ;
		}
		else
		return hr + 1 ;
	}                                                                                                                                                                                                          	
}

void main ( )
{
	struct node* n ;
	n = create ( ) ;
	printf ( " Traversal are showing \n " ) ;
	printf ( " \n PREORDER TRAVERSAL \n \n " ) ;    // Preorder traversal of a tree
/* In preorder traversal first we will traverse the root node then we will print the left part of that node and in last we will print the right part */
	preorder ( n ) ;
	printf ( " \n INORDER TRAVERSAL \n \n " ) ;       // Inorder traversal of a tree
/* In inorder traversal first we will traverse the left part of the root node then we will print the root node and in last we will print the right part */
	inorder ( n ) ;	                       
	printf ( " \n POSTORDER TRAVERSAL \n \n " ) ;        // Post order traversal of a tree
/* In postorder traversal first we will traverse the left part of the root node then we will print the right part of the root node and then in in last we will print the root node */
	postorder ( n ) ;
	printf ( " \n Height of tree is %d " , heightoftree ( n ) ) ;
} 

上述程序的输出

C++ 语言中的二叉树实现 -

// Implementation of the Binary tree in C++ programming language
#include<iostream>
using namespace std ;
#include<stdlib.h>
/* Structure of type node which consists of data part,
the left pointer and the right pointer, which carries
the addresses of left node and right node correspondingly */
struct node        
{
	int data ;
	struct node* left ;
	struct node* right ;
} ;
struct node* create()
{
	struct node * n ;
	int a ;
	n = malloc(sizeof( struct node)) ;
	cout << " Enter data in node : " << endl ;
	cout << " Enter -1 for no node " << endl ;
	scanf ( "%d " , &a ) ;
	if ( a == -1 )
	{
		return 0 ;
	}
	n -> data = a ;
	cout << " Enter left part of " << a << endl ;
	n -> left = create ( ) ;
	cout << " Enter right part of " << a << endl ;
	n -> right = create ( ) ;
	return n ;
}
void preorder ( struct node* n )
{
	if ( n != 0 )
   {
	cout << n -> data << endl  ;
	preorder ( n -> left ) ;
	preorder ( n -> right ) ;
   }
}

void inorder ( struct node* n )
{
	if ( n != 0 )
	{
		inorder ( n -> left ) ;
		cout << n -> data << endl ;
		inorder ( n -> right ) ;
	}
}
void postorder ( struct node* n )
{
	if ( n!= 0 )
	{
		postorder ( n -> left ) ;
		postorder ( n -> right ) ;
		cout << n -> data << endl ;
	}
}

int heightoftree ( struct node *n )
{
	int hl , hr ;
	if ( n == 0 )
	{
		return 0 ;
	}
	else
	{
		hl = heightoftree ( n -> left ) ;
		hr = heightoftree ( n -> right ) ;
		if ( hl > hr ) 
		{
			return hl + 1 ;
		}
		else
		return hr + 1 ;
	}                                                                                                                                                                                                          	
}
int main ( )
{
	struct node* n ;
	n = create ( ) ;
	cout << " Traversal are showing " << endl ;
	cout << " PREORDER TRAVERSAL " << endl ;    // Preorder traversal of a tree
/* In preorder traversal first we will traverse the root node then we will print the left part of that node and in last we will print the right part */

	preorder ( n ) ;
	cout << " INORDER TRAVERSAL " << endl ;              // Inorder traversal of a tree
/* In inorder traversal, first we will traverse the left part of the root node, then we will print the root node, and last, we will print the right part */

	inorder ( n ) ;	
	cout << " POSTORDER TRAVERSAL " << endl ;         // Postorder traversal of a tree
/* In postorder traversal, first we will traverse the left part of the root node, then we will print the right part of the root node, and then last, we will print the root node */

	postorder ( n ) ;
	cout << " Height of tree is " << heightoftree ( n ) << endl ;
}

上述程序的输出

图

在图中，一个节点通过边与另一个节点相连。图是一种非线性数据结构，由节点和边组成，用 G ( V, E ) 表示，其中 V 表示顶点集，E 表示边集。图分为各种类别：有向、无向、加权和无权等。
此数据不像数组中那样按顺序连续排列。同质数据元素放置在连续内存位置，以便检索数据元素更简单。
与树不同，它没有根节点或子节点的概念。此外，它不像树那样没有特定的数据元素排列顺序，而树中数据元素是按特定分层顺序排列的。
每一棵树都称为一个图，或者说，我们称它为一棵生成树，它有 n-1 条边，其中 n 表示图中的顶点总数。

图的术语

顶点：数据元素用图的顶点表示。对于某个数据元素，有一个独立的顶点来存储该数据元素。
边：边是两个顶点节点之间的连接线；它是从一个顶点节点到另一个顶点的遍历路径。
无向边：无向边是两个顶点之间的边，没有方向；它对两个顶点都有方向，这意味着它是双向边。
有向边：有向边是两个顶点之间的边，有一个从一个节点到另一个节点的特定方向。
加权边：边上有一个特定值，我们称之为特定边的权重，用于从一个顶点遍历到另一个顶点。加权边对于找到一个节点到另一个节点的最小路径非常重要。
度：顶点的度定义为连接到该顶点的边的总数。
入度：顶点的入度定义为进入该特定顶点的边的总数。
出度：顶点的出度定义为从该顶点发出的边的总数。

图的类型

平凡图
有向图
无向图
加权图
简单图
多重图
零图
完全图

让我们讨论其中一些类型

1. 平凡图：平凡图只有一个顶点，这个顶点没有任何边。

2. 有向图：图由一组有向边组成，其中每条边都关联有特定方向。这些有向边指示了从一个顶点到另一个顶点的路径方向。

3. 无向图：图由一组无向边组成，其中每条边都连接到顶点但未指定特定方向。

4. 加权图：加权图是边具有某些权重的图；这意味着边具有从一个顶点到另一个顶点的值。

5. 简单图：简单图定义为两个顶点之间只有一条边的图。简单图不包含任何平行边和自环。

6. 多重图：多重图包含平行边和自环。与简单图相比，它更复杂。

7. 零图：零图由一组空边组成，其中顶点集不包含连接它们之间的任何边。

8. 完全图：完全图是指每个顶点都与其他所有顶点连接。在完全图中，每个顶点的度必须为 n - 1，其中 n 表示顶点的数量。

C 语言中的图实现 -

// Implementation of graph in C language
#include <stdio.h>
#include <stdlib.h>
// It is a structure which is used to represent the adjacency node of the adjacency list
struct adjacencynode {
	int data ;
	struct adjacencynode* next ;
} ;
// It is a structure which is used to represent the adjacency list
struct adjacencylist {
	struct adjacencynode* head ;
} ;
/* The structure named as graph is used to represent the graph, which consists of the array of vertices */
struct graph {
	int vertex ;
	struct adjacencylist* arr ;
} ;
// Function which is used to create the adjacency list node
struct adjacencynode* newnode ( int data )
{
struct adjacencynode* node = ( struct adjacencynode* )malloc(sizeof(struct
adjacencynode) ) ;
	node -> data = data ;
	node -> next = NULL ;
	return node ;
}
// The function which is used to create the vertex
struct graph* create ( int ver )
{
	struct graph* G = ( struct graph* ) malloc(sizeof(struct graph) ) ;
	G -> vertex = ver ;
	G -> arr = ( struct adjacencylist* )malloc(ver * sizeof(struct adjacencylist) ) ;
	int i ;
	for ( i = 0 ; i < ver ; ++i )
		G -> arr [ i ].head = NULL ;
	return G ;
}
// Function which is used to create the edge between two vertices
void Edge ( struct graph* G , int srcver , int destver )
{
	struct adjacencynode* check = NULL ;
	struct adjacencynode* node = newnode ( destver ) ;
	if ( G -> arr [ srcver ].head == NULL ) 
	{
	node -> next = G -> arr [ srcver ].head ;
	G -> arr [ srcver ].head = node ;
	}
	else 
{
		check = G -> arr [ srcver ].head ;
		while ( check -> next != NULL )
 {
			check = check -> next ;
		}
		check -> next = node ;
	}
	node = newnode ( srcver ) ;
	if ( G -> arr [ destver ].head == NULL) 
{
		node -> next = G -> arr [ destver ].head ;
		G -> arr [ destver ].head = node ;
	}
	else 
{
		check = G -> arr [ destver ].head ;
		while ( check -> next != NULL ) 
{
			check = check -> next ;
		}
		check -> next = node ;
	}
}
/* The function which is used to traverse the whole graph, using adjacency list and adjacency matrix method */
void Traversal ( struct graph* G )
{
	int ver ;
	for ( ver = 0 ; ver < G -> vertex ; ++ver ) 
{
		struct adjacencynode* p = G -> arr [ ver ].head ;
		printf ( " \n Adjacency list of vertex %d \n head " , ver ) ;
		while ( p ) 
{
			printf ( " -> %d " ,  p -> data ) ;
			p = p -> next ;
		}
		printf ( " \n " ) ;
	}
}
void main()
{
	int vertex = 5 ;
	struct graph* G = create ( vertex ) ;
	Edge ( G , 0 , 1 ) ;
	Edge ( G , 0 , 4 ) ;
	Edge ( G , 1 , 2 ) ;
	Edge ( G , 1 , 3 ) ;
	Edge ( G , 1 , 4 ) ;
	Edge ( G , 2 , 3 ) ;
	Edge ( G , 3 , 4 ) ;	
	Traversal ( G ) ;
}

上述程序的输出

C++ 语言中的图实现 -

// Implementation of graph in C++ language
#include <stdlib.h>
using namespace std ;
// It is a structure which is used to represent the adjacency node of the adjacency list
struct adjacencynode
{
	int data ;
	struct adjacencynode* next ;
} ;
// It is a structure which is used to represent the adjacency list

struct adjacencylist {
	struct adjacencynode* head ;
} ;
/* The structure named as graph is used to represent the graph, which consists of the array of vertices */

struct graph {
	int vertex ;
	struct adjacencylist* arr ;
} ;
// Function which is used to create the adjacency list node
struct adjacencynode* newnode ( int data )
{
	struct adjacencynode*  node = ( struct adjacencynode* ) malloc(sizeof(struct adjacencynode) ) ;
	node -> data = data ;
	node -> next = NULL ;
	return node ;
}

// The function which is used to create the vertex

struct graph* create ( int ver )
{
	struct graph* G = ( struct graph* ) malloc(sizeof(struct graph) ) ;
	G -> vertex = ver ;
	G -> arr = ( struct adjacencylist* ) malloc ( ver * sizeof(struct adjacencylist)) ;
	int i ;
	for ( i = 0 ; i < ver ; ++i )
		G -> arr [ i ].head = NULL ;
	return G ;
}
// Function which is used to create the edge between two vertices

void Edge ( struct graph* G , int srcver , int destver )
{
	struct adjacencynode* check = NULL ;
	struct adjacencynode* node = newnode ( destver ) ;
	if ( G -> arr [ srcver ].head == NULL ) 
	{
	node -> next = G -> arr[ srcver ].head ;
	G -> arr [ srcver ].head = node ;
	}
	else 
{

		check = G -> arr [ srcver ].head ;
		while  ( check -> next != NULL ) 
{
			check = check -> next ;
		}
		check -> next = node ;
	}
	node = newnode ( srcver ) ;
	if ( G -> arr [ destver ].head == NULL ) 
{
		node -> next = G -> arr [ destver ].head ;
		G -> arr [ destver ].head = node ;
	}
	else 
{
		check = G -> arr [ destver ].head ;
		while ( check -> next != NULL ) 
{
			check = check -> next ;
		}
		check -> next = node ;
	}

}
/* The function which is used to traverse the whole graph, using adjacency list and adjacency matrix method */

void Traversal ( struct graph* G )
{
	int ver ;
	for ( ver = 0 ; ver < G -> vertex ; ++ver ) 
{
		struct adjacencynode* p = G -> arr [ ver ].head ;
		cout << " Adjacency list of vertex " << ver << " head " << endl ;
		while (p) {
			cout << p -> data << endl ;
			p = p -> next ;
		}
		printf ( " \n " ) ;
	}
}
int main()
{	
	int vertex = 5 ;
	struct graph* G = create ( vertex ) ;
	Edge ( G , 0 , 1 ) ;
	Edge ( G , 0 , 4 ) ;
	Edge ( G , 1 , 2 ) ;
	Edge ( G , 1 , 3 ) ;
	Edge ( G , 1 , 4 ) ;
	Edge ( G , 2 , 3 ) ;
	Edge ( G , 3 , 4 ) ;	
	Traversal ( G ) ;
	return 0 ;
}

上述程序的输出

下一个主题数据结构中的 FIFO 方法

← 上一个下一个 →

什么是线性数据结构？

数据结构

数据结构类型

1. 原始数据结构

2. 非原始数据结构

非原始数据结构类型

线性数据结构

非线性数据结构

非线性数据结构的属性

什么是树数据结构？

树中使用的术语

树的类型

C 语言中的二叉树实现 -

C++ 语言中的二叉树实现 -

图

图的术语

图的类型

C 语言中的图实现 -

C++ 语言中的图实现 -

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

数据结构教程

DS 数组

DS 链表

DS 栈

DS 队列

DS 树

DS 图

DS 搜索

DS 排序

哈希与堆

差异

二叉树

二叉搜索树

AVL 树

单向链表

双向链表

循环链表

循环双向链表

DS 选择题

其他

什么是线性数据结构？

数据结构

数据结构类型

1. 原始数据结构

2. 非原始数据结构

非原始数据结构类型

线性数据结构

非线性数据结构

非线性数据结构的属性

什么是树数据结构？

树中使用的术语

树的类型

C 语言中的二叉树实现 -

C++ 语言中的二叉树实现 -

图

图的术语

图的类型

C 语言中的图实现 -

C++ 语言中的图实现 -

相关帖子

通用树 (N 元树)

二叉搜索树中的中序前驱和后继

三向链表

AVL 树的性质

计算指定范围内的优美数字

对 0、1 和 2 的链表进行排序

安全消息编码

高效计算矩阵对角线之和

二叉搜索树 vs 三元搜索树

对近乎排序、k 排序或几乎排序的数组进行排序

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器