我试图编写代码以使用插入排序查找第 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;
}