动态数组、单链表、栈、二叉树

最新推荐文章于 2024-10-04 05:48:57 发布
最新推荐文章于 2024-10-04 05:48:57 发布
阅读量345 收藏
点赞数
分类专栏： c/c++ 文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45879198/article/details/117374792
版权

文章目录

前言

提示：以下是本篇文章正文内容，下面案例可供参考

一、动态数组

1.darray.h

#ifndef _DARRAY_H_
#define _DARRAY_H_

// 定义管理动态数组的结构体。
typedef struct darray
{
	int cap; // 容量
	int size;   // 实际元素个数
	void **data;  // 等价 void *data[];  数组中存储的都是 地址 
}DArray;

// 封装操作 动态数组的 API接口

// 初始化动态数组
DArray *Init_DArray(int cap); 

// 插入元素  --- 往哪里插， 插入到哪去， 插什么？ 
void Insert_DArray(DArray *array, int pos, void *data); 

// 删除元素
void Delete_DArray(DArray *array, int pos);

// 遍历  --- 回调函数 
void Traverse_DArray(DArray *array, void (*print)(void *));

// 销毁
void Destroy_DArray(DArray *array);

#endif

2.darry.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "darray.h"

// 初始化动态数组
DArray *Init_DArray(int cap)
{
	DArray *ptr = (DArray *)malloc(sizeof(DArray));
	
	ptr->cap = cap;
	ptr->size = 0;
	ptr->data = (void **)malloc(sizeof(void *) * cap);
	
	return ptr;
}

// 插入元素  --- 往哪里插， 插入到哪去， 插什么？ 
void Insert_DArray(DArray *array, int pos, void *data)
{
	// 容错
	if (NULL == array || NULL == data)
	{
		return;
	} 
	if (pos < 0 || pos > array->size)
	{
		pos = array->size;  // 当插入位置，超出尾元素下一位置， 插入到末尾。 
	}

	// 当容量 == size时， 应该自动扩容。
	if (array->cap == array->size)	
	{
	 	// 指定容量扩充为原来的 2 倍。
		int newCap = array->cap * 2;
		
		void **space = (void **)malloc(sizeof(void *) * newCap);	
		
		// 将 旧数据 拷贝到新内存中
		memcpy(space, array->data, sizeof(void *) * array->size); 
		
		// 释放旧的内存空间
		free(array->data);
		
		array->cap = newCap;  // 更新容量
		 
		array->data = space; 
	}
	
	// pos位置之后的元素， 依次后移（前一个元素，覆盖后一个元素） 
	int i = 0;
	for	(i = array->size; i > pos; --i)
	{
		array->data[i] = array->data[i-1];
	}
	
	// 将 pos位置插入元素
	array->data[pos] = data;
	
	// 更新size
	array->size++;
} 

// 遍历
void Traverse_DArray(DArray *array, void (*print)(void *))
{
	int i = 0; 
	for (i = 0; i < array->size; i++)
	{
		// 打印每一个动态数组中的元素。
		print(array->data[i]);
	}
}

// 删除元素
void Delete_DArray(DArray *array, int pos)
{

}
// 销毁
void Destroy_DArray(DArray *array)
{
	
}

3.test

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "darray.h"

typedef struct Person
{
	int id;
	char name;
}Person; 

void myprint(void *data)
{
	Person *p = (Person *)data;
	printf("id = %d, name = %c\n", p->id, p->name);
}

int main(void)
{
	Person p[10];
	
	// 初始化
	DArray *ptr = Init_DArray(5);
	
	// 循环插入到动态数组中
	int i= 0; 
	for (i = 0; i<10; i++)
	{
		p[i].id = i;
		p[i].name = 'A' + i;
		
		// 插入到动态数组
		Insert_DArray(ptr, i, &p[i]); 
	}
	
	// 遍历
	Traverse_DArray(ptr, myprint);
	
	return 0;
}

二、单链表

1.linklist

代码如下（示例）：

#ifndef _LINKLIST_H_
#define _LINKLIST_H_

// 定义链表结点结构体
typedef struct Node
{
	void *data;
	struct Node *next;
}Node; 

