数转存广义表

save

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

#define NAMESIZE 16
#define FILEPATH "./sava.txt"

typedef struct BiTree_st
{
	char data;
	struct BiTree_st* lchild;
	struct BiTree_st* rchild;
}Tree;

Tree* tree = NULL;

int insert(Tree** t, int data)
{
	Tree* p;
	if (*t == NULL)
	{
		p = (Tree*)malloc(sizeof(*p));
		if (p == NULL)
		{
			return -1;
		}
		p->data = data;
		p->lchild = NULL;
		p->rchild = NULL;
		*t = p;
		return 0;
	}
	else
	{
		if (data <= (*t)->data)
		{
			return insert(&((*t)->lchild), data);
		}
		else
		{
			return insert(&((*t)->rchild), data);
		}
	}
}







void draw_(Tree* t, int level)
{
	if (t == NULL)
		return;
	draw_(t->rchild, level + 1);
	for (int i = 0; i < level; i++)
	{
		printf("    ");
	}
	printf("%c\n", t->data);
	draw_(t->lchild, level + 1);


}


void draw(Tree* t)
{
	draw_(t, 0);
	
}

int getnum(Tree* t)
{
	if (t == NULL)
	{
		return 0;
	}
	printf("----\n");
	return (getnum(t->lchild) + 1 + getnum(t->rchild));

}

static Tree* find_mini(Tree* t)
{
	if (t->lchild == NULL)
		return t;

	return find_mini(t->lchild);


}

void turn_left(Tree** t)
{
	/*
	Tree** p = t;
	*t = (*p)->rchild;
	(*p)->rchild = NULL;
	find_mini(*t)->lchild = *p;
	*/

	Tree* p = *t;
	*t = p->rchild;
	p->rchild = NULL;

	find_mini(*t)->lchild = p;
	draw(tree);
}

static Tree* find_max(Tree* t)
{
	if (t->rchild == NULL)
		return t;

	return find_max(t->rchild);
}

void turn_right(Tree** t)
{
	/*
	Tree** p = t;
	*t = (*p)->lchild;
	(*p)->lchild = NULL;
	find_max(*t)->rchild = *p;
	*/

	Tree* p = *t;
	*t = p->lchild;
	p->lchild = NULL;

	find_max(*t)->rchild = p;
	draw(tree);
}



void banlance(Tree** t)
{
	int sub = 0;
	if (*t == NULL)
		return;

	while (1)
	{
		sub = getnum((*t)->lchild) - getnum((*t)->rchild);
		if (sub >= -1 && sub <= 1)
			break;

		if (sub < -1)
		{
			turn_left(t);
		}
		else
		{
			turn_right(t);
		}

	}

	banlance(&((*t)->lchild));
	banlance(&((*t)->rchild));


}


#if 0

//层序遍历
void travel(Tree* t)
{
	QUEUE* qu;
	Tree cur;
	qu = (QUEUE*)queue_create(sizeof(struct node_st*));

	if (qu == NULL)
		return;
	queue_en(qu, &t);

	while (qu != NULL && t != NULL)
	{
		queue_de(qu, cur);
		print_s(&cur->data);
		if (cur->lchild != NULL)
			queue_en(qu, &cur->lchilde);
		if (cur->rchild != NULL)
		{
			queue_en(qu, &cur->rchilde);
		}

	}

	queue_destroy(qu);

}




#else
//通过遍历实现先序遍历
void travel(Tree* t)
{
	if (t == NULL)
		return;
	printf("%c\n", t->data);
	travel(t->lchild);
	travel(t->rchild);
}

#endif

int save_(Tree* root,FILE* fp)
{
	fputc ('(', fp);

	if (root == NULL)
	{
		fputc(')',fp);
		return 0;
	}

	fputc(root->data, fp);

	save_(root->lchild, fp);
	save_(root->rchild, fp);

	fputc(')', fp);
	return 0;

}

