二叉排序树

最新推荐文章于 2022-04-25 21:17:35 发布
原创 最新推荐文章于 2022-04-25 21:17:35 发布 · 245 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。 

#include <iostream>
using namespace std;
typedef struct Node{
    int key;
    struct Node* Lchild;
    struct Node* Rchild;
}BSTNode;

int EQ(int a,int b){
    if(a==b){
        return 1;
    }else{
        return 0;
    }
}

int LT(int a,int b){
    if(a<b){
        return 1;
    }else{
        return 0;
    }
}

BSTNode* BST_Search(BSTNode*T,int k){
    if(T==NULL)
        return NULL;
    else {
        if(EQ(T->key,k)){
            return T;
        }else if(LT(k,T->key)){
            return BST_Search(T->Lchild,k);
        }else{
            return BST_Search(T->Rchild,k);
        }
    }
}

void Insert_BST(BSTNode*T,int k){
    BSTNode*p=new BSTNode;
    p->key=k;
    p->Lchild=NULL;
    p->Rchild=NULL;
    if(T==NULL){
        T=p;
    }else{
        if(EQ(T->key,p->key)){
            return ;
        }else if(LT(p->key,T->key)){
            Insert_BST(T->Lchild,k);
        }else{
            Insert_BST(T->Rchild,k);
        }
    }
}


void inOrderTraverse(BSTNode* root) {
	if (root) {
		inOrderTraverse(root->Lchild);
		cout << root->key;
		inOrderTraverse(root->Rchild);
	}
}

int main(){
    int t;
    cin>>t;
    while(t--){
        int n;
        cin>>n;
        BSTNode*T=NULL;
        int num;
        for(int i=0;i<n;i++){
            cin>>num;
            Insert_BST(T,num);
        }
        inOrderTraverse(T);
        int m;
        cin>>m;
        while(m--){
            cin>>num;
            Insert_BST(T,num);
            inOrderTraverse(T);
        }
    }
    return 0;
}

存在问题，没有任何输入

可能原因，建树失败

 

 

什么情况？

#include <iostream>
using namespace std;

typedef struct Node{
    int key;
    struct Node* Lchild;
    struct Node* Rchild;
}BSTNode;

int EQ(int a,int b){
    if(a==b){
        return 1;
    }else{
        return 0;
    }
}

int LT(int a,int b){
    if(a<b){
        return 1;
    }else{
        return 0;
    }
}

BSTNode* BST_Search(BSTNode*T,int k){
    if(T==NULL)
        return NULL;
    else {
        if(EQ(T->key,k)){
            return T;
        }else if(LT(k,T->key)){
            return BST_Search(T->Lchild,k);
        }else{
            return BST_Search(T->Rchild,k);
        }
    }
}

void Insert_BST(BSTNode*T,int k){
    cout<<"***"<<endl;

    if(T==NULL){
            cout<<"666"<<endl;
       T=new BSTNode;
    T->key=k;
    T->Lchild=NULL;
    T->Rchild=NULL;
    return;
    }

        if(T->key==k){
            cout<<"111"<<endl;
            return ;
        }else if(k<T->key){
            cout<<"222"<<endl;
            Insert_BST(T->Lchild,k);
        }else{
            cout<<"333"<<endl;
            Insert_BST(T->Rchild,k);
        }

}


BSTNode* create(int data[],int n){
	BSTNode*T = NULL;
	for(int i = 0;i < n; i++){
		Insert_BST(T,data[i]);
	}
	return T;
}

void inOrderTraverse(BSTNode* root) {
	if (root) {
		inOrderTraverse(root->Lchild);
		cout << root->key;
		inOrderTraverse(root->Rchild);
	}
}

int main(){
    int t;
    cin>>t;
    while(t--){
        int n;
        cin>>n;

        int*num=new int[n];
        for(int i=0;i<n;i++){
            cin>>num[i];
        }
        BSTNode*T=create(num,n);
        inOrderTraverse(T);
        int m;
        cin>>m;
        int z;
        while(m--){
            cin>>z;
            Insert_BST(T,z);
            inOrderTraverse(T);
        }
    }
    return 0;
}

???似乎解决问题了

#include <iostream>
using namespace std;

typedef struct Node{
    int key;
    struct Node* Lchild;
    struct Node* Rchild;
}BSTNode;

