二叉树与二叉排序树的创建于遍历

最新推荐文章于 2022-08-04 17:15:46 发布
最新推荐文章于 2022-08-04 17:15:46 发布
阅读量1.3k 收藏
点赞数
分类专栏： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/watkinsong/article/details/11964399
版权 
// TREE_IMPORTANT.cpp : 定义控制台应用程序的入口点。
//

#include "stdio.h"
#include "stdlib.h"
#include "iostream"
#include "stack"
#include "vector"

using namespace std;

typedef struct Node
{
	int data;
	struct Node * lc;
	struct Node * rc;
}Node, *TNode;

typedef struct Tree
{
	struct Node * root;
};

void PreOrder(Node * root);
void InOrder(Node * root);
void PostOrder(Node * root);
void InOrderTraverseNotRecursive(Node * root);

void InsertSort(int * arr, int length);


void CreateTree(Node * &root, int &index);

// 通过指向Node的指针的指针构建二叉树
// 只有通过指针的指针，才能创建
void CreateTree2(TNode * root, int &index);

// 先序建立二叉树
// 根据用户交互输入建立二叉树
// 通过引用传递
void CreateTreeByInput(Node * &root);

// 插入新的数据到已经存在的二叉排序树
// 通过指向指针的指针
void Insert2BST(TNode * root, int data);

// 通过引用创建二叉排序树
void CreateBST(Node * &root,int arr[], int left, int right);

// 通过指向节点的指针的指针添加节点
void InsertNode2BST(TNode *root, int data);
void InsertNode2BST2(TNode *root, int data);

// 通过指向指针的指针创建二叉排序树
void CreateBST2(TNode *root, int arr[], int left, int right);

// 插入到二叉排序树
// 通过对指向节点的指针的引用
void Insert2BST(Node * &root, int data);

//int elements[] = {1,2,4,8,-1,-1,9,-1,-1,5,-1,-1,3,6,-1,-1,7,-1,-1};
int elements[] = {1,2,4,8,-1,-1,9,-1,-1,5,10,-1,-1,-1,3,6,-1,-1,7,-1,-1};

int test[] = {5, 7, 1, 4, 3, 2, 9, 6, 8, 0};

int index = 0;

vector<int> all;
int main(int argc, char* argv[])
{
	// 使用对Node的NULL指针构建二叉树，传递对NULL指针的引用
	Tree T;
	T.root = NULL;
	// 通过对指针的引用为NULL指针申请内存
	CreateTree(T.root, index);
	PreOrder(T.root);
	//InOrder(T.root);
	cout<<endl;

	// 通过指向指针的指针创建二叉树
	index  = 0;
	Tree T2;
	T2.root = NULL;
	cout<<"通过指向指针的指针创建二叉树"<<endl;
	// 通过对指针的引用为NULL指针申请内存
	CreateTree2(&T2.root, index);
	PreOrder(T2.root);
	cout<<endl;

	// 遍历二叉树
	all.clear();
	// 先序遍历二叉树
	cout<<"先序遍历二叉树"<<endl;
	PreOrder(T.root);
	cout<<endl;
	int * arr = new int[all.size()];
	for(int i = 0; i < all.size(); i++)
		arr[i] = all[i];
	InsertSort(arr, all.size());
	Tree T3;
	T3.root = NULL;
	CreateBST(T3.root, arr, 0, all.size() - 1);
	cout<<"二叉排序的中序遍历"<<endl;
	//InOrderTraverseNotRecursive(T3.root);
	InOrder(T3.root);
	cout<<endl;


	cout<<"/"<<endl;
	// 测试通过指向指针的指针创建二叉排序树
	Tree T4;
	T4.root = NULL;
	CreateBST2(&T4.root, arr, 0, all.size() - 1);
	cout<<"通过指向指针的指针创建排序二叉树，中序遍历"<<endl;
	InOrder(T4.root);
	cout<<endl;


	// 通过对指针的引用创建二叉排序树
	cout<<"通过引用不停的插入新的节点，创建二叉排序树"<<endl;
	Tree T5;
	T5.root = NULL;
	for(int i = 0; i < 10; i++)
	{
		Insert2BST(T5.root, test[i]);
	}
	InOrder(T5.root);
	cout<<endl;

	system("pause");
	return 0;
}