// 定义管理链表的结构体
typedef struct LinkList
{
	Node header; 
	int size; 
}LinkList; 

// 初始化链表
LinkList* Init_LinkList();

// 插入结点 --- 向哪里插，插到哪，插什么 
void Insert_LinkList(LinkList* list, int pos, void* data);

// 删除结点
void Delete_LinkList(LinkList* list, int pos); 

// 遍历 -- 回调函数 -- 函数指针 -- 函数地址 -- 函数名 
void Traverse_LinkList(LinkList* list, void (*print)(void *)); 

// 查询 -- 回调函数： compare: 相等返回 1， 不相等返回0 
void* Search_LinkList(LinkList* list, void *data, int (*compare)(void *, void *)); 

/*
//根据数据值， 删除链表结点。
void Del_Data_LinkList(LinkList* list, void* data, int(*compare)(void*, void*))
*/

// 销毁
void Destroy_LinkList(LinkList* list);
 
#endif //_LINKLIST_H_

2.linklist

代码如下（示例）：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "linklist.h"

// 初始化链表
LinkList* Init_LinkList()
{
	LinkList* ptr = (LinkList *)malloc(sizeof(LinkList));
	if (NULL == ptr)
	{
		perror("malloc ptr error");	// stderr -- 无缓冲 --- 有数据立即刷。 
		// printf();		// stdout -- 行缓冲。 遇到\n 会刷新缓冲区。 flush 手动刷新。 
		return;
	}
	ptr->header.data = NULL;
	ptr->header.next = NULL;
	ptr->size = 0;
	
	return ptr;
}

// 插入结点 --- 向哪里插，插到哪，插什么 
void Insert_LinkList(LinkList* list, int pos, void* data)
{
	// 容错
	if (NULL == list || NULL == data)
	{
		return;
	} 
	if (pos < 0 || pos > list->size)
	{
		return;
	}
	
	// 创建待插入的新结点
	Node *pnew = (Node*)malloc(sizeof(Node)); 
	pnew->data = data;
	pnew->next = NULL;
	
	// 将 pnew 插入到 pos位置。
	
	// 创建辅助指针， 找寻 pos位置。
	Node *pcur = &list->header;
	int i = 0;
	for (i = 0; i < pos; i++)  // 循环结束，pcur指向pos所对应的结点的前一个结点。 
	{
		pcur = pcur->next;
	} 
	pnew->next = pcur->next;  // 新结点的下一结点， 是 pos对应的结点（用pcur->next 去表示） 
	pcur->next = pnew; 		// pos前一个结点（用pcur）的下一结点，是新结点。 
	
	// 更新实际结点个数 
	list->size++; 
}

// 删除结点
void Delete_LinkList(LinkList* list, int pos)
{
	if (NULL == list)
	{
		return ;
	} 
	if (pos < 0 || pos >= list->size)
	{
		return ;
	}
	// 定义辅助指针变量 pcur， 找到pos位置。
	Node *pcur = &list->header;
	int i = 0;
	for (i = 0; i < pos; i++)
	{
		pcur = pcur->next;  // 循环结束后， pcur 指向 pos 的前一个结点。 
	} 
	// 定义pdel保存pos对应的待删除结点。
	Node *pdel = pcur->next; 
	pcur->next = pdel->next;  // 跳过pos对应结点， 让 pcur 的下一个结点为 pos的下一个结点。
	free(pdel);
	pdel = NULL;
	
	// 更新size
	list->size--; 
}

// 遍历 -- 回调函数 -- 函数指针 -- 函数地址 -- 函数名 
void Traverse_LinkList(LinkList* list, void (*print)(void *))
{
	if (NULL == list || NULL == print)
	{
		return ;
	} 
	// 定义辅助指针 pcur，遍历链表结点。
	Node *pcur = list->header.next;   // 用第一个数据结点给 pcur 赋初值。 
	while (pcur) 
	{
		print(pcur->data);  
		pcur = pcur->next;
	}
} 