void Insert_BST(BSTNode*&T,int k){

    if(T==NULL){
       T=new BSTNode;
        T->key=k;
        T->Lchild=NULL;
        T->Rchild=NULL;
        return;
    }

        if(T->key==k){
            return ;
        }else if(k<T->key){
            Insert_BST(T->Lchild,k);
        }else{
            Insert_BST(T->Rchild,k);
        }
}

BSTNode* create(int n){
	BSTNode*T = NULL;
	int z;
	for(int i = 0;i < n; i++){
        cin>>z;
		Insert_BST(T,z);
	}
	return T;
}

void inOrderTraverse(BSTNode* root) {
	if (root) {
		inOrderTraverse(root->Lchild);
		cout << root->key<<" ";
		inOrderTraverse(root->Rchild);
	}
}

int main(){
    int t;
    cin>>t;
    while(t--){
        int n;
        cin>>n;
        BSTNode*T=create(n);
        inOrderTraverse(T);
        cout<<endl;
        int m;
        cin>>m;
        int z;
        while(m--){
            cin>>z;
            Insert_BST(T,z);
            inOrderTraverse(T);
            cout<<endl;
        }
    }
    return 0;
}

加一个地址符？

完美搞定

查找：

#include <iostream>
using namespace std;

typedef struct Node{
    int key;
    struct Node* Lchild;
    struct Node* Rchild;
}BSTNode;

BSTNode* BST_Search(BSTNode*T,int k,int&num){

    if(T==NULL)
        return NULL;
    else {
            num++;
        if(T->key==k){

            return T;
        }else if(k<T->key){
            return BST_Search(T->Lchild,k,num);
        }else{
            return BST_Search(T->Rchild,k,num);
        }
    }
}

void Insert_BST(BSTNode*&T,int k){

    if(T==NULL){
       T=new BSTNode;
        T->key=k;
        T->Lchild=NULL;
        T->Rchild=NULL;
        return;
    }

        if(T->key==k){
            return ;
        }else if(k<T->key){
            Insert_BST(T->Lchild,k);
        }else{
            Insert_BST(T->Rchild,k);
        }
}


BSTNode* create(int n){
	BSTNode*T = NULL;
	int z;
	for(int i = 0;i < n; i++){
        cin>>z;
		Insert_BST(T,z);
	}
	return T;
}

void inOrderTraverse(BSTNode* root) {
	if (root) {
		inOrderTraverse(root->Lchild);
		cout << root->key<<" ";
		inOrderTraverse(root->Rchild);
	}
}

int main(){
    int t;
    cin>>t;
    while(t--){
        int n;
        cin>>n;
        BSTNode*T=create(n);
        inOrderTraverse(T);
        cout<<endl;
        int m;
        cin>>m;
        int z,num;
        while(m--){
            cin>>z;
            num=0;
            BSTNode*F=BST_Search(T,z,num);
            if(F==NULL){
                cout<<"-1"<<endl;
            }else{
                cout<<num<<endl;
            }

        }
    }
    return 0;
}

删除：

#include <iostream>
using namespace std;

typedef struct Node{
    int key;
    struct Node* Lchild;
    struct Node* Rchild;
}BSTNode;

BSTNode*BST_Search(BSTNode*T,int k){
    if(T==NULL)
        return NULL;
    else {
        if(T->key==k){
            return T;
        }else if(k<T->key){
            return BST_Search(T->Lchild,k);
        }else{
            return BST_Search(T->Rchild,k);
        }
    }
}

void Delete(BSTNode*&F){
    if(F->Lchild==NULL){
            cout<<"Lch"<<endl;
        F=F->Rchild;
    }else if(F->Rchild==NULL){
        cout<<"Rch"<<endl;
        F=F->Lchild;
    }else{
        cout<<"emm"<<endl;
        BSTNode*q=F;
        BSTNode*p=F->Lchild;
        while(p->Rchild){
            q=p;
            p=p->Rchild;
        }
        F->key=p->key;
        if(q!=F){
            q->Rchild=p->Lchild;
        }else{
            q->Lchild=p->Lchild;
        }
        return ;
    }
}

void Insert_BST(BSTNode*&T,int k){

    if(T==NULL){
       T=new BSTNode;
        T->key=k;
        T->Lchild=NULL;
        T->Rchild=NULL;
        return;
    }

        if(T->key==k){
            return ;
        }else if(k<T->key){
            Insert_BST(T->Lchild,k);
        }else{
            Insert_BST(T->Rchild,k);
        }
}