// 通过指针的引用创建二叉树
// 如果不是引用，指向Node的指针为NULL, 指针为值传递，在调用函数中创建的Node不会和上一层的函数关联起来
// 所以最终的二叉树还是NULL
// 使用对Node的NULL指针构建二叉树，传递对NULL指针的引用
void CreateTree(Node * &root, int &index)
{
	int data = elements[index];
	if(data == -1)
		return; // 叶子节点

	root = new Node;
	root->data = data;
	root->lc = NULL;
	root->rc = NULL;

	CreateTree(root->lc, ++index);
	CreateTree(root->rc, ++index);
}

// 通过指向Node的指针的指针构建二叉树
// 只有通过指针的指针，才能创建
void CreateTree2(TNode * root, int &index)
{
	int data = elements[index];
	if(data == -1)
		return; // 叶子节点

	*root = new Node;
	(*root)->data = data;
	(*root)->lc = NULL;
	(*root)->rc = NULL;

	CreateTree2(&(*root)->lc, ++index);
	CreateTree2(&(*root)->rc, ++index);
}

// 先序建立二叉树
// 根据用户交互输入建立二叉树
// 通过引用传递
void CreateTreeByInput(Node * &root)
{
	int data;
	scanf("%d", &data);
	if(data == -1)
		return; // 叶子节点

	root = new Node;

	root->data = data;
	root->lc = NULL;
	root->rc = NULL;

	CreateTreeByInput(root->lc);
	CreateTreeByInput(root->rc);
}


// 先序遍历
void PreOrder(Node * root)
{
	if(root)
	{
		printf("%3d", root->data);
		all.push_back(root->data);
		PreOrder(root->lc);
		PreOrder(root->rc);
	}
}

// 中序遍历
void InOrder(Node * root)
{
	if(root)
	{
		InOrder(root->lc);
		printf("%3d", root->data);
		InOrder(root->rc);
	}
}

// 后序遍历
void PostOrder(Node * root)
{
	if(root)
	{
		PostOrder(root->lc);
		PostOrder(root->rc);
		printf("%3d", root->data);
	}
}

// 中序非递归遍历
void InOrderTraverseNotRecursive(Node * root)
{
	stack<Node *> s;
	s.push(root);

	while(!s.empty())
	{
		Node * p = s.top();
		while( p != NULL )
		{
			s.push(p->lc);
			p = s.top();
		}

		s.pop();

		if(!s.empty())
		{
			Node * t = s.top();
			s.pop();
			printf("%3d", t->data);
			s.push(t->rc);
		}
	}
}

void InsertSort(int * arr, int length)  
{  
    for (int i=1; i < length; i++)  
    {  
        if (arr[i] < arr[i-1])  
        {  
            int temp = arr[i];  
            int j = i - 1;  
            do   
            {  
                arr[j+1] = arr[j];  
                j = j - 1;  
            } while (j >= 0 && arr[j] > temp);  
            arr[j+1] = temp;  
        }
    }
}

// 插入新的数据到已经存在的二叉排序树
// 通过指向指针的指针
void Insert2BST(TNode * root, int data)
{
	while(*root)
	{
		if((*root)->data < data)
		{
			(*root) = (*root)->lc;
		}
		else
		{
			(*root) = (*root)->rc;
		}
	}

	(*root) = new Node;
	(*root)->data = data;
	(*root)->lc = NULL;
	(*root)->rc = NULL;
}


// 插入到二叉排序树
// 通过对指向节点的指针的引用
void Insert2BST(Node * &root, int data)
{
	if(root == NULL)
	{
		root = new Node;
		root->data = data;
		root->lc = NULL;
		root->rc = NULL;
		return;
	}
	else
	{
		if(data < root->data)
		{
			Insert2BST(root->lc, data);
		}
		else
		{
			Insert2BST(root->rc, data);
		}
	}
}


// 通过引用创建二叉排序树
void CreateBST(Node * &root,int arr[], int left, int right)
{
	if(left <= right)
	{
		int mid = (left + right)/2;

		root = new Node;
		root->data = arr[mid];
		root->lc = NULL;
		root->rc = NULL;

		CreateBST(root->lc, arr, left, mid - 1);
		CreateBST(root->rc, arr, mid + 1, right);
	}
}

// 通过指向指针的指针创建二叉排序树
// 暂时的代码和引用没有区别
void CreateBST2(TNode *root, int arr[], int left, int right)
{
	if(left <= right)
	{
		int mid = (left + right)/2;

		int temp = arr[mid];
		InsertNode2BST2(root, temp);

		CreateBST2(root, arr, left, mid - 1);
		CreateBST2(root, arr, mid + 1, right);
	}
}

