Question

我正在研究一种算法，用于从二叉搜索树中删除具有给定键的节点。到目前为止，我已经能够提出以下代码：

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <time.h>

typedef int ElType;

typedef struct Tree {
    ElType key;
    struct Tree *left;
    struct Tree *right;
    struct Tree *parent;
} Tree;

Tree* InsertBST(Tree* t, int k)
{
    if (t == NULL) {
        Tree* w = (Tree*) malloc(sizeof(Tree));
        w->key = k;
        w->left = NULL;
        w->right = NULL;
        w->parent = NULL;
        return w;
    }

    if (k <= t->key) {
        t->left = InsertBST(t->left, k);
        t->left->parent = t;
    }
    else {
        t->right = InsertBST(t->right, k);
        t->right->parent = t;
    }

    return t;
}

Tree* DeleteMaxOfBST(Tree* t, ElType *deleted_value)
{
    if (t == NULL) {
        *deleted_value = -1;
        return NULL;
    }

    if (t->right == NULL) {
        *deleted_value = t->key;
        Tree* w = t->left;
        w->parent = t->parent;
        free(t);
        return w;
    }

    t->right = DeleteMaxOfBST(t->right, deleted_value);
    return t;
}

Tree* DeleteNodeOfBST(Tree* t, int k)
{
    if (t == NULL) return NULL;

    if (k < t->key) {
        t->left = DeleteNodeOfBST(t->left, k);
        return t;
    }
    else if (k > t->key) {
        t->right = DeleteNodeOfBST(t->right, k);
        return t;
    }
    else if (t->left == NULL) {
        Tree* w = t->right;
        w->parent = t->parent;
        free(t);
        return w;
    }
    else {
        ElType max_left;
        t->left = DeleteMaxOfBST(t->left, &max_left);
        t->key = max_left;
        return t;
    }
}

一般的想法是我想使用带有父节点指针的BST，并且能够在保留BST结构的同时删除我指定的任何键的节点。

我的代码适用于某些树中的某些键，但是其他键没有任何明显的模式会崩溃。然后我得到以下错误：

Segmentation fault (core dumped)

我倾向于认为我搞砸了指向父节点的指针，但无法确定故障的位置。我是C的新手，所以我很感激任何评论，指针是否实际上是这里的问题，以及如何解决这个问题。

Answer 1

因此，如果没有任何关于代码如何运行的示例，很难说程序运行时确切的分段错误发生在哪里。当您的程序遇到分段错误，这意味着程序正在尝试访问内存，无论出于何种原因，它都无法访问。这通常意味着你的指针试图指向内存中不应该存在的地址。

我的建议是逐步运行代码并查看问题发生的位置。或者找到一个可以显示程序存在的内存问题的调试器。我知道Valgrind程序适用于Ubuntu和其他Linux最佳机器，但我不确定其他操作系统可以使用其他操作系统。您可以在此处阅读有关Valgrind的更多信息：http://valgrind.org/。每当我需要检查程序中潜在的内存处理问题时，我都会使用它。

除此之外，只需密切关注使用malloc创建的空间，以及指针指向的位置。删除给定节点时，请确保正确地重新连接树。手动处理记忆可能会很痛苦，但你会对它有所了解。

Answer 2

以下是二进制搜索树递归中插入和删除C程序的源代码..................

 /*  C Program for Insertion and Deletion in Binary Search Tree Recursive  */

#include<stdio.h>
#include<stdlib.h>

struct node
{
    struct node *lchild;
    int info;
    struct node *rchild;
};

struct node *insert(struct node *ptr, int ikey);
void display(struct node *ptr,int level);
struct node *del(struct node *ptr, int dkey);

int main( )
{
    struct node *root=NULL,*ptr;
    int choice,k;
    while(1)
    {
        printf("\n");
        printf("1.Insert\n");
        printf("2.Delete\n");
        printf("3.Display\n");
        printf("4.Quit\n");
        printf("\nEnter your choice : ");
        scanf("%d",&choice);

        switch(choice)
        {
        case 1:
            printf("Enter the key to be inserted : ");
            scanf("%d",&k);
            root = insert(root, k);
            break;
        case 2:
            printf("Enter the key to be deleted : ");
            scanf("%d",&k);
            root = del(root,k);
            break;
         case 3:
             display(root,0);
             break;
         case 4:
            exit(1);
         default:
            printf("\nWrong choice\n");
        }/*End of switch */
    }/*End of while */

    return 0;

}/*End of main( )*/

struct node *insert(struct node *ptr, int ikey )
{
    if(ptr==NULL)
    {
        ptr = (struct node *) malloc(sizeof(struct node));
        ptr->info = ikey;
        ptr->lchild = NULL;
        ptr->rchild = NULL;
    }
    else if(ikey < ptr->info)   /*Insertion in left subtree*/
        ptr->lchild = insert(ptr->lchild, ikey);
    else if(ikey > ptr->info)   /*Insertion in right subtree */
        ptr->rchild = insert(ptr->rchild, ikey);
    else
        printf("\nDuplicate key\n");
    return ptr;
}/*End of insert( )*/

void display(struct node *ptr,int level)
{
    int i;
    if(ptr == NULL )/*Base Case*/
        return;
    else
    {
        display(ptr->rchild, level+1);
        printf("\n");
        for (i=0; i<level; i++)
            printf("    ");
        printf("%d", ptr->info);
        display(ptr->lchild, level+1);
    }

       printf("\n");

}/*End of display()*/


struct node *del(struct node *ptr, int dkey)
{
    struct node *tmp, *succ;

    if( ptr == NULL)
    {
        printf("dkey not found\n");
        return(ptr);
    }
    if( dkey < ptr->info )/*delete from left subtree*/
        ptr->lchild = del(ptr->lchild, dkey);
    else if( dkey > ptr->info )/*delete from right subtree*/
        ptr->rchild = del(ptr->rchild, dkey);
    else
    {
        /*key to be deleted is found*/
        if( ptr->lchild!=NULL  &&  ptr->rchild!=NULL )  /*2 children*/
        {
            succ=ptr->rchild;
            while(succ->lchild)
                succ=succ->lchild;
            ptr->info=succ->info;
            ptr->rchild = del(ptr->rchild, succ->info);
        }
        else
        {
            tmp = ptr;
            if( ptr->lchild != NULL ) /*only left child*/
                ptr = ptr->lchild;
            else if( ptr->rchild != NULL) /*only right child*/
                ptr = ptr->rchild;
            else    /* no child */
                ptr = NULL;
            free(tmp);
        }
    }
    return ptr;
}/*End of del( )*/

希望它可以帮到你。有关更多详细信息，请访问此处以获取二进制搜索树上的更多操作---＆gt; C Program for Insertion and Deletion in Binary Search Tree Recursive

和C Program for binary search tree deletion without recursion

使用父指针从二叉查找树中删除节点

2 个答案: