二叉查找树

二叉查找树

#include <stdio.h>
#include <assert.h>

typedef struct Node {
	int value;
	struct Node* left;
	struct Node* right;
} Node;

Node* insertNode(Node* root, int value);

Node* deleteNode(Node* root, int value);

void printSubtree(Node* N);

int countLeaves(Node* N);

Node* deleteSubtree(Node* root, int value);

int depth(Node* R, Node* N);

Node* insertNode(Node* root, int value) {
	Node *p = root;
	Node *f = root;

	Node* newNode = (Node*)malloc(sizeof(struct Node));
	newNode->value = value;
	newNode->left = NULL;
	newNode->right = NULL;

	while (p) {
		if (p->value == value) {
			return NULL;
		}
		f = p;
		if (p->value > value) {
			p = p->left;
		} else {
			p = p->right;
		}
	}
	if (f == NULL) {
		root = newNode;
	} else if (f->value > value) {
		f->left = newNode;
	} else {
		f->right = newNode;
	}

	return newNode;
}

/*
* Delete rules of node:
* 1. If the node to be deleted has a left subtree, 
*    exchange the largest node in the left subtree with the node before deleting the node.
* 2. If the node to be deleted has only the right subtree, 
*    the smallest node in the right subtree will be exchanged with the node before deleting the node.
* 3. If the node to be deleted is a leaf node, delete it directly.
*/

Node* deleteNode(Node* root, int value) {
	if (root == NULL) {
		return root;
	} else if (root->value > value) {
		root->left = deleteNode(root->left, value);
	} else if (root->value < value) {
		root->right = deleteNode(root->right, value);
	} else {
		Node* tmp;
		if (root->left != NULL) {
			for (tmp = root->left; tmp->right != NULL; tmp = tmp->right);

			int t = root->value;
			root->value = tmp->value;
			tmp->value = t;

			root->left = deleteNode(root->left, tmp->value);
		} else if (root->right != NULL) {
			for (tmp = root->right; tmp->left != NULL; tmp = tmp->left);

			int t = root->value;
			root->value = tmp->value;
			tmp->value = t;

			root->right = deleteNode(root->right, tmp->value);
		} else {
			free(root);
			return NULL;
		}
	}
	return root;
}

void printSubtree(Node* N) {
	if (N == NULL) {
		return;
	}
	printSubtree(N->left);
	printf("%d\n", N->value);
	printSubtree(N->right);
}

int countLeaves(Node* N) {
	if (N == NULL) return 0;
	else if (N->left == NULL && N->right == NULL) return 1;
	return countLeaves(N->left) + countLeaves(N->right);
}

Node* deleteSubtree(Node* root, int value) {
	if (root == NULL) {
		return root;
	} else if (root->value > value) {
		root->left = deleteSubtree(root->left, value);
	} else if (root->value < value) {
		root->right = deleteSubtree(root->right, value);
	} else {
		root = NULL;
	}
	return root;
}

int depth(Node* R, Node* N) {
	int d = 0;
	Node* tmp = R;
	if (tmp == N) return 0;
	else if (tmp == NULL || N == NULL) return -1;
	else {
		while (tmp->value != N->value) {
			if (tmp->value > N->value) {
				if (tmp->left != NULL) {
					tmp = tmp->left;
					d++;
				} else {
					return -1;
				}

			}
			if (tmp->value < N->value) {
				if (tmp->right != NULL) {
					tmp = tmp->right;
					d++;
				} else {
					return -1;
				}

			}
		}
	}
	return d;
}

int main() {
	Node *a, *b;
	a = insertNode(NULL, 42);
	b = deleteNode(a, 42);
	assert(b == NULL);

	a = insertNode(NULL, 1);
	b = insertNode(a, 2);

	printSubtree(a);
	int c = countLeaves(a);
	assert(c == 1);

	c = depth(a, b);
	assert(c == 1);

	a = deleteSubtree(a, 2);

	Node *test;
	int num[12] = {23, 16, 45, 3, 22, 37, 99, 35, 40, 38, 44, 39};
	test = insertNode(NULL, 23);

	for (int i = 1; i < 12; i++) {
		insertNode(test, num[i]);
	}

	printSubtree(test);
	assert(countLeaves(test) == 6);
	
	Node *test1;
	test1 = insertNode(NULL, 39);
	assert(depth(test, test1) == 5);

	return 0;
}