C 使用插入排序查找第k个最小元素

我试图编写代码，使用插入排序查找第k个最小的元素，但代码中出现运行时错误。 在第一行，我们得到了查询数（比如n）和k（要查找的第k个最小数）。然后给我们n个数字，如果我们遇到-1，我们需要打印到目前为止遇到的第k个最小数字（除了前面的-1）

我试着在根据问题稍加修改后使用

（我没有发布代码，因为它足够长，任何人都可以通读&这个问题不是家庭作业） 有人能告诉我需要编辑吗

好的，我发布我的代码：-

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

#define ARRAY_SIZE(arr) sizeof(arr)/sizeof(arr[0])

/* just add elements to test */
/* NOTE: A sorted array results in skewed tree */
int ele[] = { 20, 8, 22, 4, 12, 10, 14 };

/* same alias */
typedef struct node_t node_t;

/* Binary tree node */
struct node_t
{
    int data;

    node_t* left;
    node_t* right;
};

/* simple stack that stores node addresses */
typedef struct stack_t stack_t;

/* initial element always NULL, uses as sentinal */
struct stack_t
{
    node_t*  base[ARRAY_SIZE(ele) + 1];
    int      stackIndex;
};

/* pop operation of stack */
node_t *pop(stack_t *st)
{
    node_t *ret = NULL;

    if( st && st->stackIndex > 0 )
    {
        ret = st->base[st->stackIndex];
        st->stackIndex--;
    }

    return ret;
}

/* push operation of stack */
void push(stack_t *st, node_t *node)
{
    if( st )
    {
        st->stackIndex++;
        st->base[st->stackIndex] = node;
    }
}

/* Iterative insertion
   Recursion is least preferred unless we gain something
*/
node_t *insert_node(node_t *root, node_t* node)
{
    /* A crawling pointer */
    node_t *pTraverse = root;
    node_t *currentParent = root;

    // Traverse till appropriate node
    while(pTraverse)
    {
        currentParent = pTraverse;

        if( node->data < pTraverse->data )
        {
            /* left subtree */
            pTraverse = pTraverse->left;
        }
        else
        {
            /* right subtree */
            pTraverse = pTraverse->right;
        }
    }

    /* If the tree is empty, make it as root node */
    if( !root )
    {
        root = node;
    }
    else if( node->data < currentParent->data )
    {
        /* Insert on left side */
        currentParent->left = node;
    }
    else
    {
        /* Insert on right side */
        currentParent->right = node;
    }

    return root;
}

/* Elements are in an array. The function builds binary tree */
node_t* binary_search_tree(node_t *root, int keys[], int const size)
{
    int iterator;
    node_t *new_node = NULL;

    for(iterator = 0; iterator < size; iterator++)
    {
        new_node = (node_t *)malloc( sizeof(node_t) );

        /* initialize */
        new_node->data   = keys[iterator];
        new_node->left   = NULL;
        new_node->right  = NULL;

        /* insert into BST */
        root = insert_node(root, new_node);
    }

    return root;
}

node_t *k_smallest_element_inorder(stack_t *stack, node_t *root, int k)
{
    stack_t *st = stack;
    node_t *pCrawl = root;

    /* move to left extremen (minimum) */
    while( pCrawl )
    {
        push(st, pCrawl);
        pCrawl = pCrawl->left;
    }

    /* pop off stack and process each node */
    while( pCrawl = pop(st) )
    {
        /* each pop operation emits one element
           in the order
        */
        if( !--k )
        {
            /* loop testing */
            st->stackIndex = 0;
            break;
        }

        /* there is right subtree */
        if( pCrawl->right )
        {
            /* push the left subtree of right subtree */
            pCrawl = pCrawl->right;
            while( pCrawl )
            {
                push(st, pCrawl);
                pCrawl = pCrawl->left;
            }

            /* pop off stack and repeat */
        }
    }

    /* node having k-th element or NULL node */
    return pCrawl;
}

/* Driver program to test above functions */
int main(void)
{
    int n,k,elec=0,tmp;
    scanf("%d",&n);
    scanf("%d",&k);
    while (n--) {
          scanf("%d",&tmp);
          if (tmp!=-1) {
             ele[elec]=tmp;
             elec++;
          } else {
    node_t* root = NULL;
    stack_t stack = { {0}, 0 };
    node_t *kNode = NULL;


    /* Creating the tree given in the above diagram */
    root = binary_search_tree(root, ele, ARRAY_SIZE(ele));

    kNode = k_smallest_element_inorder(&stack, root, k);

    if( kNode )
    {
        printf("%d\n",kNode->data);
    }
    }}
    return 0;
}