int save(Tree* root, const char* path)
{
	FILE* fp;

	fp = fopen(path, "w");
	if (fp == NULL)
	{
		return -1;
	}

	save_(root, fp);
	return 0;



}




int main()
{
	char arr[] = "cefadjbh";


	for (int i = 0; i < sizeof(arr) / sizeof(*arr)-1; i++)
	{
		insert(&tree, arr[i]);
	}

	draw(tree);
	save(tree, FILEPATH);





#if 0
	int id = 2;
	ttemp = find(tree, id);
	if (ttemp == NULL)
		printf("cant find;");

	printf_s(ttemp);
#endif
	exit(0);
}

load

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

#define NAMESIZE 16
#define FILEPATH "./sava.txt"

typedef struct BiTree_st
{
	char data;
	struct BiTree_st* lchild;
	struct BiTree_st* rchild;
}Tree;

Tree* tree = NULL;

int insert(Tree** t, int data)
{
	Tree* p;
	if (*t == NULL)
	{
		p = (Tree*)malloc(sizeof(*p));
		if (p == NULL)
		{
			return -1;
		}
		p->data = data;
		p->lchild = NULL;
		p->rchild = NULL;
		*t = p;
		return 0;
	}
	else
	{
		if (data <= (*t)->data)
		{
			return insert(&((*t)->lchild), data);
		}
		else
		{
			return insert(&((*t)->rchild), data);
		}
	}
}



void draw_(Tree* t, int level)
{
	if (t == NULL)
		return;
	draw_(t->rchild, level + 1);
	for (int i = 0; i < level; i++)
	{
		printf("    ");
	}
	printf("%c\n", t->data);
	draw_(t->lchild, level + 1);


}


void draw(Tree* t)
{
	draw_(t, 0);

}

int getnum(Tree* t)
{
	if (t == NULL)
	{
		return 0;
	}
	printf("----\n");
	return (getnum(t->lchild) + 1 + getnum(t->rchild));

}

static Tree* find_mini(Tree* t)
{
	if (t->lchild == NULL)
		return t;

	return find_mini(t->lchild);


}


static Tree* find_max(Tree* t)
{
	if (t->rchild == NULL)
		return t;

	return find_max(t->rchild);
}





//通过遍历实现先序遍历
void travel(Tree* t)
{
	if (t == NULL)
		return;
	printf("%c\n", t->data);
	travel(t->lchild);
	travel(t->rchild);
}



int save_(Tree* root, FILE* fp)
{
	fputc('(', fp);
	printf("(");

	if (root == NULL)
	{
		fputc(')', fp);
		printf(")");
		return 0;
	}

	fputc(root->data, fp);
	printf("%c", root->data);

	save_(root->lchild, fp);
	save_(root->rchild, fp);

	fputc(')', fp);
	printf(")");
	return 0;

}

int save(Tree* root, const char* path)
{
	FILE* fp;

	fp = fopen(path, "w");
	if (fp == NULL)
	{
		return -1;
	}

	save_(root, fp);
	return 0;
	fclose(fp);
}


Tree* load_(FILE* fp)
{
	int c;
	Tree* root;
	c = fgetc(fp);
	/* if erroe*/

	if (c != '(')
	{
		fprintf(stderr, "fget():error.\n");
		exit(1);
	}

	c = fgetc(fp);
	if (c == ')')
		return NULL;

	root = (Tree* )malloc(sizeof(*root));
	if (root == NULL)
		exit(1);

	root->data = c;
	root->lchild = load_(fp);
	root->rchild = load_(fp);
	fgetc(fp);
	/* 还有最后一个 ')'   */

	return root;
}




Tree* load(const char* path)
{
	FILE* fp;
	Tree* root;
	fp = fopen(path,"r");
	if (fp == NULL)
	{
		return NULL;
	}


	root = load_(fp);

	fclose(fp);
	return root;
}




int main()
{
	Tree* root;
	root = load(FILEPATH);

	draw(root);

	exit(0);
}