// 查询 -- 回调函数： compare: 相等返回 1， 不相等返回0 
void *Search_LinkList(LinkList* list, void *data, int (*compare)(void *, void *))
{
	if (NULL == list || NULL == data || compare == NULL)
	{
		return ;
	}
	
	// 定义辅助指针 pcur，遍历链表结点。
	Node *pcur = list->header.next;   // 用第一个数据结点给 pcur 赋初值。	 
	while (pcur) 
	{
		if (compare(data, pcur->data))
		{
			break;  // 找到 与data对应的 数据结点。 该结点保存在pcur中。 
		}
		pcur = pcur->next;
	}
	// 遍历所有链表结点，没有找到与data一致的数据， 循环结束。pcur === NULL 
	if (NULL == pcur)
	{
		return NULL; 
	}
	
	return pcur->data; 
} /*
void Del_Data_LinkList(LinkList* list, void* data, int(*compare)(void*, void*))
{
		if (NULL == list || NULL == data || compare == NULL)
	{
		return ;
	}
	int pos=1;
	// 定义辅助指针 pcur，遍历链表结点。
	Node *pcur = list->header.next;   // 用第一个数据结点给 pcur 赋初值。	 
	while (pcur) 
	{
		if (compare(data, pcur->data))
		{
			break;  // 找到 与data对应的 数据结点。 该结点保存在pcur中。 
		}
		pcur = pcur->next;
		pos++;
	}
	// 遍历所有链表结点，没有找到与data一致的数据， 循环结束。pcur === NULL 
	if (NULL == pcur)
	{
		return 0; 
	}
	return pos;
}*/
// 销毁
void Destroy_LinkList(LinkList* list)
{
	if (NULL == list)
	{
		return ;
	} 
	// 定义辅助指针 pcur， 遍历链表结点 
	Node *pcur = list->header.next;
	while (pcur)
	{
		Node *pdel = pcur;   // 保存当前待释放结点的地址。 
		pcur = pcur->next;
		free(pdel); 
	}	
	free(list);
	list = NULL;
}

3.


void Del_Data_LinkList(LinkList* list, void* data, int(*compare)(void*, void*));

int Search_Pos(LinkList* list, void* data, int(*compare)(void*, void*));


// 参照 Seach_LinkList() 修改，根据 data 获取 pos 
int Search_Pos(LinkList* list, void* data, int(*compare)(void*, void*))
{
	if (list == NULL || data == NULL || compare == NULL)
	{
		return -1;
	}
	
	int pos = 0;
	
	// 用链表中的每一个节点, 和data比较
	Node* pcur = list->header.next;
	while (pcur)
	{
		// 比较两个变量是否相等
		if (compare(pcur->data, data))
		{
			break;
		}
		pcur = pcur->next;
		pos++;
	}
	// pcur 指向的地址中的数据和data指向的地址中的数据相等
	if (pcur == NULL)
	{
		return -1;
	}
	return pos;
}

void Del_Data_LinkList(LinkList* list, void* data, int(*compare)(void*, void*))
{
	// 先找到 data 在 list中的 pos 位置。—— 参照 Seach_LinkList() 修改， 获取 pos 
	int pos = Search_Pos(list, data, compare);

	// 按位置删除。 
	Delete_LinkList(list, pos);
}

// 调用测试
Del_Data_LinkList(list, &p[3], compare);
printf("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n");
Traverse_LinkList(list, myprint);

4.


void Reverse_LinkList(LinkList* list, void(*print)(void*));

void Recursion(Node* node, void(*print)(void*));

// 链表逆序遍历
void Reverse_LinkList(LinkList* list, void(*print)(void*))
{
	if (list == NULL || print == NULL)
	{
		return;
	}
	// 启动递归，遍历链表
	Recursion(list->header.next, print);
}

void Recursion(Node* node, void(*print)(void*))
{
	// 递归结束条件，尾结点
	if (node == NULL)
	{
		return;
	}

	// 开始递归调用自己
	Recursion(node->next, print);

	// 出栈的时候（链表遍历完成 node == NULL）执行的操作
	print(node->data);
}

// 调用测试
printf("|||||||||||||||||||||||||||||||||||||||||\n");
Reverse_LinkList(list, myprint);

5.test

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "linklist.h"

