二叉树排序中实现查找算法c语言,算法_数据结构二叉树(排序的)插入、查找、删除代码...

二叉树的关键概念：

每个节点是一个自引用结构体，形式如下：

struct TreeNode {

struct TreeNode *leftPtr;

int data;

struct TreeNode *rightPtr;

};

部节点开始，每个节点拥有两个子节点(NULL或者一个节点)，称为左节点与右节点，每个节点的左部分与右部分又分别称为该节点的左子树与右子树。

每个节点的键值大于左节点，小于右节点；每个节点的键值大于左子树所有节点的键值，小于右子树所有节点的键值。所以二叉树是按节点键值排序的数据结构。

二叉树的某个节点，如果不是叶节点，则有左子树或右子树，是一个更小的树，因此可以递归地处理关于树的一些问题。

二叉树的插入

思路：将要插入节点的键值与根节点键值比较，如果小于根节点键值，则插入根节点的左子树，如果大于根节点的键值，则插入根节点的右子树，插入子树相当于插入一个更小的树，因此可以用递归方法实现，直到找到没有子树的节点，将新节点插到其下面。注意，新节点插入后，最终只会成为叶节点。

函数代码如下(测试插入、删除、打印功能的源码在最后面，此处只给出插入函数代码)：

void insertNode(TreeNodePtr *treePtr, int value)

{

if (*treePtr == NULL) {

*treePtr = malloc(sizeof(TreeNode));

if (*treePtr != NULL) {

(*treePtr)->data = value;

(*treePtr)->leftPtr = NULL;

(*treePtr)->rightPtr = NULL;

}

else {

printf("%d not inserted. No memory available.\n", value);

}

}

else {

if (value < (*treePtr)->data) {

insertNode(&((*treePtr)->leftPtr), value);

}

else {

if (value >(*treePtr)->data) {

insertNode(&((*treePtr)->rightPtr), value);

}

else {

printf("dup");

}

}

}

}

1

二叉树的查找

思路：与插入类似，从根节点开始，将查找的键值与根节点键值比较，若相等，则返回指向该节点的指针，若查找的键值比它大，则从根节点的右子树开始查找，若查找的键值比它小，则从根节点的左子树开始查找。可以用递归方法实现，类似于插入。这里我用迭代实现，能用迭代还是用迭代，因为递归开销比较大。

函数代码如下：

TreeNode *binaryTreeSereach(TreeNode * const treePtr, int value)

{

TreeNode *tempPtr = treePtr;

while (tempPtr != NULL && tempPtr->data != value)

{

if (value > tempPtr->data)

tempPtr = tempPtr->rightPtr;

else

tempPtr = tempPtr->leftPtr;

}

return tempPtr;

}

1

2

3

4

二叉树的删除

相比于二叉树的插入和查找，删除一个节点要复杂一些，原因是要保证二叉树的排序性质。二叉树删除有如下三种情况：

1.

删除节点是叶节点，即没有子节点，或者说左右子节点都是NULL。这种情况下，只需要把删除节点的父节点中对应的指针指向NULL即可。然后释放掉删除节点的空间。

2.

删除节点有一个子节点(左子节点或右子节点)，这种情况下，把删除节点的父节点中对应的指针指向删除节点的子节点即可。然后释放掉删除节点的空间

3.

删除节点有两个子节点，这种情况下，必须要找到一个替代删除节点的替代节点，并且保证二叉树的排序性。根据二叉树的排序性，可知替代节点的键值必须最接近删除节点键值。比删除节点键值小的所有键值中最大那个，或者是比删除节点键值大的所有键值中最小的那个，是符合要求的。这两个键值所在的节点分别在删除节点的左子树中最右边的节点，删除节点右子树中最左边的节点。以从左子树中找最大键值节点为例，算法如下：

找到删除节点以及它的父节点

在删除节点的左子树中，向下向右遍历，找到替代节点以及它的父节点

删除节点的父节点中对应的指针指向替代节点

替代节点中的右子节点指针指向删除节点的右子树

如果替代节点的父节点不是删除节点，则将替代节点的左子节点指针指向删除节点的左子树，并且替代节点的父节点中对应的指针指向替代节点的左子节点

释放删除节点的空间 注意：第二步中找到的替代节点，可能会有左子树，但一定没有右子树。第五步要判断替代节点的父节点不是删除节点后，才将替代节点的左子节点指针指向删除节点的左子树，否则会出现替代节点左子节点指针指向自己的情况，从而丢失替代节点的左子树。

另外，还有一种实现相同效果的的方法，即将替代节点中的数据赋给删除节点，然后释放替代节点的空间。这种方法其实是删除了替代节点，并没有真正删除想要删除的节点。而且如果节点包括一个键值和很多其他的数据，则赋值语句会很多。在最后面的测试过程中，我也给出了这个函数的实现，void

