数据结构——用Java实现二分搜索树

目录

一、树

二、二分搜索树

1.二叉树

2.二分搜索树

三、代码实现

1.树的构建

2.获取树中结点的个数

3.添加元素

4.查找元素

（1）查找元素是否存在

（2）查找最小元素

（3）查找最大元素

5.二分搜索树的遍历

（1）前序遍历：

（2）中序遍历：

（3）后序遍历：

（4）层序遍历：

6.删除操作

（1）删除最小元素

（2）删除最大元素

（3）删除任意元素

（4）删除根节点

一、树

        树结构本身是一种天然的组织结构

        是一个高效的查询内容的结构

二、二分搜索树

1.二叉树

特点：1.只有唯一的一个根节点

           2.每个结点最多有两个孩子

           3.每个结点最多有一个父亲

           4.二叉树具有天然的递归结构（左右子树也是二叉树）

           5.叶子结点出现在二叉树的最底层，除叶子结点之外的其它结点都有两个孩子结点。

2.二分搜索树

是特殊的二叉树

每个节点都大于左子树的所有结点，都小于右子树的所有结点

注意：存储的元素必须具有可比性

因为二分搜索树也是二叉树，也具有天然的递归结构，所以许多方法都可以使用递归的思想去实现

三、代码实现

1.树的构建

需要的元素有：根节点，结点，频率（如果添加的元素有重复元素），结点的值，索引，结点个数

//树的结点private static class Node<T> {private final T ele;//结点的值private int frequence;//频率private Node<T> left, right;//分别指向左右孩子的索引public Node(T ele) {this.ele = ele;this.left = this.right = null;}}//树对应的属性private Node<T> root;//树的根节点private int size;//结点的个数//构建树public BinearySeachTree() {this.root = null;this.size = 0;}

在给元素添加泛型后，就不能直接比较，所以在开始就继承Comparable来实现元素的比较

public class BinearySeachTree<T extends Comparable<T>>{}

2.获取树中结点的个数

//获取树中结点的个数public int getSize() {return this.size;}

3.添加元素

将元素添加到二分搜索树的过程中，要注意将大的元素放在结点的右边，小的元素放在左边

再添加元素时，需要找到对应的位置，则可以使用递归的思想。

如果添加的值小于结点的值，则查找结点左孩子，如果还是小于结点，则继续查找

//向树中添加结点public void add(T ele) {//更新根结点this.root = addDG(this.root, ele);}//语义：向以root为根的二分搜索树中添加元素eleprivate Node<T> addDG(Node<T> root, T ele) {//递归终止条件if (root == null) {this.size++;return new Node<T>(ele);}//递归操作if (root.ele.compareTo(ele) > 0) {root.left = addDG(root.left, ele);} else if (root.ele.compareTo(ele) < 0) {root.right = addDG(root.right, ele);} else {//更新频率root.frequence++;}return root;}

4.查找元素

（1）查找元素是否存在

        查找元素是否在二叉树中，查找每一个结点，如果查找元素比当前节点小，就在左子树里重新查找，如果查找元素比当前节点大，就在右子树里重新查找

 //查询的方法public boolean search(T ele) {return searchDG(this.root, ele);}//语义：从以root为根的二分搜索树中查找元素eleprivate boolean searchDG(Node<T> root, T ele) {//递归终止的条件if (root == null) {return false;}//递归操作if (root.ele.compareTo(ele) == 0) {return true;} else if (root.ele.compareTo(ele) > 0) {return searchDG(root.left, ele);} else {return searchDG(root.right, ele);}}

（2）查找最小元素

        二分搜索树中最左边的元素

 //找树中的最小元素public T getMinValue() {if (this.isEmpty()) {return null;}Optional<Node<T>> optional = getMinNode();return optional.get().ele;}//直接查找