// 初始化链表
LinkList* Init_LinkList()
{
	LinkList* ptr = (LinkList *)malloc(sizeof(LinkList));
	if (NULL == ptr)
	{
		perror("malloc ptr error");	// stderr -- 无缓冲 --- 有数据立即刷。 
		// printf();		// stdout -- 行缓冲。 遇到\n 会刷新缓冲区。 flush 手动刷新。 
		return;
	}
	ptr->header.data = NULL;
	ptr->header.next = NULL;
	ptr->size = 0;
	
	return ptr;
}

// 插入结点 --- 向哪里插，插到哪，插什么 
void Insert_LinkList(LinkList* list, int pos, void* data)
{
	// 容错
	if (NULL == list || NULL == data)
	{
		return;
	} 
	if (pos < 0 || pos > list->size)
	{
		return;
	}
	
	// 创建待插入的新结点
	Node *pnew = (Node*)malloc(sizeof(Node)); 
	pnew->data = data;
	pnew->next = NULL;
	
	// 将 pnew 插入到 pos位置。
	
	// 创建辅助指针， 找寻 pos位置。
	Node *pcur = &list->header;
	int i = 0;
	for (i = 0; i < pos; i++)  // 循环结束，pcur指向pos所对应的结点的前一个结点。 
	{
		pcur = pcur->next;
	} 
	pnew->next = pcur->next;  // 新结点的下一结点， 是 pos对应的结点（用pcur->next 去表示） 
	pcur->next = pnew; 		// pos前一个结点（用pcur）的下一结点，是新结点。 
	
	// 更新实际结点个数 
	list->size++; 
}

// 删除结点
void Delete_LinkList(LinkList* list, int pos)
{
	if (NULL == list)
	{
		return ;
	} 
	if (pos < 0 || pos >= list->size)
	{
		return ;
	}
	// 定义辅助指针变量 pcur， 找到pos位置。
	Node *pcur = &list->header;
	int i = 0;
	for (i = 0; i < pos; i++)
	{
		pcur = pcur->next;  // 循环结束后， pcur 指向 pos 的前一个结点。 
	} 
	// 定义pdel保存pos对应的待删除结点。
	Node *pdel = pcur->next; 
	pcur->next = pdel->next;  // 跳过pos对应结点， 让 pcur 的下一个结点为 pos的下一个结点。
	free(pdel);
	pdel = NULL;
	
	// 更新size
	list->size--; 
}

// 遍历 -- 回调函数 -- 函数指针 -- 函数地址 -- 函数名 
void Traverse_LinkList(LinkList* list, void (*print)(void *))
{
	if (NULL == list || NULL == print)
	{
		return ;
	} 
	// 定义辅助指针 pcur，遍历链表结点。
	Node *pcur = list->header.next;   // 用第一个数据结点给 pcur 赋初值。 
	while (pcur) 
	{
		print(pcur->data);  
		pcur = pcur->next;
	}
} 

// 查询 -- 回调函数： compare: 相等返回 1， 不相等返回0 
void *Search_LinkList(LinkList* list, void *data, int (*compare)(void *, void *))
{
	if (NULL == list || NULL == data || compare == NULL)
	{
		return ;
	}
	
	// 定义辅助指针 pcur，遍历链表结点。
	Node *pcur = list->header.next;   // 用第一个数据结点给 pcur 赋初值。	 
	while (pcur) 
	{
		if (compare(data, pcur->data))
		{
			break;  // 找到 与data对应的 数据结点。 该结点保存在pcur中。 
		}
		pcur = pcur->next;
	}
	// 遍历所有链表结点，没有找到与data一致的数据， 循环结束。pcur === NULL 
	if (NULL == pcur)
	{
		return NULL; 
	}
	
	return pcur->data; 
} /*
void Del_Data_LinkList(LinkList* list, void* data, int(*compare)(void*, void*))
{
		if (NULL == list || NULL == data || compare == NULL)
	{
		return ;
	}
	int pos=1;
	// 定义辅助指针 pcur，遍历链表结点。
	Node *pcur = list->header.next;   // 用第一个数据结点给 pcur 赋初值。	 
	while (pcur) 
	{
		if (compare(data, pcur->data))
		{
			break;  // 找到 与data对应的 数据结点。 该结点保存在pcur中。 
		}
		pcur = pcur->next;
		pos++;
	}
	// 遍历所有链表结点，没有找到与data一致的数据， 循环结束。pcur === NULL 
	if (NULL == pcur)
	{
		return 0; 
	}
	return pos;
}*/
// 销毁
void Destroy_LinkList(LinkList* list)
{
	if (NULL == list)
	{
		return ;
	} 
	// 定义辅助指针 pcur， 遍历链表结点 
	Node *pcur = list->header.next;
	while (pcur)
	{
		Node *pdel = pcur;   // 保存当前待释放结点的地址。 
		pcur = pcur->next;
		free(pdel); 
	}	
	free(list);
	list = NULL;
}