deleteNode2(TreeNode **treePtrP, int value)

代码如下：

void deleteNode(TreeNode **treePtrP, int value)

{

TreeNode *deleteNodePtr = *treePtrP;

TreeNode *parentNodeOfDeletePtr = NULL;

TreeNode *substituteNodePtr;

TreeNode *parentNodeOfSubstitutePtr;

//find deleNode and its parentNode

while (deleteNodePtr != NULL && value != deleteNodePtr->data)

{

parentNodeOfDeletePtr = deleteNodePtr;

if (deleteNodePtr->data > value)

{

deleteNodePtr = deleteNodePtr->leftPtr;

}

else

{

deleteNodePtr = deleteNodePtr->rightPtr;

}

}

//case that can't find such Node

if (deleteNodePtr == NULL)

{

printf("no such Node, delete fail\n\n");

return;

}

//delete a leafNode

if (deleteNodePtr->leftPtr == NULL && deleteNodePtr->rightPtr == NULL)

{

//delete Node is root

if (parentNodeOfDeletePtr == NULL)

{

*treePtrP = NULL;

}

else if (parentNodeOfDeletePtr->leftPtr == deleteNodePtr)

{

parentNodeOfDeletePtr->leftPtr = NULL;

}

else

{

parentNodeOfDeletePtr->rightPtr = NULL;

}

}

//delete a Node which has a left child Node

else if (deleteNodePtr->leftPtr != NULL && deleteNodePtr->rightPtr == NULL)

{

//delete Node is root

if (parentNodeOfDeletePtr == NULL)

{

*treePtrP = deleteNodePtr->leftPtr;

}

else if (parentNodeOfDeletePtr->rightPtr == deleteNodePtr)

parentNodeOfDeletePtr->rightPtr = deleteNodePtr->leftPtr;

else

parentNodeOfDeletePtr->leftPtr = deleteNodePtr->leftPtr;

}

//delete a Node which has a right child Node

else if (deleteNodePtr->leftPtr == NULL && deleteNodePtr->rightPtr != NULL)

{

//delete Node is root

if (parentNodeOfDeletePtr == NULL)

{

*treePtrP = deleteNodePtr->rightPtr;

}

else if (parentNodeOfDeletePtr->rightPtr == deleteNodePtr)

parentNodeOfDeletePtr->rightPtr = deleteNodePtr->rightPtr;

else

parentNodeOfDeletePtr->leftPtr = deleteNodePtr->rightPtr;

}

//delete a Node which has a left and a right child Node

else

{

parentNodeOfSubstitutePtr = deleteNodePtr;

substituteNodePtr = deleteNodePtr->leftPtr;

//search down and right to find substituteNode and its parentNode

while (substituteNodePtr->rightPtr != NULL)

{

parentNodeOfSubstitutePtr = substituteNodePtr;

substituteNodePtr = substituteNodePtr->rightPtr;

}

//delete Node is root

if (parentNodeOfDeletePtr == NULL)

{

*treePtrP = substituteNodePtr;

}

else if (parentNodeOfDeletePtr->leftPtr == deleteNodePtr)

{

parentNodeOfDeletePtr->leftPtr = substituteNodePtr;

}

else

{

parentNodeOfDeletePtr->rightPtr = substituteNodePtr;

}

substituteNodePtr->rightPtr = deleteNodePtr->rightPtr;

if (parentNodeOfSubstitutePtr != deleteNodePtr)

{

substituteNodePtr->leftPtr = deleteNodePtr->leftPtr;

if (parentNodeOfSubstitutePtr->leftPtr == substituteNodePtr)

{

parentNodeOfSubstitutePtr->leftPtr = substituteNodePtr->leftPtr;

}

else

{

parentNodeOfSubstitutePtr->rightPtr = substituteNodePtr->leftPtr;

}

}

}

free(deleteNodePtr);

}

二叉树的打印

从根节点开始，先输出右子树，再输出节点键值，再输出左子树。采用递归法 代码如下：

void outputTree(TreeNodePtr treePtr, int spaces)

{

int loop;

while (treePtr != NULL) {

outputTree(treePtr->rightPtr, spaces + 4);

for (loop = 1; loop <= spaces; loop++) {

printf(" ");

}

printf("%d\n", treePtr->data);

outputTree(treePtr->leftPtr, spaces + 4);

treePtr = NULL;

}

}

1

2

3

4

5

6

测试结果截图

测试插入、删除、打印树源码

#include

#include

#include

struct TreeNode {

struct TreeNode *leftPtr;

int data;

struct TreeNode *rightPtr;

};

typedef struct TreeNode TreeNode;

void insertNode(TreeNode **treePtr, int value);

TreeNode * binaryTreeSereach(TreeNode * const treePtr, int value);