#包括
#包括
#定义数组大小（arr）sizeof（arr）/sizeof（arr[0]）
/*只需添加测试元素即可*/
/*注意：排序的数组会导致树倾斜*/
int ele[]={20,8,22,4,12,10,14}；
/*同一别名*/
类型定义结构节点；
/*二叉树节点*/
结构节点
{
int数据；
节点_t*左；
节点_t*右；
};
/*存储节点地址的简单堆栈*/
类型定义结构堆栈；
/*初始元素始终为NULL，用作sentinal*/
结构堆栈
{
node_t*base[数组大小（ele）+1]；
int-stackIndex；
};
/*堆栈的pop操作*/
节点\u t*pop（堆栈\u t*st）
{
node_t*ret=NULL；
如果（st&&st->stackIndex>0）
{
ret=st->base[st->stackIndex]；
st->stackIndex--；
}
返回ret；
}
/*堆栈的推操作*/
无效推送（堆栈、节点）
{
if（st）
{
st->stackIndex++；
st->base[st->stackIndex]=节点；
}
}
/*迭代插入
除非我们得到一些东西，否则递归是最不可取的
*/
节点\u t*插入节点（节点\u t*根，节点\u t*节点）
{
/*爬行指针*/
node_t*pTraverse=root；
节点\u t*currentParent=根；
//遍历到适当的节点
while（pTraverse）
{
currentParent=pTraverse；
如果（节点->数据数据）
{
/*左子树*/
pTraverse=pTraverse->left；
}
其他的
{
/*右子树*/
pTraverse=pTraverse->right；
}
}
/*如果树为空，则将其设为根节点*/
如果（！root）
{
根=节点；
}
else if（节点->数据<当前父节点->数据）
{
/*在左侧插入*/
currentParent->left=节点；
}
其他的
{
/*插入右侧*/
currentParent->right=节点；
}
返回根；
}
/*元素在一个数组中。该函数用于构建二叉树*/
node_t*二进制搜索树（node_t*根，int key[]，int const size）
{
整数迭代器；
node_t*new_node=NULL；
for（迭代器=0；迭代器数据=键[迭代器]；
新建_节点->左=空；
新建_节点->右=空；
/*插入BST*/
根=插入_节点（根，新_节点）；
}
返回根；
}
节点\u t*k\u最小元素\u顺序（堆栈\u t*stack，节点\u t*root，int k）
{
stack_t*st=stack；
node_t*pCrawl=根；
/*移动到左端（最小值）*/
while（pCrawl）
{
推（st，pCrawl）；
pCrawl=pCrawl->左；
}
/*弹出堆栈并处理每个节点*/
而（pCrawl=pop（st））
{
/*每个pop操作发射一个元素
按顺序
*/
if（！--k）
{
/*回路测试*/
st->stackIndex=0；
打破
}
/*有右子树*/
如果（绘制->右侧）
{
/*推动右子树的左子树*/
pCrawl=pCrawl->右侧；
while（pCrawl）
{
推（st，pCrawl）；
pCrawl=pCrawl->左；
}
/*跳出堆栈并重复*/
}
}
/*具有第k个元素或空节点的节点*/
返回pCrawl；
}
/*用于测试上述功能的驱动程序*/
内部主（空）
{
int n，k，elec=0，tmp；
scanf（“%d”和“&n”）；
scanf（“%d”和“&k”）；
而（n--）{
scanf（“%d”和tmp）；
如果（tmp！=-1）{
ele[elec]=tmp；
elec++；
}否则{
node_t*root=NULL；
stack_t stack={{0}，0}；
node_t*kNode=NULL；
/*创建上图中给出的树*/
根=二进制搜索树（根、元素、数组大小（元素））；
kNode=k_最小元素_顺序（&stack，root，k）；
if（kNode）
{
printf（“%d\n”，旋钮->数据）；
}
}}
返回0；
}

所以您不想显示引发运行时错误的代码。。。你认为任何人都能猜出发生了什么？？？每当你遇到运行时错误或“崩溃”时，你的第一反应应该是在调试器中运行你的程序。它将帮助您定位错误的位置，还可以让您检查变量，以查看可能导致错误的原因。至于不发布代码，请参阅。如果没有其他内容，您不必发布所有代码，只需发布给您带来麻烦的代码，以及理解它所需的任何声明。