精华内容
下载资源
问答
  • 二进制,八进制,十六进制定义形式如下a = 0b101 b = 012 c = 0x12ax进制转10进制:注意,参数1必须是字符串哦a = int(str('101'), 2)x进制转二进制,八进制,十六进制,格式如下: bin-》转2进制, oct-》转8...

    二进制,八进制,十六进制的定义形式如下

    a = 0b101
    b = 012
    c = 0x12a

    x进制转10进制:注意,参数1必须是字符串哦

    a = int(str('101'), 2)

    x进制转二进制,八进制,十六进制,格式如下:
    bin-》转2进制, oct-》转8进制,int-》转10进制, hex-》转16进制

    a = bin(077)
    展开全文
  • 本篇文章给大家带来内容是关于python中二叉搜索树详细介绍(代码示例),有一定参考价值,有需要朋友可以参考一下,希望对你有所帮助。一、二叉搜索树**二叉搜索树(BST binary searchtree)**是一种比较特殊...

    本篇文章给大家带来的内容是关于python中二叉搜索树的详细介绍(代码示例),有一定的参考价值,有需要的朋友可以参考一下,希望对你有所帮助。

    一、二叉搜索树

    **二叉搜索树(BST binary search

    tree)**是一种比较特殊的二叉树,表现为任意节点的值都比左孩子的值要大,而且小于等于右孩子的值,采用中序遍历BST(Binary

    Search Tree)就可以的到排序好的元素集合,而且插入删除的时间消耗也比较合理,但是有一个缺点就是内存开销有点大。

    二叉搜索树的性质

    1,任意节点x,其左子树中的key不大于x.key,其右子树中的key不小于x.key。

    2,不同的二叉搜索树可以代表同一组值的集合。

    3,二叉搜索树的基本操作和树的高度成正比,所以如果是一棵完全二叉树的话最坏运行时间为Θ(lgn),但是若是一个n个节点连接成的线性树,那么最坏运行时间是Θ(n)。

    4,根节点是唯一一个parent指针指向NIL节点的节点。

    5,每一个节点至少包括key、left、right与parent四个属性,构建二叉搜索树时,必须存在针对key的比较算法。

    二、二叉搜索树的实现

    1. 定义

    树的节点:class TreeNode:

    def __init__(self,key,val,left=None,right=None,parent=None):

    self.key = key

    self.payload = val

    self.leftChild = left

    self.rightChild = right

    self.parent = parent

    class BinarySearchTree:

    def __init__(self):

    self.root = None

    self.size = 0

    2.插入

    现在我们有了 BinarySearchTree shell 和 TreeNode,现在是时候编写 put 方法,这将允许我们构建二叉搜索树。 put 方法是BinarySearchTree 类的一个方法。此方法将检查树是否已具有根。如果没有根,那么 put 将创建一个新的 TreeNode 并将其做为树的根。如果根节点已经就位,则 put 调用私有递归辅助函数 _put 根据以下算法搜索树:从树的根开始,搜索二叉树,将新键与当前节点中的键进行比较。如果新键小于当前节点,则搜索左子树。如果新键大于当前节点,则搜索右子树。

    当没有左(或右)孩子要搜索时,我们在树中找到应该建立新节点的位置。

    要向树中添加节点,请创建一个新的 TreeNode对象,并将对象插入到上一步发现的节点。

    插入时,总是作为叶节点插入到树中

    给定序列去依次构造二叉查找树,则二叉搜索树唯一;如果是用这个序列所有的关键字去构造可能的二叉树(排列任意),则一般不唯一。def put(self,key,val):

    if self.root:

    self._put(key,val,self.root)

    else:

    self.root = TreeNode(key,val)

    self.size = self.size + 1

    def _put(self,key,val,currentNode):

    if key < currentNode.key:

    if currentNode.hasLeftChild():

    self._put(key,val,currentNode.leftChild)

    else:

    currentNode.leftChild = TreeNode(key,val,parent=currentNode)

    else:

    if currentNode.hasRightChild():

    self._put(key,val,currentNode.rightChild)

    else:

    currentNode.rightChild = TreeNode(key,val,parent=currentNode)

    上面展示了在树中插入一个新节点的 Python 代码。_put 函数按照上述步骤递归编写。请注意,当一个新的子节点插入到树中时,currentNode 将作为父节点传递给新的树节点。

    我们实现插入的一个重要问题是重复的键不能正确处理。当我们的树被实现时,重复键将在具有原始键的节点的右子树中创建具有相同键值的新节点。这样做的结果是,具有新键的节点将永远不会在搜索期间被找到。处理插入重复键的更好方法是将新键相关联的值替换旧值。

    3.查找

    一旦树被构造,下一个任务是实现对给定键的值的检索。get 方法比 put 方法更容易,因为它只是递归地搜索树,直到它到达不匹配的叶节点或找到匹配的键。当找到匹配的键时,返回存储在节点的有效载荷中的值。

    当二叉查找树不为空时:首先将给定值与根结点的关键字比较,若相等,则查找成功

    若小于根结点的关键字值,递归查左子树

    若大于根结点的关键字值,递归查右子树

    若子树为空,查找不成功def get(self,key):

    if self.root:

    res = self._get(key,self.root)

    if res:

    return res.payload

    else:

    return None

    else:

    return None

    def _get(self,key,currentNode):

    if not currentNode:

    return None

    elif currentNode.key == key:

    return currentNode

    elif key < currentNode.key:

    return self._get(key,currentNode.leftChild)

    else:

    return self._get(key,currentNode.rightChild)

    def __getitem__(self,key):

    return self.get(key)

    4.删除

    第一个任务是通过搜索树来找到要删除的节点。 如果树具有多个节点,我们使用 _get 方法搜索以找到需要删除的 TreeNode。 如果树只有一个节点,这意味着我们删除树的根,但是我们仍然必须检查以确保根的键匹配要删除的键。 在任一情况下,如果未找到键,del 操作符将引发错误。def delete(self,key):

    if self.size > 1:

    nodeToRemove = self._get(key,self.root)

    if nodeToRemove:

    self.remove(nodeToRemove)

    self.size = self.size-1

    else:

    raise KeyError('Error, key not in tree')

    elif self.size == 1 and self.root.key == key:

    self.root = None

    self.size = self.size - 1

    else:

    raise KeyError('Error, key not in tree')

    def __delitem__(self,key):

    self.delete(key)

    一旦我们找到了我们要删除的键的节点,我们必须考虑三种情况:要删除的节点没有子节点。

    要删除的节点只有一个子节点。

    要删除的节点有两个子节点。

    第一种情况:

    如果当前节点没有子节点,我们需要做的是删除节点并删除对父节点中该节点的引用。

    第二种情况:

    如果一个节点只有一个孩子,那么我们可以简单地促进孩子取代其父。此案例的代码展示在下一个列表中。当你看这个代码,你会看到有六种情况要考虑。由于这些情况相对于左孩子或右孩子对称,我们将仅讨论当前节点具有左孩子的情况。决策如下:如果当前节点是左子节点,则我们只需要更新左子节点的父引用以指向当前节点的父节点,然后更新父节点的左子节点引用以指向当前节点的左子节点。

    如果当前节点是右子节点,则我们只需要更新左子节点的父引用以指向当前节点的父节点,然后更新父节点的右子节点引用以指向当前节点的左子节点。

    如果当前节点没有父级,则它是根。在这种情况下,我们将通过在根上调用replaceNodeData 方法来替换 key,payload,leftChild 和 rightChild 数据。

    第三种情况:

    最难处理的情况。 如果一个节点有两个孩子,那么我们不太可能简单地提升其中一个节点来占据节点的位置。 然而,我们可以在树中搜索可用于替换被调度删除的节点的节点。 我们需要的是一个节点,它将保留现有的左和右子树的二叉搜索树关系。 执行此操作的节点是树中具有次最大键的节点。 我们将这个节点称为后继节点,我们将看一种方法来很快找到后继节点。 继承节点保证没有多于一个孩子,所以我们知道使用已经实现的两种情况删除它。 一旦删除了后继,我们只需将它放在树中,代替要删除的节点。

    找到后继的代码如下所示,是 TreeNode 类的一个方法。此代码利用二叉搜索树的相同属性,采用中序遍历从最小到最大打印树中的节点。在寻找接班人时,有三种情况需要考虑:

    如果节点有右子节点,则后继节点是右子树中的最小的键。

    如果节点没有右子节点并且是父节点的左子节点,则父节点是后继节点。

    如果节点是其父节点的右子节点,并且它本身没有右子节点,则此节点的后继节点是其父节点的后继节点,不包括此节点。def findSuccessor(self):

    succ = None

    if self.hasRightChild():

    succ = self.rightChild.findMin()

    else:

    if self.parent:

    if self.isLeftChild():

    succ = self.parent

    else:

    self.parent.rightChild = None

    succ = self.parent.findSuccessor()

    self.parent.rightChild = self

    return succ

    def findMin(self):

    current = self

    while current.hasLeftChild():

    current = current.leftChild

    return current

    def spliceOut(self):

    if self.isLeaf():

    if self.isLeftChild():

    self.parent.leftChild = None

    else:

    self.parent.rightChild = None

    elif self.hasAnyChildren():

    if self.hasLeftChild():

    if self.isLeftChild():

    self.parent.leftChild = self.leftChild

    else:

    self.parent.rightChild = self.leftChild

    self.leftChild.parent = self.parent

    else:

    if self.isLeftChild():

    self.parent.leftChild = self.rightChild

    else:

    self.parent.rightChild = self.rightChild

    self.rightChild.parent = self.parent

    三、平衡二叉搜索树(AVL树)

    1. 概念

    二叉搜索树的深度越小,那么搜索所需要的运算时间越小。一个深度为log(n)的二叉搜索树,搜索算法的时间复杂度也是log(n)。然而,我们在二叉搜索树中已经实现的插入和删除操作并不能让保持log(n)的深度。如果我们按照8,7,6,5,4,3,2,1的顺序插入节点,那么就是一个深度为n的二叉树。那么,搜索算法的时间复杂度为n。

    在上一节中我们讨论了建立一个二叉搜索树。我们知道,当树变得不平衡时get和put操作会使二叉搜索树的性能降低到O(n)。

    如何减少树的深度呢?

    一种想法是先填满一层,再去填充下一层,这样就是一个完全二叉树(complete binary tree)。这样的二叉树实现插入算法会比较复杂。另一种比较容易实现的树状数据结构——AVL树,其搜索算法复杂度为log(n)。

    在这一节中我们将看到一种特殊的二叉搜索树,它可以自动进行调整,以确保树随时都保持平衡。这种树被称为AVL树,命名源于其发明者:G.M. Adelson-Velskii 和 E.M. Landis。

    AVL树实现 Map 抽象数据类型就像一个常规的二叉搜索树,唯一的区别是树的执行方式。为了实现我们的 AVL树,我们需要跟踪树中每个节点的平衡因子。我们通过查看每个节点的左右子树的高度来做到这一点。更正式地,我们将节点的平衡因子定义为左子树的高度和右子树的高度之间的差。

    balanceFactor=height(leftSubTree)−height(rightSubTree)

    使用上面给出的平衡因子的定义,我们说如果平衡因子大于零,则子树是左重的。如果平衡因子小于零,则子树是右重的。如果平衡因子是零,那么树是完美的平衡。为了实现AVL树,并且获得具有平衡树的好处,如果平衡因子是 -1,0 或 1,我们将定义树平衡。一旦树中的节点的平衡因子是在这个范围之外,我们将需要一个程序来使树恢复平衡。

    高度为h的树的节点数(Nh)为:

    Nh=1+Nh−1+Nh−2这个公式和斐波那契序列非常相似。我们可以利用这个公式通过树中的节点的数目推导出一个AVL树的高度。随着斐波那契序列的数字越来越大,Fi / Fi−1 越来越接近于黄金比例 Φ

    在任何时候,我们的AVL树的高度等于树中节点数目的对数的常数(1.44)倍。 这是搜索我们的AVL树的好消息,因为它将搜索限制为 O(logN)。

    2.实现

    当新增一个节点时,会破坏二叉树的平衡,因此需要通过旋转来修正。

    单旋转

    执行一个正确的右旋转,我们需要做到以下几点:使左节点成为子树的根。

    移动旧根到新根的右节点。

    如果新根原来有右节点,那么让其成为新根右节点的左节点。

    注:由于新根是旧根的左节点,移动后的旧根的左节点一定为空。这时可以直接给移动后的旧根添加左节点。

    同理,执行左旋转我们需要做到以下几点:使右节点(B)成为子树的根。

    移动旧的根节点(A)到新根的左节点。

    如果新根(B)原来有左节点,那么让原来B的左节点成为新根左节点(A)的右节点。

    双旋转

    如图,如果子节点是4不是2,尝试单旋转,会发现无法解决问题。

    要解决这个问题,我们必须使用以下规则:如果子树需要左旋转使之平衡,首先检查右节点的平衡因子。如果右节点左重则右节点右旋转,然后原节点左旋转。

    如果子树需要右旋转使之平衡,首先检查左节点的平衡因子。如果左节点右重则左节点左旋转,然后原节点右旋转。

    此时解决方式为双旋转。

    双旋转实际上是进行两次单旋转: 4为根节点的子树先进行一次向左的单旋转,然后将5为根节点的子树进行了一次向右的单旋转。这样恢复了树的ACL性质。

    对于AVL树,可以证明,在新增一个节点时,总可以通过一次旋转恢复AVL树的性质。

    旋转规则

    当我们插入一个新的节点时,在哪里旋转?是用单旋转还是双旋转?

    我们按照如下基本步骤进行:按照二叉搜索树的方式增加节点,新增节点称为一个叶节点。

    从新增节点开始,回溯到第一个失衡节点(5)。

    (如果回溯到根节点,还没有失衡节点,就说明该树已经符合AVL性质。)

    找到断的边(5->3),并确定断弦的方向(5的左侧)

    以断边下端(3)为根节点,确定两个子树中的哪一个深度大(左子树还是右子树)。

    (这两棵子树的深度不可能相等,而且深度大的子树包含有新增节点。)

    如果第2和第3步中的方向一致(都为左或者都为右),需要单旋转以失衡节点为根节点的子树。

    否则,双旋转以失衡节点为根节点的子树。

    四、红黑树

    红黑树是一种常用的平衡二叉搜索树,它是复杂的,但它的操作有着良好的最坏情况运行时间,即操作的复杂度都不会恶化,并且在实践中是高效的: 它可以在O(logn)时间内做单次的查找,插入和删除,这里的n是树中元素的数目。

    红黑树是一种很有意思的平衡检索树。它的统计性能要好于平衡二叉树( AVL-树),因此,红黑树在很多地方都有应用。在C++ STL中,很多部分(目前包括set, multiset, map, multimap)应用了红黑树的变体(SGI STL中的红黑树有一些变化,这些修改提供了更好的性能,以及对set操作的支持)。

    红黑树的主要规则:

    红-黑树的主要规则如下:节点是红色或黑色。

    根是黑色。

    所有叶子都是黑色(叶子是NIL节点)。

    每个红色节点必须有两个黑色的子节点。(从每个叶子到根的所有路径上不能有两个连续的红色节点。)

    从任一节点到其每个叶子的所有简单路径都包含相同数目的黑色节点。

    在红-黑树中插入的节点都是红色的,这不是偶然的,因为插入一个红色节点比插入一个黑色节点违背红-黑规则的可能性更小。原因是:插入黑色节点总会改变黑色高度(违背规则4),但是插入红色节点只有一半的机会会违背规则3。另外违背规则3比违背规则4要更容易修正。

    当插入一个新的节点时,可能会破坏这种平衡性,红-黑树主要通过三种方式对平衡进行修正,改变节点颜色、左旋和右旋。(具体规则省略)

    因为每一个红黑树也是一个特化的二叉查找树,因此红黑树上的只读操作与普通二叉查找树上的只读操作相同。然而,在红黑树上进行插入操作和删除操作会导致不再符合红黑树的性质。恢复红黑树的性质需要少量(O(logn))的颜色变更(实际是非常快速的)和不超过三次树旋转(对于插入操作是两次)。虽然插入和删除很复杂,但操作时间仍可以保持为O(logn) 次。

    一棵有 n 个内部节点的红黑树的高度至多为 2lg(n+1).

    展开全文
  • 代码表示方法:System.out.println(0b100)二、不同进制数据表现:八进制:由0,1,....,7.以0开头。十进制:由0,1......,9.默认整数。十六进制:由0,1,......9,a,b,c,d,e,f(大小写均可)组...

    展开全部

    一、二进制的表示方法

    有0,1组成。以62616964757a686964616fe58685e5aeb9313333663065300b开头。

    代码的表示方法:

    System.out.println(0b100)

    二、不同进制的数据表现:

    八进制:由0,1,....,7.以0开头。

    十进制:由0,1......,9.默认整数。

    十六进制:由0,1,......9,a,b,c,d,e,f(大小写均可)组成。

    十进制:System.out.println(100);

    八进制:System.out.println(0100);

    十六进制: System.out.println(0x100);

    43e57f61f77e06a99315a982409165e9.png

    扩展资料

    java 判断二进制文件的代码:

    public static boolean isBinary(File file)

    {

    boolean isBinary = false;

    try {

    FileInputStream fin = new FileInputStream(file);

    long len = file.length();

    for (int j = 0; j < (int) len; j++) {

    int t = fin.read();

    if (t < 32 && t != 9 && t != 10 && t != 13) {

    isBinary = true;

    break;

    }

    }

    } catch (Exception e) {

    e.printStackTrace();

    }

    return isBinary;

    }

    展开全文
  • 在六一表演中,你跳《鼓舞飞扬》表现非常突出,进步很大哦,相信升大班后,你会更加自信! 应千韵Apple宝贝: 你是一个文静、可爱的小女孩,你在老师帮助下,愿意自己事情自己做,吃饭和睡觉习惯有了很大...
  • 二叉树定义二叉树(binary tree)是结点有限...左右子树都存在 有且仅有这5中表现形式二叉树与一般树区别一般树子树不分次序,而二叉树子树有左右之分.由于二叉树也是树一种,所以大部分概念,对二...

    二叉树的定义

    二叉树(binary tree)是结点的有限集合,这个集合或者空,或者由一个根及两个互不相交的称为这个根的左子树或右子树构成.

    从定义可以看出,二叉树包括:1.空树 2.只有一个根节点 3.只有左子树   4.只有右子树  5.左右子树都存在    有且仅有这5中表现形式

    二叉树与一般树的区别

    一般树的子树不分次序,而二叉树的子树有左右之分.

    由于二叉树也是树的一种,所以大部分的树的概念,对二叉树也适用.

    二叉树的存贮:每个节点只需要两个指针域(左节点,右节点),有的为了操作方便也会 增加指向父级节点的指针,除了指针域以外,还会有一个数据域用来保存当前节点的信息

    二叉树的特点:

    性质1:在二叉树的第i层上至多有2^(i-1)个节点(i >= 1)

    性质2:深度为k的二叉树至多有2^(k-1)个节点(k >=1)

    性质3:对于任意一棵二叉树T而言,其叶子节点数目为N0,度为2的节点数目为N2,则有N0 = N2 + 1。

    性质4:具有n个节点的完全二叉树的深度 。

    二叉树的遍历

    二叉树的遍历分为三种:前序遍历 中序遍历 后序遍历

    前序遍历:按照“根左右”,先遍历根节点,再遍历左子树 ,再遍历右子树

    中序遍历:按照“左根右“,先遍历左子树,再遍历根节点,最后遍历右子树

    后续遍历:按照“左右根”,先遍历左子树,再遍历右子树,最后遍历根节点

    其中前,后,中指的是每次遍历时候的根节点被遍历的顺序

    二叉树遍历:

    前根左右

    中左根右

    后左右根

    ==================================================================

    二叉树遍历的java实现

    package 树;

    import java.util.ArrayList;

    import java.util.List;

    public class Tree {

    private Node root;

    private List list=new ArrayList();

    public Tree(){

    init();

    }

    //树的初始化:先从叶节点开始,由叶到根

    public void init(){

    Node x=new Node("X",null,null);

    Node y=new Node("Y",null,null);

    Node d=new Node("d",x,y);

    Node e=new Node("e",null,null);

    Node f=new Node("f",null,null);

    Node c=new Node("c",e,f);

    Node b=new Node("b",d,null);

    Node a=new Node("a",b,c);

    root =a;

    }

    //定义节点类:

    private class Node{

    private String data;

    private Node lchid;//定义指向左子树的指针

    private Node rchild;//定义指向右子树的指针

    public Node(String data,Node lchild,Node rchild){

    this.data=data;

    this.lchid=lchild;

    this.rchild=rchild;

    }

    }

    /**

    * 对该二叉树进行前序遍历 结果存储到list中 前序遍历:ABDXYCEF

    */

    public void preOrder(Node node)

    {

    list.add(node); //先将根节点存入list

    //如果左子树不为空继续往左找,在递归调用方法的时候一直会将子树的根存入list,这就做到了先遍历根节点

    if(node.lchid != null)

    {

    preOrder(node.lchid);

    }

    //无论走到哪一层,只要当前节点左子树为空,那么就可以在右子树上遍历,保证了根左右的遍历顺序

    if(node.rchild != null)

    {

    preOrder(node.rchild);

    }

    }

    /**

    * 对该二叉树进行中序遍历 结果存储到list中,中序结果XdYbaecf

    */

    public void inOrder(Node node)

    {

    if(node.lchid!=null){

    inOrder(node.lchid);

    }

    list.add(node);

    if(node.rchild!=null){

    inOrder(node.rchild);

    }

    }

    /**

    * 对该二叉树进行后序遍历 结果存储到list中,后续结果:XYdbefca

    */

    public void postOrder(Node node)

    {

    if(node.lchid!=null){

    postOrder(node.lchid);

    }

    if(node.rchild!=null){

    postOrder(node.rchild);

    }

    list.add(node);

    }

    /**

    * 返回当前数的深度

    * 说明:

    * 1、如果一棵树只有一个结点,它的深度为1。

    * 2、如果根结点只有左子树而没有右子树,那么树的深度是其左子树的深度加1;

    * 3、如果根结点只有右子树而没有左子树,那么树的深度应该是其右子树的深度加1;

    * 4、如果既有右子树又有左子树,那该树的深度就是其左、右子树深度的较大值再加1。

    *

    * @return

    */

    public int getTreeDepth(Node node) {

    if(node.lchid == null && node.rchild == null)

    {

    return 1;

    }

    int left=0,right = 0;

    if(node.lchid!=null)

    {

    left = getTreeDepth(node.lchid);

    }

    if(node.rchild!=null)

    {

    right = getTreeDepth(node.rchild);

    }

    return left>right?left+1:right+1;

    }

    //得到遍历结果

    public List getResult()

    {

    return list;

    }

    public static void main(String[] args) {

    Tree tree=new Tree();

    System.out.println("根节点是:"+tree.root);

    //tree.preOrder(tree.root);

    tree.postOrder(tree.root);

    for(Node node:tree.getResult()){

    System.out.println(node.data);

    }

    System.out.println("树的深度是"+tree.getTreeDepth(tree.root));

    }

    }

    另一种写法:

    本文只介绍二叉树的构造和遍历。

    构造一个二叉树的节点:

    public class BinaryTreeNode {

    public T data;

    public BinaryTreeNode leftChild, rightChild;

    public T getData() {

    return data;

    }

    public void setData(T data) {

    this.data = data;

    }

    public BinaryTreeNode getLeftChild() {

    return leftChild;

    }

    public void setLeftChild(BinaryTreeNode leftChild) {

    this.leftChild = leftChild;

    }

    public BinaryTreeNode getRightChild() {

    return rightChild;

    }

    public void setRightChild(BinaryTreeNode rightChild) {

    this.rightChild = rightChild;

    }

    }

    构造树:

    import java.util.ArrayList;

    import java.util.Iterator;

    import java.util.List;

    import java.util.Stack;

    public class BinaryTree {

    BinaryTreeNode root;

    public BinaryTree(){

    }

    /**

    * 二叉树的创建

    * @param list

    */

    public void createBiTree(List list){

    Iterator iterator = list.iterator();

    while(iterator.hasNext()){

    BinaryTreeNode node = new BinaryTreeNode();

    node.setData(iterator.next());

    insertTree(node);

    }

    }

    /**

    * 插入时,从根节点开始判断它是否有Child,如果没有,则将节点的孩子

    * 指向为传入参数的引用

    *

    * @param node

    */

    public void insertTree(BinaryTreeNode node) {

    if (root == null) {

    root = node;

    } else {

    BinaryTreeNode current = root;

    while (true) {//循环用于左右节点都有时,遍历下级节点

    if (current.leftChild == null) {

    current.leftChild = node;

    //跳出循环

    return;

    } else if (root.rightChild == null) {

    current.rightChild = node;

    return;

    } else {

    current = current.leftChild;

    }

    }

    }

    }

    /**

    * 先序递归遍历-按照root,left子树和right子树顺序遍历

    *

    */

    public void preOrderTraverse(BinaryTreeNode node){

    System.out.println(node.getData());

    if(node.getLeftChild()!=null){

    preOrderTraverse(node.getLeftChild());

    }

    if(node.getRightChild()!=null){

    preOrderTraverse(node.getRightChild());

    }

    }

    /**

    * 先序循环遍历-按照root,left子树和right子树顺序遍历

    *

    */

    public void preOrderTraverseLoop(BinaryTreeNode node){

    //System.out.println(node.getData());

    Stack stack = new Stack();

    stack.push(node);

    while(!stack.isEmpty()){

    BinaryTreeNode biNode = stack.pop();

    System.out.println(biNode.getData());

    BinaryTreeNode left = biNode.leftChild;

    if(left!=null){

    stack.push(left);

    }

    BinaryTreeNode right = biNode.rightChild;

    if(right!=null){

    stack.push(right);

    }

    }

    }

    public static void main(String[] args) {

    Integer[] ints = new Integer[]{1,3,9,8,7,6,2,98,76};

    List list = new ArrayList(ints.length);

    for (int i = 0; i < ints.length; i++) {

    list.add(ints[i]);

    }

    BinaryTree binaryTree = new BinaryTree();

    binaryTree.createBiTree(list);

    binaryTree.preOrderTraverse(binaryTree.root);

    System.out.println("=========================");

    binaryTree.preOrderTraverseLoop(binaryTree.root);

    }

    }

    我的总结:

    二叉树是一个相当重要的数据结构,它的应用面非常广,并且由他改进生成了很多重要的树类数据结构,如红黑树,堆等,应用价值之高后面深入学习便有体会,因此,掌握它的基本特征和遍历方式实现是学好后续数据结构的基础,理论方面其实我们看到二叉树的形状,我们自己画图都能总结出来,但是代码实现这一块,初学者不是很好理解,树的遍历利用了递归的思想,递归的思想本质无非就是循环,方法调方法,所以,理解二叉树遍历的代码实现最好的方式就是按照它的遍历思想自己画出图来一步一步的遍历一遍,先把这个遍历过程想明白了,然后再根据递归的思想,什么时候调什么样的方法,自然就能很容易想明白了

    展开全文
  • 二叉树作为树形结构一种具体表现形式,我们也在这一篇文章中进行详细说明。二叉树定义:二叉树是树形结构一个重要类型。许多实际问题抽象出来数据结构往往是二叉树形式,即使是一般树也能简单地转换为...
  • 负数二进制表现形式。  6 = 110  -6:其实就是6二进制取反+1  取反:将二进制1变成0,0变成1  0000-0000 0000-0000 0000-0000 0000-0110     1111-1111 1111-1111 1111-1111 1111-...
  • 即创建了一个两行三列的二维数组,将这个数组更直观的表现出来应为: 【[0,0,0],[0,0,0]】 也就是说这个二维数组,拥有两个长度为3的普通数组 我们可以更好的将其表现为 0,0,0 0,0,0 如果我们创建一个大一些的...
  • 用pysot里面的vot测试功能测试DIMP50在vot2018上的表现一、将实验添加到myexperiments.py中二、稍微调整一下run_experiment.py的运行接口三、修改votdataset.py中的gt格式四、修改tracker.py文件需要把复制到五、...
  • 关于CNUO一点点

    千次阅读 2018-06-05 20:17:49
    虽然这是不成熟的表现,但是自己也通过从想法的产生到付之行动,遇到困难默默解决,一步一步走了下来。这一版前后断断续续写了三个多月,中间一度“忘了”写,好在是坚持了下来。对于大牛来说,可能这个App很简单...
  • 二维数据:由多个一维数据构成,是一维数据组合形式。表格就是典型二维数据,其中表头是二维数组一部分。...python中二维数组表示:使用二维列表。注意字典并不是二维数组,而是高维数组,每...
  • Unix工具是你朋友 ... 首先,IDE以特定语言为目标,而Unix工具对于任何以文本形式表现的东西都能工作。现今开发环境中,新语言和新表示法每年都如雨后春笋般出现,学习Unix方式是一种有着重复回报投资。  
  • TrueType采用几何学中二次B样条曲线及直线来描述字体外形轮廓,其特点是:TrueType既可以作打印字体,又可以用作屏幕显示;由于它是由指令对字形进行描述,因此它与分辨率无关,输出时总是按照打印机分辨率输出...
  • 答:257因化学刺激引起腹泻叫答:激惹性腹泻下列不属于肝郁化热所致月经先期临床表现:答:经色紫红,质稠有块常用拆开蛋白质分子中二硫键方法有(1)________________法,常用试剂为________________。...
  • 摘要在多类别图像分割和标记领域表现最优技术采用都是定义在像素或者图像域之上条件随机场。虽然区域级模型通常具有稠密二元连通性,但由于考虑到像素级模型相当大所以只可以使用稀疏图结构。在这篇论文...
  • Python第十三课(模块1)

    2019-07-16 17:19:00
    Python第十三课(模块1) >>>转到思维导图>>>转到中二青年 1.什么是模块? ...1模块就是一系列工能结合体 ...2模块三种来源: ...3模块四种表现形式 1.使用python编写py文件(也就...
  • Python异常处理

    2019-10-03 11:47:47
    并且该错误没有对应处理机制,那么就会以异常形式表现出来 造成影响就是整个程序无法正常运行 异常结构 1.异常类型:NAMEERROR 2.异常信息:name 'abc' is not defined 3.异常...
  • 幼儿园观察记录表3篇

    2021-01-20 01:48:16
    幼儿园业务园长观察记录表 观察者 观察日期 观察时间7:40-8:20 观察班级中二班 观察地点 户外操场 观察对象 怡怡 观察目标 怡怡在户外活动中行为表现 户外活动开始了孩子们从筐里拿出高跷玩起
  • 古筝左手指法

    千次阅读 2013-11-19 18:06:54
    在筝曲中,表现细腻、委婉情趣,与左手技法巧妙运用有着十分密切关系。  左手吟按指法基本要求,左手在码子左侧弦段上润饰、美化和改变右手拨弦音各种指法,称为左手吟按指法。使用吟按指法时,首先...
  • JAVA取反运算

    2020-07-28 11:51:43
    1、首先明白任何一个整数在JAVA中二进制表达形式都是展现补码, 正数原码、反码、补码都是一致 如int a = 12,b = -13; int 类型占4个字节 32位表现形式如下: 用工具类Integer.toBinaryString()查看a,b在...
  • 相信你今天的表现也一定是棒棒哒!现在,就让我们一起度过接下来的“宅家时光”吧!今天中二班的小朋友给大家带来他们的宅家生活,我们一起看看他们跟爸爸妈妈一起做了哪些好玩的事情呢?游戏一:送球球回家 制作...
  • 卡马克卷轴算法

    2010-07-29 15:19:36
    这里使用简化概念,精确定义请参考计算机图形学中二维观察流程。 世界坐标系:用于标注整个游戏世界坐标系。 摄像机:摄像机摄到区域才能显示在屏幕上,摄像机在本文中表现为一个窗口,窗口内世界才能...
  • http请求方法总结

    2016-12-10 21:29:33
    数据量不能太大数据位置:存放在query_string变量中二、post:用于添加新内容表现:数据存在于请求体中,对get两个特点进行弥补三、head:取得相应头理解:类似于get,但不返回body信息。用途:检
  • (一)、先介绍一下3D绘图基本概念三维坐标系由于我们要将三维模型显示在二维显示器上,所以我们创建场景时,实际上是要创建三维对象二维表现形式。前面文章已经讲过,WPF中二维图形坐标系原点在屏幕左上角,x轴正...
  • (一)、先介绍一下3D绘图基本概念三维坐标系由于我们要将三维模型显示在二维显示器上,所以我们创建场景时,实际上是要创建三维对象二维表现形式。前面文章已经讲过,WPF中二维图形坐标系原点在屏幕左上角,x轴正...
  • (一)、先介绍一下3D绘图基本概念三维坐标系由于我们要将三维模型显示在二维显示器上,所以我们创建场景时,实际上是要创建三维对象二维表现形式。前面文章已经讲过,WPF中二维图形坐标系原点在屏幕左上角,x轴正...

空空如也

空空如也

1 2
收藏数 31
精华内容 12
关键字:

中二的表现