三、栈

1.顺序栈

1.seqstack.h

#ifndef _SEQSTACK_H_
#define _SEQSTACK_H_

#define MAXSIZE 50

// 创建管理栈的结构体
typedef struct seqstack 
{
	void *data[MAXSIZE];   // 静态数组，存储栈数据 
	int top;   	// 记录数组尾元素（栈顶元素）下标	
}SeqStack;

// 初始化空栈 
void InitStack(SeqStack *st); 

// 清空栈
void ClearStack(SeqStack *st);

// 获取栈顶元素 
void *GetTop(SeqStack *st);

// 入栈（压栈）
void PushStack(SeqStack *st, void *data);

// 出栈（弹栈） 
void PopStack(SeqStack *st);

// 获取栈元素数 -- 栈大小 
int SizeStack(SeqStack *st);

#endif

2.seqstack

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "seqstack.h"

// 初始化空栈 
void InitStack(SeqStack *st)
{
	if (st == NULL)
		return;
		
	st->top = -1;  // 不能指定为 >=0 的有效下标。 、
	memset(st->data, 0, sizeof(st->data));
} 

// 清空栈
void ClearStack(SeqStack *st)
{
	InitStack(st);  // 将栈恢复成初始化状态 
}

// 获取栈顶元素 
void *GetTop(SeqStack *st)
{
	if (NULL == st || st->top == -1)  // 当 top 为 -1，栈为空。 
	{
		return ;
	}	
	return st->data[st->top]; 
}

// 入栈（压栈）
void PushStack(SeqStack *st, void *data)
{
	if (NULL == st || data == NULL)  
	{
		return ;
	}
	if (st->top == MAXSIZE-1)
	{
		return ;
	}
	st->top++;
	st->data[st->top] = data;
}

// 出栈（弹栈） 
void PopStack(SeqStack *st)
{
	if (NULL == st)  
	{
		return ;
	}
	if (st->top == -1)
	{
		return ;
	}
	st->top--;
}

// 获取栈元素数 -- 栈大小 
int SizeStack(SeqStack *st)
{
	if (NULL == st)  
	{
		return ;
	}
	
	return st->top + 1;
}

3.test

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "seqstack.h"

typedef struct Person
{
	int id;
	char name;	
}Person;

int main(void)
{
	Person p[10];

	// 初始化栈 
	SeqStack st;
	InitStack(&st); 
	
	// 循环将数据插入到栈中
	int i = 0;
	for (i = 0; i < sizeof(p)/sizeof(p[0]); i++)
	{
		p[i].id = i;
		p[i].name = i+'a';
		
		PushStack(&st, &p[i]);
	} 
	
	printf("1st --stack size = %d\n", SizeStack(&st));
	
	// 借助循环 + 获取栈顶元素 + 弹栈 模拟遍历。
	while (SizeStack(&st)) 
	{
		// 获取栈顶元素 
		Person *pret = (Person *)GetTop(&st);
		printf("id = %d, name=%c\n", pret->id, pret->name); 
		PopStack(&st);
	}
	printf("2nd --stack size = %d\n", SizeStack(&st));
	
	// 清空 
	ClearStack(&st);
	
	return  0; 
}

2.链栈

1.LinkStack.h

#ifndef _LINKSTACK_H_
#define _LINKSTACK_H_

// 链表结点结构体
typedef struct Node
{
	struct Node* next;	// 没有数据域
}Node;
 
// 管理 链式栈 机构体
typedef struct LinkStack
{
	int size;
	Node* top;
}LinkStack;

// 初始化空链式栈
void InitStack(LinkStack *st);

