数据结构精要-优快云博客

本文深入探讨了各种数据结构，包括数组、链表、栈、队列、哈希表、树等，详细解析了它们的特点、应用场景及优劣对比。特别介绍了二叉树、满二叉树、完全二叉树、B树、B+树的概念和实现，以及如何通过先序和中序遍历重建二叉树。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

数组（Array）

最简单的数据结构就是数组。
基于数组的数据结构有ArrayList（查询和修改性能较高，添加和删除性能较低）、Vector

栈（Stack）

是一种运算受限的线性表，只允许在表的一端进行插入和删除操作，这一端被称为栈顶，相对的另一端称为栈底。
栈中的元素遵循先进后出的原则。

链表（LinkedList）

单向链表：只能从头遍历到尾/只能从尾遍历到头。
双向链表：既可以从头遍历到尾，又可以从尾遍历到头。
基于链表的列表，查询更改比较慢，但是新增和删除比较快。

哈希表（Hash）

数组中元素的值和索引位置存在对应的关系，这样的数组就称之为哈希表。哈希表最大的优点是提供查找数据的效率。

队列（Queue）

队列是一种特殊的线性表
单向队列：先进先出，只能从队列尾部插入数据，从队列头部删除数据。

双向队列：可以从队列尾部/头部插入数据，只能从队列头部/尾部删除数据。

堆（Heap）

图（Graph）

在图中，任意的两个节点都可能有直接的关系。所以图中一个节点的前驱节点和后继节点的数目是没有限制的。
利用有向图的结构来判断？？？

树（Tree）

一般用来做索引的结构

二叉树

特点： ① 每个节点最多有两棵子树。
② 二叉树有左右子树之分。
存储结构：顺序存储（优点存储完全二叉树，节省空间）；链式存储（一般采用链式进行存储二叉树）。
满二叉树：所有叶子节点都在最后一层，而且节点的总数为2^n-1（n为树的高度）。
完全二叉树：对满二叉树的节点进行编号，从根节点起，自上而下，从左到右，依次放置不能留空。这样的树称为完全二叉树。（完全二叉树中，除了最后一层，其余各层都是满的。并且最后一层的节点必须从左到右依次放置，不能留空）

B-树

B树是一个结点可以拥有多于2个子节点的二叉查找树。
与平衡二叉树不同，B树的最大优点就是优化了大块数据的读写操作，B树减少定位记录时所经历的中间过程，从而加快存取速度，普遍用于数据库和文件系统。
B树允许每个结点有M-1个子节点。

B+树

B+树是对B树的一种变种，只有叶子结点保存数据，非叶子结点只保存索引

根据先序和中序重建二叉树

//首先建立一个二叉树类
class TreeNode {
		  //节点的权
          String value;
          //左节点
          TreeNode left;
          //右节点
          TreeNode right;
          TreeNode(String value) { 
          	this.value = value; 
          }
}
//实现重建二叉树
public class binaryTree {
  //主功能函数
  public static TreeNode reConstructBinaryTree(String[] pre,String[] in) {
      if(pre == null || in == null){
          return null;
      }
      TreeNode mm = reConstructBinaryTreeCore(pre, in, 0, pre.length-1, 0, in.length-1);
      return mm;
  }
  //核心递归
  public static TreeNode reConstructBinaryTreeCore(String[] pre, String[] in, int preStart, int preEnd, int inStart, int inEnd) {
      TreeNode tree = new TreeNode(pre[preStart]);
      tree.left = null;
      tree.right = null;
      //只有一个节点
      if (preStart == preEnd && inStart == inEnd) {
          return tree;
      }
      int root = 0;
      for(root= inStart; root < inEnd; root++){
          if (pre[preStart] == in[root]) {
              break;
          }
      }
      int leftLength = root - inStart;
      int rightLength = inEnd - root;
      if (leftLength > 0) {
          tree.left = reConstructBinaryTreeCore(pre, in, preStart+1, preStart+leftLength, inStart, root-1);
      }
      if (rightLength > 0) {
          tree.right = reConstructBinaryTreeCore(pre, in, preStart+1+leftLength, preEnd, root+1, inEnd);
      }
      return tree;
  }

 

	//先序遍历
    public static void preTraverseBinTree(TreeNode node){
        if (node==null) {
              return;
          }
        System.out.print(node.val+",");
        if (node.left!=null) {
            preTraverseBinTree(node.left);
          }
        if(node.right!=null){
            preTraverseBinTree(node.right);
        }
      }
    //中序遍历
    public static void inTraverseBinTree(TreeNode node){
        if (node==null) {
              return;
          }
        if (node.left!=null) {
            inTraverseBinTree(node.left);
          }
        System.out.print(node.val+",");
        if(node.right!=null){
            inTraverseBinTree(node.right);
        }
      }
  //后序遍历
    public static void postTraverseBinTree(TreeNode node){
        if (node==null) {
              return;
          }
        if (node.left!=null) {
            postTraverseBinTree(node.left);
          }
        if(node.right!=null){
            postTraverseBinTree(node.right);
        }
        System.out.print(node.val+",");
      } 
  //层次遍历
  public static void floorTraversing(TreeNode node){
 		if(node == null){
 			return;
		 }
	 LinkedList<TreeNode> queue = new LinkedList<>();
	 queue.offer(node);	
	 while(!queue.isEmpty()){	
		 TreeNode no = queue.poll();
		 System.out.print(no.val+" ");
		 if(no.left != null){
			 queue.offer(no.left);
		 }
		 if(no.right != null){
		 queue.offer(no.right);
		 }
	 }
 }

  public static void main(String[] args){
      String pre[] = {"A","B","C","D","E","H","F","G"};
      String in[]  = {"D","C","E","B","A","F","H","G"};
      TreeNode tree = reConstructBinaryTree(pre, in);
      System.out.print("层次遍历结果:  {");
      floorTraversing(tree);
      System.out.println("}");
    }
}