private Optional<Node<T>> getMinNode() {if (this.root == null) {return Optional.empty();}//一直向左查找Node<T> node = this.root;while (node.left != null) {node = node.left;}return Optional.of(node);}//利用递归方法查找//语义：在以Node为根结点的树中查找最小结点private Optional<Node<T>> getMinNode(Node<T> node) {if (node.left == null) {return Optional.of(node);}return getMinNode(node.left);}

（3）查找最大元素

        二分搜索树中最右边的元素

//找树中的最大元素public T getMaxValue() {if (this.isEmpty()) {return null;}Optional<Node<T>> optional = getMaxNode(this.root);return optional.get().ele;}//语义：在以Node为根结点的树中查找最大结点private Optional<Node<T>> getMaxNode(Node<T> node) {if (node.right == null) {return Optional.of(node);}return getMaxNode(node.right);}

5.二分搜索树的遍历

树的遍历有四种：前序遍历；中序遍历；后序遍历；层序遍历

（1）前序遍历：

首先打印根节点，然后遍历左子树，最后是右子树

【28,16,13,22,30,29,42】

//前序遍历public void preTravel() {List<AbstractMap.SimpleEntry<T, Integer>> list = new ArrayList<>();preTravelDG(this.root, list);String str = list.stream().map(item -> "[" + item.getKey() + ":" + item.getValue() + "]").collect(Collectors.joining("-"));System.out.println(str);}//前序遍历以root为根的树，讲解稿保存在list中private void preTravelDG(Node<T> root, List<AbstractMap.SimpleEntry<T, Integer>> list) {//递归终止条件if (root == null) {return;}//递归操作list.add(new AbstractMap.SimpleEntry<>(root.ele, root.frequence));//遍历左子树preTravelDG(root.left, list);//遍历右子树preTravelDG(root.right, list);}

（2）中序遍历：

先遍历左子树，在打印中间结点，最后遍历右子树

【13,16,22,28,29,30,42】

//中序遍历public void midTravel() {List<AbstractMap.SimpleEntry<T, Integer>> list = new ArrayList<>();midTravelDG(this.root, list);String str = list.stream().map(item -> item.toString()).collect(Collectors.joining("-"));System.out.println(str);}//中序遍历以root为根的树，讲解稿保存在list中private void midTravelDG(Node<T> root, List<AbstractMap.SimpleEntry<T, Integer>> list) {//递归终止条件if (root == null) {return;}//递归操作//遍历左子树preTravelDG(root.left, list);list.add(new AbstractMap.SimpleEntry<>(root.ele, root.frequence));//遍历右子树preTravelDG(root.right, list);}

（3）后序遍历：

先遍历左子树，在遍历右子树，最后在打印中间结点

【13,22,16,29,42,30,28】

 //后序遍历public void sufTravel() {List<AbstractMap.SimpleEntry<T, Integer>> list = new ArrayList<>();sufTravelDG(this.root, list);String str = list.stream().map(item -> item.toString()).collect(Collectors.joining("-"));System.out.println(str);}//后序遍历以root为根的树，讲解稿保存在list中private void sufTravelDG(Node<T> root, List<AbstractMap.SimpleEntry<T, Integer>> list) {//递归终止条件if (root == null) {return;}//递归操作//遍历左子树preTravelDG(root.left, list);//遍历右子树preTravelDG(root.right, list);list.add(new AbstractMap.SimpleEntry<>(root.ele, root.frequence));}

可以看到，先中后序遍历的代码区别只是在递归最后将元素添加到list的位置不同而已

（4）层序遍历：

一层一层的打印

【28,16,30,13,22,29,42】

//层序遍历public void levelTravel() {//判断树是否为空if (this.isEmpty()) {return;}Queue<AbstractMap.SimpleEntry<Node<T>, Integer>> queue = new LinkedList<>();//1.先将根结点入队queue.add(new AbstractMap.SimpleEntry<>(this.root, 1));//2.遍历队列while (!queue.isEmpty()) {//2-1.出队AbstractMap.SimpleEntry<Node<T>, Integer> pair = queue.poll();//结点Node<T> node = pair.getKey();//层int level = pair.getValue();;System.out.println("[val:" + node.ele + ",level:" + level + "]");//2-2.判断左右子树是否为空if (node.left != null) {queue.add(new AbstractMap.SimpleEntry<>(node.left, level + 1));}if (node.right != null) {queue.add(new AbstractMap.SimpleEntry<>(node.right, level + 1));}}}

6.删除操作

删除的操作中，需要注意删除后二分搜索树也会因此改变，所以要分情况讨论

（1）删除最小元素

删除最小元素并不需要改变树，只需要失去关联关系即可

 //从树中删除最小的结点public T removeMinNode() {T result = getMinValue();if (result == null) {return null;}//更新根结点this.root = removeMinNode(this.root);return result;}//语义：从以Node为根的二分搜索树中删除元素最小的结点private Node<T> removeMinNode(Node<T> node) {//递归终止条件if (node.left == null) {//删除操作//1.记录右子树Node<T> rightTree = node.right;//失去关联关系node.right = null;//3.跟新sizethis.size--;return rightTree;}//递归操作node.left = removeMinNode(node.left);return node;}

（2）删除最大元素

跟删除最小元素一样，只需要失去关联关系即可

//从树中删除最大的结点public T removeMaxNode() {T result = getMaxValue();if (result == null) {return null;}//更新根结点this.root = removeMaxNode(this.root);return result;}//语义：从以Node为根的二分搜索树中删除元素最大的结点private Node<T> removeMaxNode(Node<T> node) {//递归终止条件if (node.right == null) {//删除操作//1.记录左子树Node<T> leftTree = node.left;//失去关联关系node.left = null;//3.跟新sizethis.size--;return leftTree;}//递归操作node.right = removeMaxNode(node.right);return node;}

（3）删除任意元素

在删除任意元素中，需要考虑删除结点有没有左右子树

//语义：从以Node为根的二分搜索树中删除值为ele的结点private Node<T> remove(Node<T> node, T ele) {//递归终止的条件//没有找到if (node == null) {return null;}//找到了if (node.ele.compareTo(ele) == 0) {this.size--;//Node就是要删除的结点if (node.left == null) {Node<T>rightNode=node.right;node.right=null;return rightNode;} else if (node.right == null) {Node<T>leftNode=node.left;node.left=null;return leftNode;} else {Node<T> suffixNode = getMinNode(node.right).get();suffixNode.right=removeMinNode(node.right);suffixNode.left=node.left;this.size++;//失去关联关系node.left=node.right=null;return suffixNode;}}//递归操作if (node.ele.compareTo(ele) > 0) {node.left = remove(node.left, ele);} else {node.right = remove(node.right, ele);}return node;}

（4）删除根节点

直接删除关联关系即可

 //删除根节点public void removeRoot(){if(this.root==null){return;}remove(this.root.ele);}

四、完整代码

package com.algo.lesson.lesson04;import java.util.*;
import java.util.stream.Collectors;//二分搜索树
/*
保存到结点中的元素值必须具有可比性*/
public class BinearySeachTree<T extends Comparable<T>> {//树的结点private static class Node<T> {private final T ele;//结点的值private int frequence;//频率private Node<T> left, right;//分别指向左右孩子的索引public Node(T ele) {this.ele = ele;this.left = this.right = null;}}//树对应的属性private Node<T> root;//树的根节点private int size;//结点的个数//构建树public BinearySeachTree() {this.root = null;this.size = 0;}//获取树中结点的个数public int getSize() {return this.size;}//向树中添加结点public void add(T ele) {//更新根结点this.root = addDG(this.root, ele);}//语义：向以root为根的二分搜索树中添加元素eleprivate Node<T> addDG(Node<T> root, T ele) {//递归终止条件if (root == null) {this.size++;return new Node<T>(ele);}//递归操作if (root.ele.compareTo(ele) > 0) {root.left = addDG(root.left, ele);} else if (root.ele.compareTo(ele) < 0) {root.right = addDG(root.right, ele);} else {//更新频率root.frequence++;}return root;}//查询的方法public boolean search(T ele) {return searchDG(this.root, ele);}//语义：从以root为根的二分搜索树中查找元素eleprivate boolean searchDG(Node<T> root, T ele) {//递归终止的条件if (root == null) {return false;}//递归操作if (root.ele.compareTo(ele) == 0) {return true;} else if (root.ele.compareTo(ele) > 0) {return searchDG(root.left, ele);} else {return searchDG(root.right, ele);}}//二分搜索树的遍历//前序遍历public void preTravel() {List<AbstractMap.SimpleEntry<T, Integer>> list = new ArrayList<>();preTravelDG(this.root, list);String str = list.stream().map(item -> "[" + item.getKey() + ":" + item.getValue() + "]").collect(Collectors.joining("-"));System.out.println(str);}//中序遍历public void midTravel() {List<AbstractMap.SimpleEntry<T, Integer>> list = new ArrayList<>();midTravelDG(this.root, list);String str = list.stream().map(item -> item.toString()).collect(Collectors.joining("-"));System.out.println(str);}//后序遍历public void sufTravel() {List<AbstractMap.SimpleEntry<T, Integer>> list = new ArrayList<>();sufTravelDG(this.root, list);String str = list.stream().map(item -> item.toString()).collect(Collectors.joining("-"));System.out.println(str);}//前序遍历以root为根的树，讲解稿保存在list中private void preTravelDG(Node<T> root, List<AbstractMap.SimpleEntry<T, Integer>> list) {//递归终止条件if (root == null) {return;}//递归操作list.add(new AbstractMap.SimpleEntry<>(root.ele, root.frequence));//遍历左子树preTravelDG(root.left, list);//遍历右子树preTravelDG(root.right, list);}//中序遍历以root为根的树，讲解稿保存在list中private void midTravelDG(Node<T> root, List<AbstractMap.SimpleEntry<T, Integer>> list) {//递归终止条件if (root == null) {return;}//递归操作//遍历左子树preTravelDG(root.left, list);list.add(new AbstractMap.SimpleEntry<>(root.ele, root.frequence));//遍历右子树preTravelDG(root.right, list);}//后序遍历以root为根的树，讲解稿保存在list中private void sufTravelDG(Node<T> root, List<AbstractMap.SimpleEntry<T, Integer>> list) {//递归终止条件if (root == null) {return;}//递归操作//遍历左子树preTravelDG(root.left, list);//遍历右子树preTravelDG(root.right, list);list.add(new AbstractMap.SimpleEntry<>(root.ele, root.frequence));}//判断树是否为空public boolean isEmpty() {return this.size == 0;}//层序遍历public void levelTravel() {//判断树是否为空if (this.isEmpty()) {return;}Queue<AbstractMap.SimpleEntry<Node<T>, Integer>> queue = new LinkedList<>();//1.先将根结点入队queue.add(new AbstractMap.SimpleEntry<>(this.root, 1));//2.遍历队列while (!queue.isEmpty()) {//2-1.出队AbstractMap.SimpleEntry<Node<T>, Integer> pair = queue.poll();//结点Node<T> node = pair.getKey();//层int level = pair.getValue();;System.out.println("[val:" + node.ele + ",level:" + level + "]");//2-2.判断左右子树是否为空if (node.left != null) {queue.add(new AbstractMap.SimpleEntry<>(node.left, level + 1));}if (node.right != null) {queue.add(new AbstractMap.SimpleEntry<>(node.right, level + 1));}}}//找树中的最小元素public T getMinValue() {if (this.isEmpty()) {return null;}Optional<Node<T>> optional = getMinNode();return optional.get().ele;}//找树中的最大元素public T getMaxValue() {if (this.isEmpty()) {return null;}Optional<Node<T>> optional = getMaxNode(this.root);return optional.get().ele;}private Optional<Node<T>> getMinNode() {if (this.root == null) {return Optional.empty();}//一直向左查找Node<T> node = this.root;while (node.left != null) {node = node.left;}return Optional.of(node);}//递归//语义：在以Node为根结点的树中查找最小结点private Optional<Node<T>> getMinNode(Node<T> node) {if (node.left == null) {return Optional.of(node);}return getMinNode(node.left);}//语义：在以Node为根结点的树中查找最大结点private Optional<Node<T>> getMaxNode(Node<T> node) {if (node.right == null) {return Optional.of(node);}return getMaxNode(node.right);}//删除操作//从树中删除最小的结点public T removeMinNode() {T result = getMinValue();if (result == null) {return null;}//更新根结点this.root = removeMinNode(this.root);return result;}//语义：从以Node为根的二分搜索树中删除元素最小的结点private Node<T> removeMinNode(Node<T> node) {//递归终止条件if (node.left == null) {//删除操作//1.记录右子树Node<T> rightTree = node.right;//失去关联关系node.right = null;//3.跟新sizethis.size--;return rightTree;}//递归操作node.left = removeMinNode(node.left);return node;}//删除操作//从树中删除最大的结点public T removeMaxNode() {T result = getMaxValue();if (result == null) {return null;}//更新根结点this.root = removeMaxNode(this.root);return result;}//语义：从以Node为根的二分搜索树中删除元素最大的结点private Node<T> removeMaxNode(Node<T> node) {//递归终止条件if (node.right == null) {//删除操作//1.记录左子树Node<T> leftTree = node.left;//失去关联关系node.left = null;//3.跟新sizethis.size--;return leftTree;}//递归操作node.right = removeMaxNode(node.right);return node;}//删除任意结点public void remove(T ele) {//根据值查找结点this.root = remove(this.root, ele);}//语义：从以Node为根的二分搜索树中删除值为ele的结点private Node<T> remove(Node<T> node, T ele) {//递归终止的条件//没有找到if (node == null) {return null;}//找到了if (node.ele.compareTo(ele) == 0) {this.size--;//Node就是要删除的结点if (node.left == null) {Node<T>rightNode=node.right;node.right=null;return rightNode;} else if (node.right == null) {Node<T>leftNode=node.left;node.left=null;return leftNode;} else {Node<T> suffixNode = getMinNode(node.right).get();suffixNode.right=removeMinNode(node.right);suffixNode.left=node.left;this.size++;//失去关联关系node.left=node.right=null;return suffixNode;}}//递归操作if (node.ele.compareTo(ele) > 0) {node.left = remove(node.left, ele);} else {node.right = remove(node.right, ele);}return node;}//删除根节点public void removeRoot(){if(this.root==null){return;}remove(this.root.ele);}}

五、例题

1.700. 二叉搜索树中的搜索

​​​​

class Solution {public TreeNode searchBST(TreeNode root, int val) {if(root==null){return null;}if(val==root.val){return root;}return searchBST(val<root.val?root.left:root.right,val);}
}

2.力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

class Solution {public TreeNode insertIntoBST(TreeNode root, int val) {
//更新根结点return root = addDG(root, val);}//语义：向以root为根的二分搜索树中添加元素eleprivate TreeNode addDG(TreeNode root, int val) {//递归终止条件if (root == null) {return new TreeNode(val);}//递归操作if (root.val>val) {root.left = addDG(root.left, val);} else if (root.val<val) {root.right = addDG(root.right, val);}return root;}
}

3.力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

class Solution {public List<List<Integer>> levelOrder(TreeNode root) {List<List<Integer>> list = new ArrayList<List<Integer>>();if (root == null) {return list;}Queue<TreeNode> queue = new LinkedList<TreeNode>();queue.offer(root);while (!queue.isEmpty()) {List<Integer> level = new ArrayList<Integer>();int temp = queue.size();for (int i = 1; i <= temp; i++) {TreeNode node = queue.poll();level.add(node.val);if (node.left != null) {queue.offer(node.left);}if (node.right != null) {queue.offer(node.right);}}list.add(level);}return list;}
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/438341.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

使用程序设计流程图解析并建立神经网络(不依赖深度学习library）

使用程序设计流程图解析并建立神经网络(不依赖深度学习library）

介绍&#xff1a; ## Flow chart for a simple neural network: #(1)Take inputs 输入 #(2)Add bias (if required) #(3)Assign random weights to input features 随机一个权重 #(4)Run the code for training. 训练集训练 #(5)Find the error in prediction. 找预测损失 #(6…
阅读更多...
Linux实验记录：使用RAID（独立冗余磁盘阵列）

Linux实验记录：使用RAID（独立冗余磁盘阵列）

前言&#xff1a; 本文是一篇关于Linux系统初学者的实验记录。 参考书籍&#xff1a;《Linux就该这么学》 实验环境&#xff1a; VmwareWorkStation 17——虚拟机软件 RedHatEnterpriseLinux[RHEL]8——红帽操作系统 目录 前言&#xff1a; 备注&#xff1a; 部署磁盘阵…
阅读更多...
模拟退火算法（Simulated Annealing, SA）

模拟退火算法（Simulated Annealing, SA）

一、简介 模拟退火算法来源于固体退火原理&#xff0c;是一种基于概率的算法。将固体加温至充分高的温度&#xff0c;再让其徐徐冷却&#xff0c;加温时&#xff0c;固体内部粒子随温升变为无序状&#xff0c;内能增大&#xff0c;分子和原子越不稳定。而徐徐冷却时粒子渐趋有…
阅读更多...
幻兽帕鲁Linux私服搭建备份迁移指南

幻兽帕鲁Linux私服搭建备份迁移指南

幻兽帕鲁Linux私服搭建指南 文档参考 &#xff01;&#xff01;&#xff01;说明&#xff1a;不只是幻兽帕鲁&#xff0c;后续大家想自己搭私服玩别的Steam游戏&#xff0c;大部分内容都可以做一个参考 Linux安装steamcmd Linux开服步骤 游戏配置修改 Youtobe视频教程 配…
阅读更多...
阿里十年 “帕鲁” 手把手带你学习 CompletableFuture

阿里十年 “帕鲁” 手把手带你学习 CompletableFuture

阿里十年 “帕鲁” 手把手带你学习 CompletableFuture 文章目录 阿里十年 “帕鲁” 手把手带你学习 CompletableFutureFuture 介绍CompletableFuture 介绍CompletableFuture 常见操作创建 CompletableFuturenew 关键字静态工厂方法 处理异步结算的结果异常处理组合 Completable…
阅读更多...
Kafka（九）跨集群数据镜像

Kafka（九）跨集群数据镜像

目录 1 跨集群镜像的应用场景1.1 区域集群和中心集群1.2 高可用(HA)和灾备(DR)1.3 监管与合规1.4 云迁移1.5 聚合边缘集群的数据 2 多集群架构2.1 星型架构2.2 双活架构2.2 主备架构2.2.1 如何实现Kafka集群的故障转移2.2.1.1 故障转移包括的内容1. 灾难恢复计划2. 非计划内的故…
阅读更多...
遗传算法优化最大化效应的某些需求点可不配送的vrptw问题

遗传算法优化最大化效应的某些需求点可不配送的vrptw问题

标题&#xff1a;遗传算法优化最大化效应的某些需求点可不配送的vrptw问题 摘要&#xff1a; 在可不配送的车辆路径配送问题&#xff08;VRPTW&#xff09;中&#xff0c;我们面临着优化路径规划以最大化效用的挑战。本文提出了一种基于遗传算法的方法&#xff0c;旨在解决具…
阅读更多...
信创发展之路

信创发展之路

1、什么是信创 信创&#xff0c;即信息技术应用创新&#xff0c;以前也被称为“安可“&#xff08;安全可控&#xff09; 1.1、基本概念 信创产业主要包括四大领域&#xff1a; 基础设施&#xff0c;包括芯片&#xff08;CPU、GPU等&#xff09;、存储、服务器、云计算等&…
阅读更多...
排序（2）——选择排序

排序（2）——选择排序

三、选择排序 1.简介 选择排序主要采取的排序策略就是选择&#xff0c;在拿到待排序数组后&#xff0c;程序会一遍遍地遍历未排序部分数组&#xff0c;在每一次的遍历过程中会找到最小的元素&#xff0c;并在遍历完成后换到未排序数组部分的最左侧。如此循环往复&#xff0c;每…
阅读更多...
Linux网络编程——网络初识

Linux网络编程——网络初识

文章目录 1. 网络协议初识1.1 为什么要有网络协议1.2 协议分层 2. OSI七层模型3. TCP/IP五层&#xff08;或四层&#xff09;模型4. 网络传输基本流程5. 以太网通信 1. 网络协议初识 1.1 为什么要有网络协议 早期计算机是独立的&#xff0c;如果要进行数据交互&#xff0c;就…
阅读更多...
【Shell实战案例面试题】输入网卡的名字，来输出网卡的IP

【Shell实战案例面试题】输入网卡的名字，来输出网卡的IP

1.问题 参数后判断要加"" 名字为空时显示ip 2.分析 把本机的所有网卡名列出来&#xff0c;来引导用户输入 使用命令列出所有网卡信:ifconfig/ip a 设计一个函数&#xff0c;把网卡名作为参数&#xff0c;函数返回网卡的IP 在获取某个网卡IP时&#xff0c;考虑网…
阅读更多...
手把手带你Git入门，从下载到精通，常用git命令

手把手带你Git入门，从下载到精通，常用git命令

文章目录 Git概述什么是GitGit历史Git是什么 为什么要使用Git什么是版本控制系统 Git和SVN对比SVN集中式SVN优缺点 Git分布式Git优缺点 Git工作流程四个工作区域工作流程 Git下载与安装下载window版下载64位软件包安装Git Git基础环境配置设置用户信息查看配置信息 文件的两种状…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023