// 清空栈
void ClearStack(LinkStack* st);

// 获取栈顶元素
void* GetTop(LinkStack* st);

// 压栈（入栈）—— 对应的，要将 node 添加为 Person 首个成员。
void PushStack(LinkStack* st, Node *node);

// 弹栈（出栈）
void PopStack(LinkStack* st);

// 栈大小
int SizeStack(LinkStack* st);

#endif // _LINKSTACK_H_

2.LinkStack.c

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
#include "LinkStack.h"

// 初始化空链式栈
void InitStack(LinkStack* st)
{
	if (NULL == st)
		return;

	st->size = 0;
	st->top = NULL;  // 永远指向第一个数据结点。  NULL 表没有指向。
}

// 清空栈
void ClearStack(LinkStack* st)
{
	// InitStack(st);  【方法1】

	// 【方法2】：有可能，需要释放链表的结点。 
	if (NULL == st)
		return;
		
	while (st->size)
	{
		PopStack(st);	// 利用Pop， 如果需要删除、释放， 都在 Pop中。
	}
}

// 获取栈顶元素
void* GetTop(LinkStack* st)
{
	if (0 == st->size)
		return NULL;

	return st->top;   // 返回第一个数据结点。
}

// 压栈（入栈）—— 对应的，要将 node 添加为 Person 首个成员。
void PushStack(LinkStack* st, Node* node)
{
	if (NULL == st || NULL == node)
		return;

	// 采用 头插法
	node->next = st->top;   // 新结点node，将变为 头。原来的 top 是其下一个结点。
	st->top = node;		// 让 top 指向新结点。

	st->size++;
}

// 弹栈（出栈）
void PopStack(LinkStack* st)
{
	// 没数据， 不用执行弹栈了。 
	if (NULL == st || st->size == 0)
		return;

	st->top = st->top->next;  // top指向当前结点的下一个结点
	st->size--;
}

// 栈大小
int SizeStack(LinkStack* st)
{
	if (NULL == st)
		return 0;

	return st->size;
}

3.test

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
#include "LinkStack.h"

// 初始化空链式栈
void InitStack(LinkStack* st)
{
	if (NULL == st)
		return;

	st->size = 0;
	st->top = NULL;  // 永远指向第一个数据结点。  NULL 表没有指向。
}

// 清空栈
void ClearStack(LinkStack* st)
{
	// InitStack(st);  【方法1】

	// 【方法2】：有可能，需要释放链表的结点。 
	if (NULL == st)
		return;
		
	while (st->size)
	{
		PopStack(st);	// 利用Pop， 如果需要删除、释放， 都在 Pop中。
	}
}

// 获取栈顶元素
void* GetTop(LinkStack* st)
{
	if (0 == st->size)
		return NULL;

	return st->top;   // 返回第一个数据结点。
}

// 压栈（入栈）—— 对应的，要将 node 添加为 Person 首个成员。
void PushStack(LinkStack* st, Node* node)
{
	if (NULL == st || NULL == node)
		return;

	// 采用 头插法
	node->next = st->top;   // 新结点node，将变为 头。原来的 top 是其下一个结点。
	st->top = node;		// 让 top 指向新结点。

	st->size++;
}

// 弹栈（出栈）
void PopStack(LinkStack* st)
{
	// 没数据， 不用执行弹栈了。 
	if (NULL == st || st->size == 0)
		return;

	st->top = st->top->next;  // top指向当前结点的下一个结点
	st->size--;
}

// 栈大小
int SizeStack(LinkStack* st)
{
	if (NULL == st)
		return 0;

	return st->size;
}

四.二叉树

#include <stdio.h>

// 定义二叉树的结点结构体
typedef struct BinaryTree
{
	char data;
	struct BinaryTree *left;
	struct BinaryTree *right;
}BinTree;

// 先序遍历  --- 递归 
void PreOrder(BinTree *root)
{
	// 递归终止条件
	if (NULL == root)
		return ;
		 
	printf("%c ", root->data);	
	PreOrder(root->left);
	PreOrder(root->right);
} 
// 中序遍历  --- 递归 
void MidOrder(BinTree *root)
{
	// 递归终止条件
	if (NULL == root)
		return ;
		 
	MidOrder(root->left);
	printf("%c ", root->data);
	MidOrder(root->right);	
}
 
