数据结构（三）

最新推荐文章于 2022-04-16 20:54:39 发布
最新推荐文章于 2022-04-16 20:54:39 发布
阅读量3k 收藏 4
点赞数 2
分类专栏： 算法与数据结构 文章标签： 数据结构 二叉树 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44590534/article/details/106179644
版权

树

树型结构是一类非常重要的非线性数据结构，其中以二叉树最为常用。直观来看，树是以分支关系定义的层次结构。

树的术语

在这里插入图片描述

根（Root）：树的最顶端的结点（A），一个树仅有一个根节点，根节点无父节点。

子树（SubTree）：当树中的结点数大于一个时，根结点下面的子结点又可以做为根结点与其下面的结点组成一棵树，称为根结点的子树。（以B，C，D为根结点的树都是A的子树）

结点的度（Degree）：该结点拥有的子树个数。（如A的度为3，B的度为2，C的度为0，D的度为1）

叶子（Leaf）或终端节点：度为0（无子结点）的结点。（树A的叶节点为E，F，C，G）

非终端节点或分支节点：度不为0（非叶子结点）的结点。（树A的非终端节点为B，D）

孩子（Child）：结点的子树的根节点。（A的孩子为B，C，D）
双亲（Parent）：结点包含子结点，那么该结点就称为其子结点的双亲（父结点）。（B，C，D的双亲为A结点）

兄弟（Sibling）：同一个双亲的孩子结点之间互称为兄弟。（E，F为兄弟）
祖先：结点的祖先是从根结点到该结点所经分支上的所有结点。（E的祖先为B，A）

子孙：以某结点为根的子树中的任一结点都称为该结点的子孙。（除A以外的结点都是A的子孙）

层次（Level）：从根节点开始定义，根为第一层，根节点的孩子为第二层。

堂兄弟：双亲在同一层的结点互称为堂兄弟。（E和G，F和G互为堂兄弟）

树的深度：树中结点的最大层次称为树的深度。（树A的深度为3）

有序树：如果将树中结点的各子树看成从左至右是有次序的（即不能互换顺序）。

无序树：如果树中的节点各子树可以互换次序，则称为无序树。

森林（Forest）：互不相交的树的集合。对树中的每个结点而言，其子树的集合称为森林。

二叉树

在这里插入图片描述