// 通过指向节点的指针的指针添加节点
// 每次插入都需要从根节点找到带插入的节点位置
// 这段代码，虽然每次TNode * root都是值传递，但是每次代码运行，二叉树的根节点的指针都移动了
// 每次插入节点，根节点指针都移动到最后一个元素，然后指向根节点的指针的指针又总是指向根节点
// 所以这段代码是有问题的***** @@@@@ %%%%%%%%%
void InsertNode2BST(TNode *root, int data)
{
	while(*root)
	{
		if((*root)->data < data)
		{
			(*root) = (*root)->lc;
		}
		else
		{
			(*root) = (*root)->rc;
		}
	}
	(*root) = new Node;
	(*root)->data = data;
	(*root)->lc = NULL;
	(*root)->rc = NULL;
}

// 通过移动指向根节点的指针的指针，找到待插入的位置
// 这样也不会移动原来的根节点
void InsertNode2BST2(TNode *root, int data)
{
	while(*root)
	{
		if((*root)->data > data)
		{
			root = &(*root)->lc;
		}
		else
		{
			root = &(*root)->rc;
		}
	}
	(*root) = new Node;
	(*root)->data = data;
	(*root)->lc = NULL;
	(*root)->rc = NULL;
}

二叉树、二叉树排序树的实现及遍历
ZER00000001的博客
07-23 997
对于大量的数据而言，链表的线性访问时间太慢，不宜使用。本章节将会介绍一种简单的数据结构：树（tree），其大部分操作的运行时间平均为O（logN）。在数据结构中树是非常有用的抽象概念，在本篇中我们将讨论二叉树的存储结构、二叉树的遍历和二叉排序树的实现，为后续平衡树以及高阶搜索树打下基础。我们下次将详细讲解二叉平衡树的增删查改。...
二叉树（排序树）的创建、遍历、插入、删除以及查找
weixin_43126491的博客
08-11 3660
二叉树（排序树）的创建、遍历、插入、删除以及查找 原理：二叉树的先序创建（递归）按先序遍历的顺序，依次 输入结点的信息建成立二叉链表的算法。该算法的基本思想是：首先对一般的二叉树添加若干个虚结点，使每一个节点都有左右两个孩子，然后依次输入结点信息。若输入的结不是虚结点，则建立一个新结点；先序创建左子树；先序创建右子树 在这里插入代码片 ...
二叉排序树（Java实现）
u013571044的博客
11-25 198
package cn.mrlij.binarysorttree; /** * 二叉排序树 */ public class BinarySortTreeDemo { public static void main(String[] args) { BinarySortTree bst = new BinarySortTree(); int[] arr ...
面试前你需要掌握的二叉树、二叉排序树的创建和四种遍历方式
04-05 1455
二叉树的创建 普通二叉树的创建，这里以完全二叉树的创建为例，所谓完全二叉树，也就是从根节点开始，一层一层的往后接入节点，首先我们创建一个结构体，用来存储二叉树的节点，每一个节点除了存一个data，还有一个左孩子和一个右孩子。 #include<stdio.h> #include<algorithm> using namespace std; struct BiTree{ ...
二叉排序树（二叉搜索树）的建立与遍历方法（超详细图文解释）
热门推荐
yohe12的博客
12-22 4万+
详解二叉排序树的性质，如何通过代码创建一个二叉排序树，二叉排序树的一个重要用处。
C语言二叉排序树的中序遍历,C语言实现二叉树的中序线索化及遍历中序线索二叉树...
weixin_30607173的博客
05-20 1070
C语言实现二叉树的中序线索化及遍历中序线索二叉树C语言实现二叉树的中序线索化及遍历中序线索二叉树C语言实现二叉树的线索化以及如何遍历线索二叉树！文章目录线索二叉树的结构及数据类型定义根据输入结点初始化二叉树中序遍历二叉树并线索化遍历中序线索二叉树项目完整代码运行效果图线索二叉树的结构及数据类型定义//定义数据类型typedef char ElemType;//枚举，Link为0表示不是线索，Thr...
二叉搜索树及中序遍历
繁华街角的歇脚处
03-30 5321
二叉搜索树的概念 二叉搜索树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根节点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。二叉搜索树作为一种经典的数据结构，它既有链表的快速插入与删除操作的特点，又有数组快速查找的优势；所以应用十分广泛，例如在文件系统和数据库系统一般会采用这种数据结构进行高效率的排序与检索操作。 图..
写一算法,判断一棵二叉树是否是一棵二叉排序树。
07-15
根据给定的文件信息，我们将深入探讨如何通过不同的方法来判断一棵二叉树是否为二叉排序树（Binary Search Tree, BST）。二叉排序树是一种特殊的二叉树，它满足以下条件： 1. 若左子树不为空，则左子树上所有节点的...
二叉搜索树的后序遍历序列
皮卡qiu~的博客
08-24 2330
一、需求 输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历结果，如果是则返回true，否则返回false。 假设输入的数组的任意两个数字都互不相同。 二、分治算法 2.1 思路分析 后序遍历：左、右、根。 二叉搜索树：左子树中所有结点的值 < 根结点的值，右子树中所有结点的值 > 根结点的值，其左、右子树也分别为二叉搜索树。 根据二叉树搜索树的定义，可以通过递归判断所有子树的正确性(即其后序遍历是否满足二叉搜索树的定义)，若所有子树均正确，则此序列为二叉搜索树的后序遍历...
二叉排序树_17281183_刘梦婷_leavingtbk_二叉排序树_
10-01
二叉排序树，又称二叉查找树或二叉搜索树，是一种特殊的二叉树数据结构，它具有以下特性：对于树中的每个节点，其左子树中的所有节点的值都小于该节点的值，而右子树中的所有节点的值都大于该节点的值。这种性质使得...
二叉树的生成与遍历
清风明月's blog
11-18 2168
#include <stdio.h> #include <stdlib.h>typedef char ElemType;typedef struct BiTNode{ char data;//数据域 struct BiTNode *lchild,*rchild;//左，右孩子 }BiTNode,*BiTree;//建立二叉树,前序遍历 CreateBiTree(BiTree *
二叉排序树C语言实现（超级详细代码）
nidayededaye2的博客
12-12 7475
今天来给大家讲解一下二叉排序树C语言代码实现 typedef int ElemType; // 自定义数据元素为整数。 // 二叉树的数据结构。 typedef struct BSTNode { ElemType data; // 存放结点的数据元素。 struct BSTNode* lchild; // 指向左子结点地址的指针。 struct BSTNode* rchild; // 指向右子结点地址的指针。 ..
二叉排序树 建树_二叉排序树
weixin_28867413的博客
01-27 527
首先二叉排序树也是一棵二叉树，所谓二叉树，就是“任何节点最多只允许两个子节点”，这两个子节点称为左右子节点。如下便是一个二叉树。二叉排序树性质：1、就是若它的左子树不空，则左子树上所有节点的值均小于它的根节点的值；2、若它的右子树不空，则右子树上所有节点的值均大于其根节点的值。3、换句话说就是：任何节点的键值一定大于其左子树中的每一个节点的键值，并小于其右子树中的每一个节点的键值。如下便...
数据结构-二叉排序树（二叉查找树or二叉线索数）
Colin_xuan的博客
08-04 215
排序二叉树代码。
排序二叉树（BST）
qq_42211587的博客
06-09 592
/* 排序二叉树 BST 时间复杂度为 LOG n 2 */ #include <iostream> #include <stack> using namespace std; typedef struct node { int value; struct node *left,*right; }...
二叉搜索树基本原理与C语言实现
qq_41836269的博客
05-21 365
1：二叉搜索树的客观认识 二叉搜索树又称二叉排序树，即对一棵树按照中序遍历之后，每个节点的属性值是按照顺序排列的，如下图： 对上图的树按照中序遍历得到的属性值依次为(2,5,5,6,7,8)，可以发现得到的属性值是按照从小到大排序的。 2：二叉搜索树的性质 对于二叉搜索树的每一个节点，如果它的左孩子不为NULL，那么它左孩子的属性值 <= 它的属性值；如果右孩...
二叉树构建、遍历、线索、节点数目、深度、高度、（非）递归等操作
10-09 293
//Notice: this file.cpp can run on your pc; //input: example // 1 // 2 3 // you can input 1 2 0 0 3 0 0 // then you'll get a binaryTree like line 3、4 #include <iostream> #include &lt...
94. 二叉树的中序遍历
行走巨人国
05-22 1061
题目描述： 给定一个二叉树，返回它的中序遍历。 示例: 输入: [1,null,2,3] 1 \ 2 / 3 输出: [1,3,2] 进阶:递归算法很简单，你可以通过迭代算法完成吗？ 代码： 递归： class Solution { public: vector<int> inorderTraver...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值