BSTNode* create(int n){
	BSTNode*T = NULL;
	int z;
	for(int i = 0;i < n; i++){
        cin>>z;
		Insert_BST(T,z);
	}
	return T;
}

void inOrderTraverse(BSTNode* root) {
	if (root) {
		inOrderTraverse(root->Lchild);
		cout << root->key<<" ";
		inOrderTraverse(root->Rchild);
	}
}

int main(){
    int t;
    cin>>t;
    while(t--){
        int n;
        cin>>n;
        BSTNode*T=create(n);
        inOrderTraverse(T);
        cout<<endl;
        int m;
        cin>>m;
        int z,num;
        while(m--){
            cin>>z;
            BSTNode*F=BST_Search(T,z);
            if(F!=NULL){
                    cout<<"could found"<<endl;
                Delete(F);
            }
            inOrderTraverse(T);
            cout<<endl;
        }
    }
    return 0;
}

也许是没有删除野指针的操作，导致出问题

#include <iostream>
using namespace std;

typedef struct Node{
    int key;
    struct Node* Lchild;
    struct Node* Rchild;
}BSTNode;

BSTNode*BST_Search(BSTNode*T,int k){
    if(T==NULL)
        return NULL;
    else {
        if(T->key==k){
            return T;
        }else if(k<T->key){
            return BST_Search(T->Lchild,k);
        }else{
            return BST_Search(T->Rchild,k);
        }
    }
}

void Delete(BSTNode*F){
    BSTNode*q;
    BSTNode*s;
    if(F->Lchild==NULL){
        cout<<"Lch"<<endl;
        F=F->Rchild;
    }else if(F->Rchild==NULL){
        cout<<"Rch"<<endl;
        F=F->Lchild;
    }else{
        cout<<"emm"<<endl;
        q=F;
        s=F->Lchild;
        while(s->Rchild){
            q=s;
            s=s->Rchild;
        }
        F->key=s->key;
        if(q!=F){
            q->Rchild=s->Lchild;
        }else{
            q->Lchild=s->Lchild;
        }
    }
     return ;
}

void Insert_BST(BSTNode*&T,int k){
    if(T==NULL){
       T=new BSTNode;
        T->key=k;
        T->Lchild=NULL;
        T->Rchild=NULL;
        return;
    }
        if(T->key==k){
            return ;
        }else if(k<T->key){
            Insert_BST(T->Lchild,k);
        }else{
            Insert_BST(T->Rchild,k);
        }
}


BSTNode* create(int n){
	BSTNode*T = NULL;
	int z;
	for(int i = 0;i < n; i++){
        cin>>z;
		Insert_BST(T,z);
	}
	return T;
}

void inOrderTraverse(BSTNode* root) {
	if (root) {
		inOrderTraverse(root->Lchild);
		cout << root->key<<" ";
		inOrderTraverse(root->Rchild);
	}
}

int main(){
    int t;
    cin>>t;
    while(t--){
        int n;
        cin>>n;
        BSTNode*T=create(n);
        inOrderTraverse(T);
        cout<<endl;
        int m;
        cin>>m;
        int z,num;
        while(m--){
            cin>>z;
            BSTNode*F=BST_Search(T,z);
            if(F!=NULL){
                    cout<<"could found"<<endl;
                Delete(F);
            }
            inOrderTraverse(T);
            cout<<endl;
        }
    }
    return 0;
}

有问题啊？

 

 

#include <iostream>
using namespace std;

typedef struct Node{
    int key;
    struct Node* Lchild;
    struct Node* Rchild;
    struct Node* Father;
}BSTNode;

BSTNode*BST_Search(BSTNode*T,int k){
    if(T==NULL)
        return NULL;
    else {
        if(T->key==k){
            return T;
        }else if(k<T->key){
            return BST_Search(T->Lchild,k);
        }else{
            return BST_Search(T->Rchild,k);
        }
    }
}

void Delete(BSTNode*F){
    BSTNode*q;
    BSTNode*s;
    if(F->Lchild==NULL){
        cout<<"Lch"<<endl;
        q=F;
        F=F->Rchild;

    }else if(F->Rchild==NULL){
        cout<<"Rch"<<endl;
        q=F;
        F=F->Lchild;
    }else{
        cout<<"emm"<<endl;
        q=F;
        s=F->Lchild;
        while(s->Rchild){
            q=s;
            s=s->Rchild;
        }
        F->key=s->key;
        if(q!=F){
            q->Rchild=s->Lchild;
        }else{
            q->Lchild=s->Lchild;
        }
    }
}