二叉树（Binary Tree）`是一种树形结构，特点是每个结点至多只有两颗子树（即二叉树中不存在度大于2的结点），并且二叉树的子树有左右之分，其次序不能任意颠倒。

满二叉树：一棵深度为k且有2k-1个结点的二叉树称为满二叉树。满二叉树中每一层中的结点都是最大结点数，只包含饱和度为0和2的节点，且度为0的结点只能出现在最后一层。

完全二叉树：对于满二叉树，约定编号从根节点起，自上而下，自左至右。深度为k的，有n个结点的二叉树，当且仅当每一个结点都与深度为k的满二叉树中编号从1至n的节点一一对应时，称为完全二叉树。完全二叉树所有的叶结点都出现在最下面两层上，最下面一层的结点都集中在该层最左边的若干个位置。

二叉树的五种基本形态：
在这里插入图片描述

二叉树的性质：

1.在二叉树的第i层上至多有2i-1个节点（i>=1）。

2.深度为k的二叉树至多有2k-1个节点（k>=1）。

3.对任意一颗二叉树T，如果其终端节点为n0，度为2的结点数为n2，则n0=n2+1。

4.具有n个结点的完全二叉树的深度为$ \lfloor log_2 n \rfloor + 1$。

5.如果对一棵有n个结点的完全二叉树（其深度为 ⌊ l o g 2 n ⌋ + 1 \lfloor log_2n \rfloor+1 ⌊log2​n⌋+1）的结点按层序编号（从第1层到第 ⌊ l o g 2 n ⌋ + 1 \lfloor log_2n \rfloor +1 ⌊log2​n⌋+1，每层从左至右），则对任一结点（1<=i<=n），有：

（1）如果i=1，则结点i是二叉树的根，根节点无双亲；如果i>1，则其双亲节点为 ⌊ i / 2 ⌋ \lfloor i/2 \rfloor ⌊i/2⌋。

（2）如果2i>n，则结点i无左孩子（结点i为叶子结点）；否则其左孩子是节点2i；

（3）如果2i+1>n，则结点i无右孩子，则结点i无右孩子；否则其右孩子是结点2i+1；

二叉树的存储结构
在这里插入图片描述在这里插入图片描述

顺序存储结构（数组）：用一组地址连续的存储单元依次自上而下，自左至右存储完全二叉树上的结点元素，即将完全二叉树上的编号为i的结点元素存储在如上定义的一维数组中下标为i-1的分量中。0表示不存在次结点，这种结构仅适用于完全二叉树（空间利用率较高）。

在这里插入图片描述

链式存储结构（链表）：由二叉树的概念可知，二叉树的结点中至少包含三个区域，即数据域，左右指针域。为了方便找到双亲节点，还可以加入父节点指针。利用这种结点结构所得二叉树的存储结构分别称为二叉链表和三叉链表。

二叉树的方法：

1.创建根结点，获取根节点，为指定结点添加子结点

2.遍历：深度遍历（先序，中序，后序遍历），广度遍历

3.查找某个结点是否在树中，获取树中结点数，获取树的高度，获取树的叶结点数，获取结点的父节点

4.判断树是否为空，判断二叉树是否是完全二叉树

基于数组的二叉树

方法概述：

1.创建根结点（creatRoot），添加结点（add），树中结点数

2.树是否为空（isEmpty）

3.根据层数打印二叉树

public class ArrayBinaryTree<T> {
	private T[] data;
	private int deep;
	private int capacity;
	private int size;

	/**
	 * 初始化需要提供二叉树的深度，可以计算出需要分配的数组大小
	 * @param deep:二叉树的深度
	 */
	public ArrayBinaryTree(int deep) {
		this.deep = deep;
		capacity = (int) Math.pow(2, deep) - 1;
		data = (T[]) new Object[capacity];
	}

	/**
	 * 创建根节点
	 * @param value：根节点的值
	 */
	public void creatRoot(T value) {
		data[0] = value;
		size++;
	}

	/**
	 * 向二叉树中添加结点
	 * @param value：待插入结点的值
	 * @param index：待插入结点的父节点，也就是插入位置
	 * @param left：插入位置是否是左子结点
	 */
	public void add(T value, int index, boolean left) {
		if (2 * index + 1 >= capacity) {
			throw new RuntimeException("树已满，无法继续插入！");
		}
		if (data[index] == null) {
			throw new RuntimeException("index节点为空，无法插入！");
		}
		if (left) {
			data[index * 2 + 1] = value;
			size++;
		} else {
			data[index * 2 + 2] = value;
			size++;
		}
	}

	public boolean isEmpty() {
		return data[0] == null;
	}

	public int size() {
		return size;
	}

	public void print() {
		for (int i = 1; i <= deep; i++) {
			int k = (int) Math.pow(2, i - 1) - 1;
			int j = (int) Math.pow(2, i) - 2;
			System.out.print("第" + i + "层上的数据为：");
			while (k <= j) {
				System.out.print(data[k++] + ",");
			}
			System.out.println();
		}
	}
}

基于二叉链表的二叉树

方法概述：

1.创建根结点（creatRoot），为指定结点添加子节点（add）

2.获取根结点（getRoot），获取树中结点数量（size），获取树的高度（getHeight），获取叶结点的数量（getLeafs），根据结点中的值查找某个节点findNode

3.判断树是否为空（isEmpty），判断树是否是完全二叉树（isCompleteBTree），

4.遍历二叉树（traversing binary tree）

​ 4.1深度优先遍历（Depth First Search，DFS）：先序遍历（DLR），中序遍历（LDR），后续遍历（LRD）分 别为preOrder，inOrder，postOrder

​ 4.2广度优先遍历（Breadth First Traversal，BFS）：逐层访问每层的结点，BSF

public class LinkedListBinaryTree<T> {
	// 封装结点
	class Node<T> {
		public T data;
		public Node left;
		public Node right;

		public Node(T data) {
			this.data = data;
			this.left = null;
			this.right = null;
		}
	}

	private Node<T> root;
	private int size;

	public LinkedListBinaryTree() {
		root = null;
		size = 0;
	}

	/**
	 * 创建根结点
	 * 
	 * @param value：根结点的值
	 */
	public void creatRoot(T value) {
		if (value == null) {
			throw new RuntimeException("根节点不能为空！");
		}
		Node<T> node = new Node<T>(value);
		root = node;
		size++;
	}

	public Node getRoot() {
		if (root == null) {
			throw new RuntimeException("根结点为空！");
		}
		return root;
	}

	public boolean isEmpty() {
		return root == null;
	}

	public int size() {
		return size;
	}

   	/**
	 * 在指定的节点处插入结点
	 * 
	 * @param node：插入结点的父结点
	 * @param value：待插入结点的值
	 * @param left：是否是左子节点
	 * @return：返回被插入后的结点
	 */
	public Node add(Node<T> node, T value, boolean left) {
		if (value == null) {
			throw new RuntimeException("子结点为空!");
		}
		if (node == null) {
			throw new RuntimeException("父结点为空！");
		}
		Node<T> n;
		if (left) {
			if (node.left != null) {
				throw new RuntimeException("左节点已存在！");
			}
			n = new Node<T>(value);
			node.left = n;
			size++;
		} else {
			if (node.right != null) {
				throw new RuntimeException("右节点已存在！");
			}
			n = new Node<T>(value);
			node.right = n;
			size++;
		}
		return n;
	}

	/**
	 * 获取树的深度
	 * 
	 * @param root：待获取深度树的根结点
	 * @return：返回树的深度
	 */
	public int getHeight(Node root) {
		if (root == null) {
			return 0;
		}
		int leftHeight = 0;
		int rightHeight = 0;
		leftHeight = getHeight(root.left);
		rightHeight = getHeight(root.right);
		return leftHeight >= rightHeight ? ++leftHeight : ++rightHeight;
	}

	/**
	 * 先序遍历
	 * 
	 * @param root:要遍历树的根结点
	 */
	public void preOrder(Node root) {
		if (root == null) {
			return;
		}
		System.out.print(root.data + ",");
		preOrder(root.left);
		preOrder(root.right);
	}

	/**
	 * 中序遍历:要遍历树的根结点
	 * 
	 * @param root
	 */
	public void inOrder(Node root) {
		if (root == null) {
			return;
		}
		inOrder(root.left);
		System.out.print(root.data + ",");
		inOrder(root.right);
	}

	/**
	 * 后序遍历
	 * 
	 * @param root：要遍历树的根结点
	 */
	public void postOrder(Node root) {
		if (root == null) {
			return;
		}
		postOrder(root.left);
		postOrder(root.right);
		System.out.print(root.data + ",");
	}

    /**
	 * 广度遍历
	 */
	public void BFS() {
		Node root = this.root;
		Queue<Node> queue = new LinkedList<Node>();
		LinkedList<Node> list = new LinkedList<Node>();
		queue.offer(root);
		while (!queue.isEmpty()) {
			Node node = queue.poll();
			list.add(node);
			if (node.left != null) {
				queue.offer(node.left);
			}
			if (node.right != null) {
				queue.offer(node.right);
			}
		}
		Iterator it = list.iterator();
		while (it.hasNext()) {
			Node cur = (Node) it.next();
			System.out.print(cur.data + ",");
		}
	}
    
	/**
	 * 获取叶子结点的个数
	 * 
	 * @param root：要获取叶子结点的根结点
	 * @return：叶子结点的个数
	 */
	public int getLeafs(Node<T> root) {
		if (root == null) {
			return 0;
		} else if (root.left == null && root.right == null) {
			System.out.print("叶节点：" + root.data + ",");
			return 1;
		}
		int leftLeafs = 0;
		int rightLeafs = 0;
		leftLeafs = getLeafs(root.left);
		rightLeafs = getLeafs(root.right);
		return leftLeafs + rightLeafs;
	}

	/**
	 * 获取root树第k层上结点数
	 * 
	 * @param root：待获取的数的根结点
	 * @param k：第k层元素
	 * @return：返回root第k层结点个数
	 */
	public int getKNodeNum(Node root, int k) {
		if (k == 1) {
			if (root == null) {
				return 0;
			} else {
				return 1;
			}
		}
		int lNodeNum;
		int rNodeNum;
		lNodeNum = getKNodeNum(root.left, k - 1);
		rNodeNum = getKNodeNum(root.right, k - 1);
		return lNodeNum + rNodeNum;
	}

	/**
	 * 在根结点为root的树中查找值x的结点
	 * 
	 * @param root：树根的结点
	 * @param x：待查找结点的值
	 * @return：返回树中值为x的结点
	 */
	public Node findNode(Node root, T x) {
		if (root == null) {
			return null;
		} else if (root.data == x) {
			return root;
		}
		Node lNode = findNode(root.left, x);
		if (lNode != null) {
			return lNode;
		}
		Node rNode = findNode(root.right, x);
		if (rNode != null) {
			return rNode;
		}
		return null;

	}

	/**
	 * 判断是否是完全二叉树
	 * 
	 * @return
	 */
	public boolean isCompleteBTree() {
		Node root = this.root;
		Queue<Node> queue = new LinkedList<Node>();
		queue.offer(root);
		while (!queue.isEmpty()) {
			Node pre = queue.poll();
			if (pre == null) {
				break;
			}
			queue.offer(pre.left);
			queue.offer(pre.right);
		}
		while (!queue.isEmpty()) {
			Node cur = queue.poll();
			if (cur != null) {
				return false;
			}
		}
		return true;
	}
    
	//	测试用例
	public static void main(String[] args) {
		LinkedListBinaryTree<Integer> llbt = new LinkedListBinaryTree<Integer>();
		llbt.creatRoot(2);
		llbt.add(llbt.getRoot(), 3, true);
		llbt.add(llbt.getRoot(), 5, false);
		llbt.add(llbt.findNode(llbt.getRoot(), 3), 7, true);
		llbt.add(llbt.findNode(llbt.getRoot(), 3), 8, false);
		llbt.add(llbt.findNode(llbt.getRoot(), 5), 10, true);
		llbt.add(llbt.findNode(llbt.getRoot(), 5), 12, false);
		System.out.println("树中的结点数量为：" + llbt.size());
		System.out.println("root的深度为：" + llbt.getHeight(llbt.getRoot()));
		
        System.out.print("先序遍历：");
		llbt.preOrder(llbt.getRoot());
		System.out.println();
        
		System.out.print("中序遍历：");
		llbt.inOrder(llbt.getRoot());
		System.out.println();
        
		System.out.print("后序遍历：");
		llbt.postOrder(llbt.getRoot());
		System.out.println();
        
		System.out.print("广度遍历：");
		llbt.BFS();
		System.out.println();
        
		System.out.println("第2层的节点数量为：" + llbt.getKNodeNum(llbt.getRoot(), 2));
		System.out.println("第3层的节点数量为：" + llbt.getKNodeNum(llbt.getRoot(), 3));
		System.out.println("叶结点的数量为：" + llbt.getLeafs(llbt.getRoot()));
		System.out.println("是否为空：" + llbt.isEmpty());
		System.out.println("是否是完全二叉树：" + llbt.isCompleteBTree());
		System.out.println("2的父节点为：" + llbt.getParent(llbt.getRoot(), 2));
		System.out.println("3的父节点为：" + llbt.getParent(llbt.getRoot(), 3).data);
		System.out.println("10的父节点为：" + llbt.getParent(llbt.getRoot(), 10).data);
	}
}

测试结果：

树中的结点数量为：7
root的深度为：3
先序遍历：2,3,7,8,5,10,12,
中序遍历：7,3,8,2,10,5,12,
后序遍历：7,8,3,10,12,5,2,
广度遍历：2,3,5,7,8,10,12,
第2层的节点数量为：2
第3层的节点数量为：4
叶节点：7,叶节点：8,叶节点：10,叶节点：12,叶结点的数量为：4
是否为空：false
是否是完全二叉树：true
2的父节点为：null
3的父节点为：2
10的父节点为：5

线索二叉树

线索二叉树（Threaded Binary Tree）

线索化实质上是将二叉链表中的空指针改为指向前驱或者后继的线索，而前驱或后继的信息只能在遍历中才能得到，因此线索化的过程即在遍历的过程中修改空指针的过程。

适用于经常遍历或查找结点在遍历所得线性序列中的前驱和后继，则应该使用线索链表做存储结构。

二叉查找（搜索，排序）树

在这里插入图片描述

二叉查找树（Binary Search Tree，BST）又被称为二叉搜索树。设x为二叉查找树中的一个结点，x结点包含关键字key，结点x的key值记为key[x]。如果y是x的左子树中的一个结点，则key[y]<=key[x]；如果y是x的右子树的一个结点，则key[y]>=key[x]。

简单来说，任意选取一个结点，以该结点为根节点的左右子树中，若左子树不为空，则左子树中的结点值均小于该跟结点的值，若右子树不为空，右子树中的节点值均大于该根节点的值。

总的来说二叉查找树相对于二叉树有三个特征：

1.任取一个结点，其值大于左子树中任意结点的值，其值小于任意右子树中任意结点的值（有序）。

2.任意结点的左，右子树也分别为二叉查找树

3.二叉查找树中没有键值相等的结点。

二叉查找树的方法：

因为二叉查找树结点之间具有大小关系，因此在添加结点方法中可以根据待添加结点的值与根结点比较，如果小于根结点的值则向左移动，如果大于根结点的值则向右移动，继续以上步骤直到找到为null时，插入此节点。同样这种方法还可以用于查找方法。

删除二叉树中结点时，根据待删除结点的左右子节点是否为空分为以下四种情况：

1.左右子结点都为空（叶子结点）

在这里插入图片描述

2.左右子结点都不为空

在这里插入图片描述

待删除的结点左右子树都不为空，这时需要将32结点右子树中的最小值作为代替32结点的新根结点。

3.左子结点为空，右子节点不为空
在这里插入图片描述

4.左子节点不为空，右子节点为空

与3情况互为镜像，操作类似。

public class BinarySearchTree {
	// 封装结点
	class Node {
		public int data;
		public Node left;
		public Node right;

		public Node(int data) {
			this.data = data;
			this.left = null;
			this.right = null;
		}

		// 使结点类可以根据待插入结点的值进行插入
		public void add(Node node) {
			if (node == null) {
				throw new RuntimeException("无法插入空结点！");
			}
			if (node.data < this.data) {
				if (this.left == null) {
					this.left = node;
					return;
				} else {
					this.left.add(node);
				}
			} else if (node.data > this.data) {
				if (this.right == null) {
					this.right = node;
					return;
				} else {
					this.right.add(node);
				}
			}
		}

		// 结点类实现根据值查找对应结点
		public Node searchNode(int value) {
			if (this.data == value) {
				return this;
			} else if (value < this.data) {
				if (this.left == null) {
					return null;
				} else {
					return this.left.searchNode(value);
				}
			} else {
				if (this.right == null) {
					return null;
				} else {
					return this.right.searchNode(value);
				}
			}
		}

		// 结点类实现根据值查找对应结点的父节点
		public Node searchParent(int value) {
			if ((this.left != null && this.left.data == value) || (this.right != null && this.right.data == value)) {
				return this;
			}
			if (value < this.data && this.left != null) {
				return this.left.searchParent(value);
			} else if (value > this.data && this.right != null) {
				return this.right.searchParent(value);
			}
			return null;
		}
	}

	public BinarySearchTree() {
	}

	private Node root;

	public Node getRoot() {
		return root;
	}

	/**
	 * 添加结点
	 * 
	 * @param node
	 */
	public void add(Node node) {
		// 如果根节点为空则将node赋给root
		if (root == null) {
			root = node;
		} else {
			root.add(node);
		}
	}

	/**
	 * 前序遍历
	 * 
	 * @param node
	 */
	public void preOrder(Node node) {
		if (node == null) {
			return;
		}
		System.out.print(node.data + ",");
		this.preOrder(node.left);
		this.preOrder(node.right);
	}

	/**
	 * 查找值为vlaue的结点，不存在就返回null
	 * 
	 * @param value：待查找结点的值
	 * @return：返回结点
	 */
	public Node searchNode(int value) {
		if (root == null) {
			return null;
		} else {
			return root.searchNode(value);
		}
	}

	/**
	 * 寻找结点值为value的父节点
	 * 
	 * @param value：待查找父节点的值
	 * @return：返回父节点，如不存在返回null
	 */
	public Node searchParent(int value) {
		if (root == null) {
			return null;
		}
		return root.searchParent(value);
	}

	/**
	 * 删除结点
	 * 
	 * @param value：待删除结点的值
	 * @return：删除成功返回删除的结点，删除失败返回null
	 */
	public Node deleteNode(int value) {
		// 树为空
		if (root == null) {
			return null;
		}
		// 值为value的结点不在树中
		Node target = searchNode(value);
		if (target == null) {
			System.out.println("树中无此结点，无法删除！");
			return null;
		}
		Node parent = searchParent(value);
		// 根据待删除的结点左右子节点是否分为以下四种情况
		// 情况1.左右子节点都为空，即带删除的为叶节点
		if (target.left == null && target.right == null) {
			if (parent.left.data == value) {
				parent.left = null;
			} else {
				parent.right = null;
			}
		} else if (target.left != null && target.right != null) {
			// 情况2.左右节点都不为空；
			int min = deleteMin(target.right);
			target.data = min;
		} else if (target.left != null && target.right == null) {
			// 情况3.左子节点不为，右子节点为空
			if (parent.left.data == value) {
				parent.left = target.left;
			} else {
				parent.right = target.left;
			}
		} else if (target.left == null && target.right != null) {
			// 情况4.左子节点为空，右子节点不为空
			if (parent.right.data == value) {
				parent.right = target.right;
			} else {
				parent.left = target.right;
			}
		}
		return target;
	}

	/**
	 * 删除树中的最小值
	 * 
	 * @param node：带删除最小值的树的根结点
	 * @return：返回删除结点的值
	 */
	public int deleteMin(Node node) {
		Node target = node;
		// 向左寻找，直到左子节点为空
		while (target.left != null) {
			target = target.left;
		}
		// 调用deleteNode方法删除值为最小值的结点
		deleteNode(target.data);
		return target.data;
	}

	public static void main(String[] args) {
		// arr[0]为根结点，根结点确定后add方法不改变根结点
		int[] arr = new int[] { 10, 5, 3, 7, 1, 4, 6, 8, 15, 12, 18, 11, 13, 16, 20 };
		BinarySearchTree bst = new BinarySearchTree();
		for (int i : arr) {
			bst.add(bst.new Node(i));
		}
		System.out.print("原始二叉搜索树：");
		bst.preOrder(bst.getRoot());
		System.out.println();

		System.out.print("删除最小结点后为：");
		bst.deleteMin(bst.getRoot());
		bst.preOrder(bst.getRoot());
		System.out.println();

		System.out.print("删除叶结点8后的树：");
		bst.deleteNode(8);
		bst.preOrder(bst.getRoot());
		System.out.println();

		System.out.print("删除有一个右节点左节点为空的结点3后的树：");
		bst.deleteNode(3);
		bst.preOrder(bst.getRoot());
		System.out.println();

		System.out.print("删除有一个左节点右节点为空的结点7后的树：");
		bst.deleteNode(7);
		bst.preOrder(bst.getRoot());
		System.out.println();

		System.out.print("删除有两个子节点的结点15后的树：");
		bst.deleteNode(15);
		bst.preOrder(bst.getRoot());
		System.out.println();

		System.out.println("值为11的结点：" + bst.searchNode(11).data);
		System.out.println("值为11的结点的父节点：" + bst.searchParent(11).data);
	}
}

测试结果：

原始二叉搜索树：10,5,3,1,4,7,6,8,15,12,11,13,18,16,20,
删除最小结点后为：10,5,3,4,7,6,8,15,12,11,13,18,16,20,
删除叶结点8后的树：10,5,3,4,7,6,15,12,11,13,18,16,20,
删除有一个右节点左节点为空的结点3后的树：10,5,4,7,6,15,12,11,13,18,16,20,
删除有一个左节点右节点为空的结点7后的树：10,5,4,6,15,12,11,13,18,16,20,
删除有两个子节点的结点15后的树：10,5,4,6,16,12,11,13,18,20,
值为11的结点：11
值为11的结点的父节点：12

参考资料：

数据结构 严蔚敏 吴伟民

https://blog.csdn.net/xdzhouxin/article/details/79981087

https://blog.csdn.net/qq_35402412/article/details/79721288

https://blog.csdn.net/skylibiao/article/details/81195219

https://blog.csdn.net/rodman177/article/details/89771156

https://www.cnblogs.com/hadilo/p/5724118.html

https://blog.csdn.net/gavin_john/article/details/72628965

https://blog.csdn.net/isea533/article/details/80345507
( 注：部分资料参考网络，如有侵权或错误请在留言与我联系，欢迎关注我的微信公众号“搬砖小张”，一起学习，一起进步)

搬砖小张
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
关于数据结构（八）
Joker700的博客
04-16 1878
数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。数据结构往往同高效的检索算法和索引技术有关。
终端节点、叶子节点和分支结点和非终端结点区别，数据结构常见误区答疑
qq_43747055的博客
08-18 2万+
参考严薇敏数据结构（C语言）第二版 非终端结点：度不为0的结点称为非终端结点或分支结点。 终端结点： 度为0的结点称为终端结点或叶子。 另外，各位考研的同学，“结”点，不是节点。是结点！！ 还有， 祖先不包括你的大伯结点（就是父节点的兄弟结点）！ 父节点就是双亲结点，是叫法不同。 堂兄弟结点不包括你的亲兄弟结点！ ...
网易2020校招数据分析方向正式批笔试题 解析
cjl的博客
11-25 1372
网易2020校招数据分析方向正式批笔试题选择题简答题编程题 题目来自网易2020校招数据分析方向正式批笔试题 选择题 关于主成分分析说法错误的是 PCA可以用来降维处理 PCA可以通过SVD来实现 PCA实现线性组合最大化样本方差 PCA可以通过特征值分解来实现 2个盒子被小牛分别放入中有两个大小相同的球，这两个球只可能是红和蓝两种颜色，并且一个球是红的还是蓝的是等可能的。小牛让小客来猜盒子里球的颜色分别是什么样颜色。在小客猜的过程中，小牛告诉小客其中一个是盒子里面是红色的小球，那么另一个盒子里球
数据结构—树—二叉树
夏日漱石的博客
04-16 1405
数据结构——二叉树
[ 数据结构-C语言 ] 二叉树--初阶 大总结~~
CSDN博客
04-14 1万+
今天要和大家一起步入一个新的数据结构--二叉树。在学习了解二叉树之前我们先来了解什么是树。 目录 1.树的概念及其结构 1.1树的概念 1.2树的相关概念(重点*) 1.3树的表示 2.二叉树概念及结构 2.1概念 2.2特殊的二叉树 2.3二叉树的性质（重要*） 2.4练习题 2.5 二叉树的存储结构 1. 顺序存储 2.链式存储 3.二叉树的顺序结构及实现 3.1 二叉树的顺序结构 3.2堆概念及其结构 3.2.1堆的实现 3.2.2堆的时间复杂...
数据结构教案
12-13
数据结构教案 数据结构是计算机科学中的一门重要课程，它研究的是计算机中数据的存储、组织和管理方式。数据结构的基本概念包括数据元素、数据结构、数据类型、抽象数据类型等。 数据元素是数据结构中讨论的基本...
数据结构三级项目导航系统
12-26
数据结构三级项目导航系统是一个基于C++编程语言的控制台应用程序，主要目的是为用户提供城市内的导航服务。这个项目深入地运用了数据结构的概念和技术，包括但不限于图数据结构、链表、队列和栈等，来解决实际问题...
数据结构实验报告三.doc
最新发布
12-17
这篇实验报告三是关于数据结构的实验报告，报告中包括数据结构的基本概念、数据结构的类型、数据结构的操作、数据结构的应用等内容。 在报告的开头，作者对数据结构进行了定义，并简要介绍了数据结构的历史发展和...
四川大学数据结构实验三
06-15
在四川大学的数据结构课程中，实验三是对理论学习的重要实践环节，旨在加深学生对数据结构的理解和应用能力。实验三通常会围绕一个具体的问题或项目展开，比如构建一个数字化校园系统，这涉及到大量的数据处理和算法...
数据结构实验三.docx
05-10
数据结构实验三.docx 数据结构实验三.docx是数据结构课程的一部分， experiment三主要是关于线性表实验-链式存储，使用C语言实现。下面是实验的详细知识点总结： 一、实验目的 * 掌握带表头结点的单链表基本操作...
树型结构--树的定义和基本术语(十六)
花狗Fdog的博客
03-09 2069
树是n（n>=0）个结点的有限集合T，当n=0时，称为空树，当n>0时，该集合满足如下条件：1.其中必有一个称为根的特定结点，它没有直接前驱，但是有零个或多个直接后续。2.其中n-1个结点可以划分成m（m>=0）个互不相交的有限集T1，T2，T3，T4.........其中Ti又是一棵树，称为根的子树，每棵子树的根结点有且仅有一个直接前驱，但有零个或者多个直接后续。1.结点：包括一个数据元素以及若干指向其他结点的分支信息。2.结点的度：一个结点的子树个数称为此结点的度。3.叶结点：度为0的结点
B树中的终端节点、叶子节点和非终端结点辨别
热门推荐
y786168557的博客
10-07 5万+
第一篇博客而已。
数据结构之二叉树
DayDayUp
12-04 2022
树的一个节点拥有多少个子节点取决于树的类型，这个量值称为树的分支因子，它决定了当插入节点是，树的分支扩展速度。二叉树的分支因子为2。二叉树是一种将节点按照层次结构组织起来的数据结构，每个节点最多只有两个与它直接相关联的子节点。 二叉树二叉树概念基本形态相关术语特殊类型性质二叉树的应用霍夫曼编码用户界面数据库系统表达式处理人工智能优先级队列二叉树的数据结构树的周游算法先序遍历中序遍历后序遍历层级遍历树的平衡 二叉树概念 基本形态 二叉树是递归定义的，其结点有左右子树之分，逻辑上二叉树有五种基本形态： 1、空二
8大数据结构介绍，一看就懂！
明而决之
09-25 897
目录 数据结构分类 1、数组 2、栈 3、队列 4、链表 5、树 6、散列表 7、堆 8、图 数据结构分类 数据结构是指相互之间存在着一种或多种关系的数据元素的集合和该集合中数据元素之间的关系组成 。 常用的数据结构有：数组，栈，链表，队列，树，图，堆，散列表等，如图所示： 每一种数据结构都有着独特的数据存储方式，下面为大家介绍它们的结构和优缺点。 1、数组 数组是可以再内存中连续存储多个元素的结构，在内存中的分配也是连续的，数组中的元素通过数组下标进行访问，数组下标从0开始。例如
完全二叉树的最后一个非终端节点的下标
波波诸葛伟
11-29 2429
今天突然想通了一件事，完全二叉树的最后一个非终端节点的下标为(n-2)/2,若一根完全二叉树有n个节点，则n-1为最后一个叶子节点的下标，而完全二叉树中一个节点的父亲节点的下标为此节点下标减去1再除2. 于是二叉树的最后一个非终端节点的下标就为(n-2)/2...
【数据结构】（二叉树与森林）设F是一个森林，B是由F转换得到的二叉树，F中有n个非终端结点，B中右指针域为空的结点有?
你好丶下一秒
08-05 1万+
设F是一个森林，B是由F转换得到的二叉树，F中有n个非终端结点，B中右指针域为空的结点有? 解题思路： 对于树中的非终端节点（也就是分支结点），每个非终端结点至少有一个孩子结点，不管孩子结点有几个（孩子结点必然是有限的）按照森林转化为二叉树的左孩子右兄弟来看，必然最后一个孩子结点的右指针域是空的，因为他是最后一个孩子他已经没用兄弟了所以此时有n个非终端结点那么就会有n个右指针域为空的结点 因为我...
【数据结构】有序树和无序树的区别
学习ing.........
07-20 4万+
这个问题想了好久才弄清楚，现在总结一下。 概念是这样的： 有序树 树中任意节点的子结点之间有顺序关系，这种树称为有序树 无序树 树中任意节点的子结点之间没有顺序关系，这种树称为无序树,也称为自由树 换而言之，兄弟结点有顺序的树，称为有序树，兄弟之间无顺序的树称为无序树。 那么，3个结点到底能组成多少种有序树，多少
判断一棵树是否是搜索二叉树、判断一棵树是否是完全二叉树
gkq_tt的博客
01-09 1151
判断一棵树是否是搜索二叉树、判断一棵树是否是完全二叉树 判断是否是搜索二叉树的思路：如果一颗二叉树在中序遍历过程中出现了当前结点的值比前一节点值小，这说明不是搜索二叉树。 判断是否是完全二叉树的思路：1）如果一个结点有右孩子无左孩子一定不是完全二叉树 ​ 2）如果一个结点不是左右两个孩子都有（...
数据结构三要素：逻辑、存储与操作详解
数据结构的三个核心组成部分包括逻辑结构、存储结构和数据操作。 首先，逻辑结构是数据元素之间内在的、抽象的关系，它是数据结构的基础。逻辑结构可以分为三种主要类型：集合结构（如线性结构，如数组、链表等）、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

搬砖小张

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

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

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

打赏作者

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

抵扣说明：

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

余额充值