void deleteNode(TreeNode **treePtrP, int value);

void outputTree(TreeNode *treePtr, int spaces);

void deleteNode2(TreeNode **treePtrP, int value);

int main(void)

{

int arr[] = { 45, 83, 28, 97, 71, 40, 18, 77, 99, 92, 72, 69, 44, 32, 19, 11 };

int i;

int item;

int totalSpaces = 0;

TreeNode *rootPtr = NULL;

srand(time(NULL));

printf("The numbers being placed in the tree are:\n\n");

for (i = 0; i < sizeof(arr) / sizeof(int); i++) {

item = arr[i];

printf("=", item);

insertNode(&rootPtr, item);

}

printf("\n\n\nnow the tree is:\n\n");

if (rootPtr == NULL)

printf("empty tree\n");

else

outputTree(rootPtr, totalSpaces);

//random delete Nodes, then output the tree

while (rootPtr != NULL)

{

item = rand() % 16;

printf("\n\nafter delete %d:\n\n", arr[item]);

deleteNode2(&rootPtr, arr[item]);

if (rootPtr == NULL)

printf("empty tree\n");

else

outputTree(rootPtr, totalSpaces);

}

return 0;

}

void insertNode(TreeNode **treePtr, int value)

{

if (*treePtr == NULL) {

*treePtr = malloc(sizeof(TreeNode));

if (*treePtr != NULL) {

(*treePtr)->data = value;

(*treePtr)->leftPtr = NULL;

(*treePtr)->rightPtr = NULL;

}

else {

printf("%d not inserted. No memory available.\n", value);

}

}

else {

if (value < (*treePtr)->data) {

insertNode(&((*treePtr)->leftPtr), value);

}

else {

if (value >(*treePtr)->data) {

insertNode(&((*treePtr)->rightPtr), value);

}

else {

printf("dup");

}

}

}

}

TreeNode *binaryTreeSereach(TreeNode * const treePtr, int value)

{

TreeNode *tempPtr = treePtr;

while (tempPtr != NULL && tempPtr->data != value)

{

if (value > tempPtr->data)

tempPtr = tempPtr->rightPtr;

else

tempPtr = tempPtr->leftPtr;

}

return tempPtr;

}

void deleteNode(TreeNode **treePtrP, int value)

{

TreeNode *deleteNodePtr = *treePtrP;

TreeNode *parentNodeOfDeletePtr = NULL;

TreeNode *substituteNodePtr;

TreeNode *parentNodeOfSubstitutePtr;

//find deleNode and its parentNode

while (deleteNodePtr != NULL && value != deleteNodePtr->data)

{

parentNodeOfDeletePtr = deleteNodePtr;

if (deleteNodePtr->data > value)

{

deleteNodePtr = deleteNodePtr->leftPtr;

}

else

{

deleteNodePtr = deleteNodePtr->rightPtr;

}

}

//case that can't find such Node

if (deleteNodePtr == NULL)

{

printf("no such Node, delete fail\n\n");

return;

}

//delete a leafNode

if (deleteNodePtr->leftPtr == NULL && deleteNodePtr->rightPtr == NULL)

{

//delete Node is root

if (parentNodeOfDeletePtr == NULL)

{

*treePtrP = NULL;

}

else if (parentNodeOfDeletePtr->leftPtr == deleteNodePtr)

{

parentNodeOfDeletePtr->leftPtr = NULL;

}

else

{

parentNodeOfDeletePtr->rightPtr = NULL;

}

}

//delete a Node which has a left child Node

else if (deleteNodePtr->leftPtr != NULL && deleteNodePtr->rightPtr == NULL)

{

//delete Node is root

if (parentNodeOfDeletePtr == NULL)

{

*treePtrP = deleteNodePtr->leftPtr;

}

else if (parentNodeOfDeletePtr->rightPtr == deleteNodePtr)

parentNodeOfDeletePtr->rightPtr = deleteNodePtr->leftPtr;

else

parentNodeOfDeletePtr->leftPtr = deleteNodePtr->leftPtr;

}

//delete a Node which has a right child Node

else if (deleteNodePtr->leftPtr == NULL && deleteNodePtr->rightPtr != NULL)

{

//delete Node is root

if (parentNodeOfDeletePtr == NULL)

{

*treePtrP = deleteNodePtr->rightPtr;

}

else if (parentNodeOfDeletePtr->rightPtr == deleteNodePtr)

parentNodeOfDeletePtr->rightPtr = deleteNodePtr->rightPtr;

else

parentNodeOfDeletePtr->leftPtr = deleteNodePtr->rightPtr;

}

//delete a Node which has a left and a right child Node

else

{

parentNodeOfSubstitutePtr = deleteNodePtr;

substituteNodePtr = deleteNodePtr->leftPtr;

//search down and right to find substituteNode and its parentNode

while (substituteNodePtr->rightPtr != NULL)

{

parentNodeOfSubstitutePtr = substituteNodePtr;

substituteNodePtr = substituteNodePtr->rightPtr;

}

//delete Node is root

if (parentNodeOfDeletePtr == NULL)

{

*treePtrP = substituteNodePtr;

}

else if (parentNodeOfDeletePtr->leftPtr == deleteNodePtr)

{

parentNodeOfDeletePtr->leftPtr = substituteNodePtr;

}

else

{

parentNodeOfDeletePtr->rightPtr = substituteNodePtr;

}

substituteNodePtr->rightPtr = deleteNodePtr->rightPtr;

if (parentNodeOfSubstitutePtr != deleteNodePtr)

{

substituteNodePtr->leftPtr = deleteNodePtr->leftPtr;

if (parentNodeOfSubstitutePtr->leftPtr == substituteNodePtr)

{

parentNodeOfSubstitutePtr->leftPtr = substituteNodePtr->leftPtr;

}

else

{

parentNodeOfSubstitutePtr->rightPtr = substituteNodePtr->leftPtr;

}

}

}

free(deleteNodePtr);

}