void Insert_BST(BSTNode*&T,int k,BSTNode*&F){
    if(T==NULL){
       T=new BSTNode;
        T->key=k;
        T->Lchild=NULL;
        T->Rchild=NULL;
        T->Father=F;
        return;
    }
        if(T->key==k){
            return ;
        }else if(k<T->key){
            Insert_BST(T->Lchild,k,T);
        }else{
            Insert_BST(T->Rchild,k,T);
        }
}


BSTNode* create(int n){
	BSTNode*T = NULL;
	int z;
	for(int i = 0;i < n; i++){
        cin>>z;
		Insert_BST(T,z,NULL);
	}
	return T;
}

void inOrderTraverse(BSTNode* root) {
	if (root) {
		inOrderTraverse(root->Lchild);
		cout << root->key<<" ";
		inOrderTraverse(root->Rchild);
	}
}

int main(){
    int t;
    cin>>t;
    while(t--){
        int n;
        cin>>n;
        BSTNode*T=create(n);
        inOrderTraverse(T);
        cout<<endl;
        int m;
        cin>>m;
        int z,num;
        while(m--){
            cin>>z;
            BSTNode*F=BST_Search(T,z);
            inOrderTraverse(T);
            if(F!=NULL){
                cout<<"could found"<<endl;
                inOrderTraverse(T);
                Delete(F);
            }
            inOrderTraverse(T);
            cout<<endl;
        }
    }
    return 0;
}

这里还没改完，我觉得是传父亲结点，但是看来不用，再试一试

#include <iostream>
using namespace std;

typedef struct Node{
    int key;
    struct Node* Lchild;
    struct Node* Rchild;
}BSTNode;

BSTNode*BST_Search(BSTNode*T,int k){
    if(T==NULL)
        return NULL;
    else {
        if(T->key==k){
            return T;
        }else if(k<T->key){
            return BST_Search(T->Lchild,k);
        }else{
            return BST_Search(T->Rchild,k);
        }
    }
}

void Delete(BSTNode*&F){
    BSTNode*q;
    BSTNode*s;
    if(F->Lchild==NULL){
        q=F;
        F=F->Rchild;
        delete F;
    }else if(F->Rchild==NULL){
        q=F;
        F=F->Lchild;
        delete F;
    }else{
        q=F;
        s=F->Lchild;
        while(s->Rchild){
            q=s;
            s=s->Rchild;
        }
        F->key=s->key;
        if(q!=F){
            q->Rchild=s->Lchild;
        }else{
            q->Lchild=s->Lchild;
        }
        delete s;
    }
}

void Insert_BST(BSTNode*&T,int k){
    if(T==NULL){
       T=new BSTNode;
        T->key=k;
        T->Lchild=NULL;
        T->Rchild=NULL;
        return;
    }
        if(T->key==k){
            return ;
        }else if(k<T->key){
            Insert_BST(T->Lchild,k);
        }else{
            Insert_BST(T->Rchild,k);
        }
}


BSTNode* create(int n){
	BSTNode*T = NULL;
	int z;
	for(int i = 0;i < n; i++){
        cin>>z;
		Insert_BST(T,z);
	}
	return T;
}

void inOrderTraverse(BSTNode* root) {
	if (root) {
		inOrderTraverse(root->Lchild);
		cout << root->key<<" ";
		inOrderTraverse(root->Rchild);
	}
}

int main(){
    int t;
    cin>>t;
    while(t--){
        int n;
        cin>>n;
        BSTNode*T=create(n);
        inOrderTraverse(T);
        cout<<endl;
        int m;
        cin>>m;
        int z,num;
        while(m--){
            cin>>z;
            BSTNode*F=BST_Search(T,z);
            if(F!=NULL){
                Delete(F);
            }
            inOrderTraverse(T);
            cout<<endl;
        }
    }
    return 0;
}

照旧

#include <iostream>
using namespace std;

typedef struct Node{
    int key;
    struct Node* Lchild;
    struct Node* Rchild;
}BSTNode;