int main(void)
{
	BinTree a, b, c, d, e, f, g;
	
	memset(&a, 0, sizeof(BinTree));
	memset(&b, 0, sizeof(BinTree));
	memset(&c, 0, sizeof(BinTree));
	memset(&d, 0, sizeof(BinTree));
	memset(&e, 0, sizeof(BinTree));
	memset(&f, 0, sizeof(BinTree));
	memset(&g, 0, sizeof(BinTree));
	
	a.data = 'A';
	a.left = &b;
	a.right = &c;
	
	b.data = 'B';
	b.left = &d;
	b.right = &e;
		
	c.data = 'C';
	c.left = &f;
	c.right = &g;
	
	d.data = 'D';
	e.data = 'E';
	f.data = 'F';
	g.data = 'G';
	
	// 先序
	PreOrder(&a);
	printf("\n----------------\n");
	MidOrder(&a); 
		
	return 0;
}
末日流光
关注
专栏目录
链表形式去创建一个二叉树
weixin_55625968的博客
07-28 655
链表（动态方式）创建一个二叉树
二叉树的建立，从动态二叉链表转化为静态二叉链表
windflybird
11-30 5131
动态二叉链表 typedef char ElemType; typedef  struct BiNode { ElemType data; struct  BiNode *lchild;    struct BiNode *rchild; }BiNode,*Bitree; typedef struct { ElemType data;   int lc
数据结构(13)二叉树的动态链表存储和遍历的实现
happylzs2008的专栏
12-19 389
http://blog.csdn.net/u010366748/article/details/50765512 参考书籍：数据结构（C语言版）严蔚敏吴伟民编著清华大学出版社 1.动态二叉链表存储即遍历的实现 1.1.动态二叉链表的定义 [cpp] view plain copy #include  
二叉链表实现二叉树
SWC0619的博客
03-22 6637
c++实现二叉树
《数据结构》-二叉树(二叉链表实现)
tyustli
07-20 9241
main.c /* * Change Logs: * Date Author Notes * 2021-07-20 tyustli first version */ #include "tree.h" void visitT(TElemType e) { printf("%d ", e); } int main(int argc, char *argv[]) { printf("this bitree\r\n"); in
数据结构-通过数组和单链表实现栈
qq_39565307的博客
12-16 226
1.栈的介绍 ： 1）栈的英文名称（stack） 2) 栈是一个先进后出的有序列表 3) 栈是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性结构。允许操作的一端称为栈顶，固定的一端称为栈底。 4）图解说明出栈和入栈的概念 2.栈的一些应用场景 1）子程序的调用：在跳往子程序之前，会先将下个指令的地址存放在堆栈中，直到子程序执行完后在将地址取出，已回到原来的程序中 2）处理...
数据结构与算法学习七：栈、数组模拟栈、单链表模拟栈、栈应用实例 实现 综合计算器
冯安晨
04-22 372
文章目录前言一、栈1.1 栈的介绍1.2 栈的应用实例【重点】1.3 栈的应用场景二、数据模拟栈三、单链表模拟栈四、栈实现综合计算器 前言 一、栈 1.1 栈的介绍 栈的英文为(stack) 栈是一个 先入后出 (FILO-First In Last Out)的有序列表。 栈(stack)是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，...
数据结构--常见的数据结构总结：链表、数组、栈、队列、二叉树、图
qq_44641527的博客
11-10 596
一、链表--逻辑上连续、空间上不连续 1、单链表 由数据域和next指针构成，next指针指向下一个链表结点 2、双链表 由数据域、前驱结点和后继结点构成，访问一个结点后既可以向前依次访问，也可以向后依次访问 二、数组--逻辑和空间上都连续 1、一维数组 2、二维数据 元素为一维数组的一维数组 特点：每行的列数可以不一样，因为存储的每个一维数组长度不固定 三、栈和队列 1、栈--桶状（封底） 先入后出 2、队列--管状（双通） ...
Java拓展——常见数据结构（数组，栈，链表，树，图）
m0_68154641的博客
09-19 363
常见的数据结构 栈--栈简介；如何创建一个类实现栈的功能?栈使用场景 队列--队列简介；如何实现?队列分类 链表--单链表；循环链表；双向链表；双向循环链表；链表使用场景；数组vs链表 树--二叉树分类；满二叉树；完全二叉树；平衡二叉树；二叉树的存储 链式存储；顺序存储； 二叉树的遍历--先序遍历、中序遍历、’后序遍历 二叉排序树--为什么使用二叉排序树；使用链表存储；使用二叉排序树存储；什么是二叉排序树 红黑树--什么事红黑树；为什么要用红黑树；旋转和变色；红黑树的优缺点
数据结构（数组、链表、栈、队列、树）
Lifelong learning
04-25 1425
数据结构，就是一种程序设计优化的方法论，研究数据的逻辑结构和物理结构以及它们之间相互关系，并对这种结构定义相应的运算，目的是加快程序的执行速度、减少内存占用的空间。
数据结构课件 线性表 单链表 栈和队列 串 数组和广义表 树和二叉树 C语言版
05-08
本课件聚焦于数据结构的基础部分，特别是线性表、单链表、栈和队列、串、数组和广义表，以及树和二叉树，所有这些概念都是用C语言实现的。 1. **线性表**：线性表是最基本的数据结构，它是由n（n≥0）个相同类型...
数据结构顺序表+单链表+二叉树+图等等各实验总汇.rar
07-10
在这个"数据结构顺序表+单链表+二叉树+图等等各实验总汇.rar"压缩包中，包含了多个关于基础数据结构的实验，对于计算机专业的学生来说，这些都是极其重要的学习资源。 首先，我们来看"顺序表o_o"。顺序表是一种最...
数据结构实验汇总+源代码（线性表、栈、字符串、多维数组、二叉树、图、排序）
12-18
数据结构实验内容：线性表（顺序表实现）、线性表（单链表实现）、栈、字符串、多维数组（三元组表存矩阵）、二叉树（二叉链表和顺序表存储）、邻接表存图以及图的遍历、排序 实验报告部分只要求了线性表、栈、多维...
DataStructers:由指针和动态数组构建的CC ++数据结构
03-22
本主题聚焦于使用C++编程语言，通过指针和动态数组来构建数据结构。C++是一种强大的、面向对象的编程语言，它允许程序员灵活地处理内存，并提供了构造复杂数据结构的工具。 首先，我们要理解指针。在C++中，指针是...
C语言 | Leetcode C语言题解之第454题四数相加II
m0_59237910的博客
10-04 751
C语言 | Leetcode C语言题解之第454题四数相加II
多台三相逆变器并联（本模型为三台并联，市面上多为两台并联）matlab simulink仿真 功能：实现并联系统中各逆变器输出
最新发布
10-09
多台三相逆变器并联（本模型为三台并联，市面上多为两台并联）matlab simulink仿真。 功能：实现并联系统中各逆变器输出功率均分。 （有能力的话还可以研究下垂特性、功率指令以及静态功工作点三者之间的联系） 控制策略：VSG控制策略（同步机控制） 逆变器主电路：三相逆变器，LCL滤波电路，VSG控制模块。 VSG控制模块：定、转子方程，dq变，电压电流双闭环，预同步，pwm发生器。
Ringtones波点音乐-《Lightning Moment》.mp3
10-09
Ringtones波点音乐-《Lightning Moment》.mp3
onnx2onnx-0.3.1.tar.gz
10-09
onnx2onnx-0.3.1.tar
网页商城系统 SSM毕业设计 源码+数据库+论文（JAVA+SpringBoot+Vue.JS）.zip
10-09
网页商城系统 SSM毕业设计 源码+数据库+论文（JAVA+SpringBoot+Vue.JS） 启动教程：https://www.bilibili.com/video/BV1GK1iYyE2B
Java数据结构详解：数组、链表、栈与队列
动态数组的特性使得数组大小可以在运行时根据需要扩展或收缩。 链表则是另一种存储结构，它不保证元素的连续存储，每个节点包含数据和指向下一个节点的指针。链表适用于频繁的插入和删除操作，但查找效率相对较低，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值