void outputTree(TreeNode *treePtr, int spaces)

{

int loop;

while (treePtr != NULL) {

outputTree(treePtr->rightPtr, spaces + 4);

for (loop = 1; loop <= spaces; loop++) {

printf(" ");

}

printf("%d\n", treePtr->data);

outputTree(treePtr->leftPtr, spaces + 4);

treePtr = NULL;

}

}

void deleteNode2(TreeNode **treePtrP, int value)

{

TreeNode *deleteNodePtr = *treePtrP;

TreeNode *parentNodeOfDeletePtr = NULL;

TreeNode *substituteNodePtr;

TreeNode *parentNodeOfSubstitutePtr;

//find deleNode and its parentNode

while (deleteNodePtr != NULL && value != deleteNodePtr->data)

{

parentNodeOfDeletePtr = deleteNodePtr;

if (deleteNodePtr->data > value)

{

deleteNodePtr = deleteNodePtr->leftPtr;

}

else

{

deleteNodePtr = deleteNodePtr->rightPtr;

}

}

//case that can't find such Node

if (deleteNodePtr == NULL)

{

printf("no such Node, delete fail\n\n");

return;

}

// delete a leafNode

if (deleteNodePtr->leftPtr == NULL && deleteNodePtr->rightPtr == NULL)

{

//delete Node is root

if (parentNodeOfDeletePtr == NULL)

{

*treePtrP = NULL;

}

else if (parentNodeOfDeletePtr->leftPtr == deleteNodePtr)

{

parentNodeOfDeletePtr->leftPtr = NULL;

}

else

{

parentNodeOfDeletePtr->rightPtr = NULL;

}

}

//delete a Node which has a left child Node

else if (deleteNodePtr->leftPtr != NULL && deleteNodePtr->rightPtr == NULL)

{

//delete Node is root

if (parentNodeOfDeletePtr == NULL)

{

*treePtrP = deleteNodePtr->leftPtr;

}

else if (parentNodeOfDeletePtr->rightPtr == deleteNodePtr)

parentNodeOfDeletePtr->rightPtr = deleteNodePtr->leftPtr;

else

parentNodeOfDeletePtr->leftPtr = deleteNodePtr->leftPtr;

}

//delete a Node which has a right child Node

else if (deleteNodePtr->leftPtr == NULL && deleteNodePtr->rightPtr != NULL)

{

//delete Node is root

if (parentNodeOfDeletePtr == NULL)

{

*treePtrP = deleteNodePtr->rightPtr;

}

else if (parentNodeOfDeletePtr->rightPtr == deleteNodePtr)

parentNodeOfDeletePtr->rightPtr = deleteNodePtr->rightPtr;

else

parentNodeOfDeletePtr->leftPtr = deleteNodePtr->rightPtr;

}

//delete a Node which has a left and a right child Node

else

{

//find substituteNode and its parentNode

parentNodeOfSubstitutePtr = deleteNodePtr;

substituteNodePtr = deleteNodePtr->leftPtr;

//search down and right

while (substituteNodePtr->rightPtr != NULL)

{

parentNodeOfSubstitutePtr = substituteNodePtr;

substituteNodePtr = substituteNodePtr->rightPtr;

}

if (parentNodeOfSubstitutePtr->leftPtr == substituteNodePtr)

{

parentNodeOfSubstitutePtr->leftPtr = substituteNodePtr->leftPtr;

}

else

{

parentNodeOfSubstitutePtr->rightPtr = substituteNodePtr->leftPtr;

}

deleteNodePtr->data = substituteNodePtr->data;

deleteNodePtr = substituteNodePtr;

}

free(deleteNodePtr);

}