void Delete(BSTNode*&F){
    BSTNode*q;
    BSTNode*s;
    if(F->Lchild==NULL){
        q=F;
        F=F->Rchild;
        delete F;
    }else if(F->Rchild==NULL){
        q=F;
        F=F->Lchild;
        delete F;
    }else{
        q=F;
        s=F->Lchild;
        while(s->Rchild){
            q=s;
            s=s->Rchild;
        }
        F->key=s->key;
        if(q!=F){
            q->Rchild=s->Lchild;
        }else{
            q->Lchild=s->Lchild;
        }
        delete s;
    }
}

void Delete_Search(BSTNode*&T,int k){
    if(T==NULL)
        return ;
    else {
        if(T->key==k){
            Delete(T);
        }else if(k<T->key){
            Delete_Search(T->Lchild,k);
        }else{
            Delete_Search(T->Rchild,k);
        }
    }
}


void Insert_BST(BSTNode*&T,int k){
    if(T==NULL){
       T=new BSTNode;
        T->key=k;
        T->Lchild=NULL;
        T->Rchild=NULL;
        return;
    }
        if(T->key==k){
            return ;
        }else if(k<T->key){
            Insert_BST(T->Lchild,k);
        }else{
            Insert_BST(T->Rchild,k);
        }
}


BSTNode* create(int n){
	BSTNode*T = NULL;
	int z;
	for(int i = 0;i < n; i++){
        cin>>z;
		Insert_BST(T,z);
	}
	return T;
}

void inOrderTraverse(BSTNode* root) {
	if (root) {
		inOrderTraverse(root->Lchild);
		cout << root->key<<" ";
		inOrderTraverse(root->Rchild);
	}
}

int main(){
    int t;
    cin>>t;
    while(t--){
        int n;
        cin>>n;
        BSTNode*T=create(n);
        inOrderTraverse(T);
        cout<<endl;
        int m;
        cin>>m;
        int z,num;
        while(m--){
            cin>>z;
            Delete_Search(T,z);
            inOrderTraverse(T);
            cout<<endl;
        }
    }
    return 0;
}

引用是个好东西，指针也不能保证确实会返回。

 

当F变化，F->Father->Child因为和它时同一个，所以也直接发生了变化，你第一感觉做的题没有问题，后面想多了

 

 

 

数据结构 | 第八章 查找
Leonadoice的博客
08-02 408
八、 查找 　　 (一) 查找的基本概念 　　 (二) 顺序查找法 (三) 折半查找法 (四) 动态查找表 二叉排序树 　 　2. 平衡二叉树 B-树及其基本操作 (五) 哈希(Hash)表 　 　(六) 查找算法的分析及应用 ...
二叉排序树的实现c语言,二叉排序树的C语言实现
weixin_28881787的博客
05-20 508
出现的问题莫名其妙#include#includetypedefintKeyType;typedefstructnode{KeyTypekey;structnode*lchild,*rchild;}BSTNode;typedefBSTNode*BSTree;//二叉排序树插...出现的问题莫名其妙#include #include typedef int KeyType;typedef struc...
数据结构274：中序遍历二叉排序树
退堂鼓演奏家
05-26 2209
问题描述 输入一整数序列，建立二叉排序树，然后中序遍历。 输入说明 输入第一行为整数的个数n，第二行是具体的n个整数。 输出说明 建立二叉排序树，然后输出中序遍历的结果。 输入样例 5 1 6 5 9 8 输出样例 1 5 6 8 9 #include<stdio.h> #include<stdlib.h> typedef struct node { int key; struct node *lchild,*rchild; }bst; bst *root; bst *inser
二叉树的实现
qq_45692857的博客
04-19 202
一.二叉排序树的结点类型 typedef int KeyType; typedef struct node { KeyType key; //关键字项 　 InfoType data; //其他数据域 struct node *lchild,*rchild; //左右孩子指针 } BSTNode;...
eq()方法
丑娘娘不丑
07-07 1206
eq()方法将匹配元素集缩减值指定index上的一个。 语法：.eq(index) 参数：index是整数，只是元素的位置（最小为0）。如果是负数，则从集合中的最后一个元素往回计数。 详细说明： 如果给定表示DOM元素集合的jQuery对象，eq()方法会用集合中的一个元素构造一个新的jQuery对象。所使用的index参数标示集合中元素的位置。 如果无法根据指定的index参数找到元素
二叉排序树（二叉查找树、二叉搜索树）（图解+完整代码）
weixin_54186646的博客
04-25 10万+
图解二叉排序树（二叉查找树、二叉搜索树）的插入操作、查找操作、删除操作以及完整的代码实现
数据结构：二叉排序树
Jocab_jl的博客
03-15 1658
1、二叉排序树 二叉排序树：BST( Binary Sort( Search)Tree，又称二叉查找树（Binary Search Tree），亦称二叉搜索树。对于二叉排序树的任何一个非叶子节点，要求左子节点的值比当前节点的值小，右子节点的值比当前节点的值大。 特别说明：如果有相同的值,可以将该节点放在左子节点或右子节点 比如针对前面的数据(7,3,10,12,5,1,9),对应的二叉排序树为： 2、二叉排序树的创建和遍历 一个数组创建成对应的二叉排序树，并使用中序遍历二叉排序树，比如：数组为Aray(7
二叉排序树_17281183_刘梦婷_leavingtbk_二叉排序树_
10-01
二叉排序树，又称二叉查找树或二叉搜索树，是一种特殊的二叉树数据结构，它具有以下特性：对于树中的每个节点，其左子树中的所有节点的值都小于该节点的值，而右子树中的所有节点的值都大于该节点的值。这种性质使得...
实现二叉排序树的各种算法
07-25
二叉排序树（Binary Sort Tree，BST），也称为二叉查找树或二叉搜索树，是一种自平衡的二叉树数据结构，它在处理搜索、插入和删除操作时具有较高的效率。二叉排序树的主要特性是：对于任意节点，其左子树中的所有...
二叉排序树的实现与基本操作
08-31
二叉排序树（Binary Sort Tree，BST），又称为二叉查找树，是一种特殊的二叉树数据结构，其每个节点都遵循以下三个关键性质： 1. 左子树上的所有节点的值都小于当前节点的值。 2. 右子树上的所有节点的值都大于当前...
二叉树，中序遍历+后序遍历输出前序遍历
Phoenix0z的博客
12-14 1195
引用： https://blog.youkuaiyun.com/m0_37698652/article/details/79218014 #include &lt;iostream&gt; #include &lt;string&gt; using namespace std; struct TreeNode { struct TreeNode* left; struct TreeNode* ri...
c++中栈stack、queue的使用
Phoenix0z的博客
10-14 777
包含头文件 #include&lt;stack&gt;  和命名空间 using namespace std 定义一个栈的语句：stack&lt;int&gt; stackOne，则： 入栈操作：int number = 3; stackOne.push(number); 出栈操作：stackOne.pop(); 获取栈顶元素：stackOne.top(); 判断栈是否为空：stackO...
数据结构串的应用，实验
Phoenix0z的博客
10-14 684
#include&lt;iostream&gt; #include&lt;string.h&gt; using namespace std; const int MAXNUM = 1000; int main() { int t; cin &gt;&gt; t; char chars[MAXNUM]; char chart[MAXNUM]; while (t--) { memset...
最小树
Phoenix0z的博客
11-13 625
#include&lt;iostream&gt; #include&lt;string&gt; using namespace std; const int Max=20; const int Mlen=9999; struct zp{ int k; int value; }; struct ma{ int h1; int h2; int v; }; zp mar[...
数据结构 二叉树《c++版》
Phoenix0z的博客
10-15 372
二叉树节点BinNode模板类 #define BinNodePosi(T) BinNode&lt;T&gt; * //节点位置 #define stature(p) ((p) ? (p)-&gt;height : -1) //节点高度（与“空树高度为-1”的约定相统一） typedef enum { RB_RED, RB_BLACK } RBColor; //节点颜色 template &...
复习：DS顺序表插入删除查找
Phoenix0z的博客
12-22 342
#include&lt;iostream&gt; using namespace std; const MaxLen=1000; struct SeqList{ int*list; int Len; }Se; void insert(int i,Se&amp;se,int item){ if(i&lt;1||i&gt;Len+1){ cout&lt;&lt;"error"&lt;&...
C语言实现二叉排序树
"这篇文章主要介绍了如何使用C语言实现二叉排序树（Binary Search Tree, BST）。二叉排序树是一种特殊的数据结构，具有左子节点小于父节点、右子节点大于父节点的特性，使得查找、插入和删除操作的平均时间复杂度...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值