C和指针 第十七章 经典数据类型 堆栈 队列 二叉树
堆栈:
//
// Created by mao on 16-9-16.
//
#ifndef UNTITLED_STACK_H
#define UNTITLED_STACK_H
#define TRUE 1
#define FALSE 0
typedef int STACK_TYPE;
typedef struct stack{
STACK_TYPE value;
struct stack *next;
} STACK;
void create_stack();
void destory_stack();
void push(STACK_TYPE value);
STACK_TYPE pop();
int isEmpty();
#endif //UNTITLED_STACK_H
stack.h
//
// Created by mao on 16-9-16.
//
#include <stdlib.h>
#include "stack.h"
static STACK *stack;
void create_stack()
{
stack = (STACK *)malloc(sizeof(STACK));
stack -> next = NULL;
}
void destory_stack()
{
STACK *pStack;
while((pStack = stack -> next) != NULL){
free(stack);
stack = pStack;
}
}
void push(STACK_TYPE value)
{
STACK *new = (STACK *)malloc(sizeof(STACK));
new -> next = stack;
new -> value = value;
stack = new;
}
STACK_TYPE pop()
{
STACK_TYPE value = stack -> value;
STACK *pStack = stack;
stack = stack -> next;
free(pStack);
return value;
}
int isEmpty()
{
return stack -> next == NULL ? TRUE : FALSE;
}
stack.c
#include <stdio.h>
#include "stack.h"
int main()
{
//堆栈
create_stack();
push(10);
push(20);
push(30);
pop();
push(22);
while(isEmpty() == FALSE){
printf("%d \t", pop());
}
}
main.c
运行:
队列:
当使用数组作为队列时，如果只是一端插入一端弹出，那么当尾部没有空间时，便无法插入元素，一种解决方法是使用“环绕”数组，新元素可以存储到以前删除元素所留出来的空间中，这种方法称为循环数组。
循环数组有个问题，当队列为空，或者为满时，首位的下标是一样的，无法判断出此时队列的状态，所以在队列的rear后加一个空余的不使用的位置，用来判断队列的状态是满队列，还是空队列。
当为满队列时:
(rear + 2) % QUEUE_SIZE = front
当为空队列时：
(rear + 1) % QUEUE_SIZE = front
队列实现:
// // Created by mao on 16-9-16. // #ifndef UNTITLED_QUEUE_H #define UNTITLED_QUEUE_H #define TRUE 1 #define FALSE 0 #define QUEUE_SIZE 100 #define ARRAY_SIZE (QUEUE_SIZE + 1) typedef int QUEUE_TYPE; static QUEUE_TYPE queue[ARRAY_SIZE]; static int front = 1; static int rear = 0; void Q_delete(); QUEUE_TYPE Q_first(); void Q_insert(QUEUE_TYPE value); int Q_isEmpty(); int Q_isFull(); #endif //UNTITLED_QUEUE_H
queue.h
//
// Created by mao on 16-9-16.
//
#include "queue.h"
#include <assert.h>
void Q_delete()
{
assert(Q_isEmpty() == FALSE);
front = (front + 1) % QUEUE_SIZE;
front = (front) % QUEUE_SIZE;
}
QUEUE_TYPE Q_first()
{
assert(Q_isEmpty() == FALSE);
return queue[front];
}
//队列插入数据,rear++
void Q_insert(QUEUE_TYPE value)
{
assert(Q_isFull() == FALSE);
rear = (rear + 1) % QUEUE_SIZE;
queue[(rear) % QUEUE_SIZE] = value;
}
int Q_isEmpty()
{
return (rear + 1) % QUEUE_SIZE == front ? TRUE: FALSE;
}
int Q_isFull()
{
return (rear + 2) % QUEUE_SIZE == front ? TRUE : FALSE;
}
queue.c
#include <stdio.h>
#include "queue.h"
int main()
{
//插入队列
Q_insert(10);
Q_insert(12);
Q_delete();
Q_insert(22);
Q_insert(30);
printf("%d\n", Q_first());
Q_delete();
printf("%d\n", Q_first());
Q_delete();
printf("%d\n", Q_first());
Q_delete();
return 1;
}
main.c
运行:
二叉树:
#ifndef UNTITLED_BINARYTREE_H
#define UNTITLED_BINARYTREE_H
#include <assert.h>
#define TREE_TYPE int
#define ARRAY_SIZE 100
#define TREE_SIZE (ARRAY_SIZE + 1)
TREE_TYPE TREE[TREE_SIZE] = {0};
static unsigned int leftChild(unsigned int current)
{
return current * 2;
}
static unsigned int rightChild(unsigned int current)
{
return current * 2 + 1;
}
void insert(TREE_TYPE value)
{
unsigned int current = 1;
while(TREE[current] != 0){
if(value < TREE[current]){
current = leftChild(current);
}else{
assert(TREE[current] != value);
current = rightChild(current);
}
assert(current < TREE_SIZE);
}
TREE[current] = value;
}
TREE_TYPE *find(TREE_TYPE value)
{
unsigned int current = 1;
while (current < TREE_SIZE && TREE[current] != value){
if(value < TREE[current]){
current = leftChild(current);
}else if(value > TREE[current]){
current = rightChild(current);
}
}
if(current < TREE_SIZE){
return TREE + current;
}else{
return 0;
}
}
//根据指针计算数组下标
static unsigned long getIndex(TREE_TYPE *ptr){
assert(ptr >= TREE || ptr <= TREE + TREE_SIZE);
return ptr - TREE;
}
//内置先遍历接口
void pre_order_traverse(unsigned int current, void(*callback)(TREE_TYPE value))
{
if(current < ARRAY_SIZE && TREE[current] != 0){
callback(TREE[current]);
pre_order_traverse(leftChild(current), callback);
pre_order_traverse(rightChild(current), callback);
}
}
//先序遍历
void do_pre_traverse(void(*callback)(TREE_TYPE value))
{
pre_order_traverse(1, callback);
}
//中序遍历
void mid_order_traverse(unsigned int current, void(*callback)(TREE_TYPE value))
{
if(current < ARRAY_SIZE && TREE[current] != 0){
mid_order_traverse(leftChild(current), callback);
callback(TREE[current]);
mid_order_traverse(rightChild(current), callback);
}
}
void do_mid_order_traverse(void(*callback)(TREE_TYPE value))
{
mid_order_traverse(1, callback);
}
//后续遍历
void after_order_traverse(unsigned int current, void(*callback)(TREE_TYPE value))
{
if(current < ARRAY_SIZE && TREE[current] != 0){
after_order_traverse(leftChild(current), callback);
after_order_traverse(rightChild(current), callback);
callback(TREE[current]);
}
}
void do_after_order_traverse(void(*callback)(TREE_TYPE value))
{
after_order_traverse(1, callback);
}
void print_tree(TREE_TYPE value)
{
printf("%d\t", value);
}
#endif //UNTITLED_BINARYTREE_H
BinaryTree.h
#include <stdio.h>
#include "BinaryTree.h"
int main()
{
insert(20);
insert(12);
insert(5);
insert(9);
insert(16);
insert(17);
insert(25);
insert(28);
insert(26);
insert(29);
do_pre_traverse(print_tree);
printf("\n");
do_mid_order_traverse(print_tree);
printf("\n");
do_after_order_traverse(print_tree);
return 1;
}
main.c
运行：
数组形式存放二叉树，会导致内存空间的浪费，尤其是非对称的二叉树，会造成大量的数组空间闲置。通过链式二叉树可以解决数组不充分的问题
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef int TREE_TYPE;
typedef struct TREE_NODE {
TREE_TYPE value;
struct TREE_NODE *leftPtr;
struct TREE_NODE *rightPtr;
} TREE_NODE;
//指向树的根节点的指针
TREE_NODE *root;
//创建根节点
void createTree(TREE_TYPE value)
{
root = (TREE_NODE *) malloc(sizeof(TREE_NODE));
root -> leftPtr = NULL;
root -> rightPtr = NULL;
root -> value = value;
}
TREE_NODE * getRoot()
{
return root;
}
//插入节点
void insertNode(TREE_TYPE value)
{
TREE_NODE *current = root;
//pos为待插入节点的父节点
TREE_NODE *parent = root;
while(current != NULL){
//保存父节点信息
parent = current;
if(current -> value < value){
current = current -> rightPtr;
}else if(current -> value > value){
current = current -> leftPtr;
}else{
//节点已存在
return ;
}
}
TREE_NODE *node = (TREE_NODE *) malloc(sizeof(TREE_NODE));
assert(node != NULL);
node -> leftPtr = NULL;
node -> rightPtr = NULL;
node -> value = value;
//根据值得大小判断，node应该放在左节点还是右节点
if(parent -> value > value){
parent -> leftPtr = node;
}else{
parent -> rightPtr = node;
}
}
TREE_NODE * findNode(TREE_TYPE value)
{
TREE_NODE *current = root;
while(current != NULL && current -> value != value){
if( current -> value > value){
current = current -> leftPtr;
}else{
current = current -> rightPtr;
}
}
return current;
}
void printNode(TREE_NODE * node)
{
printf("%d\t", node -> value);
}
void pre_order_traverse(TREE_NODE * current)
{
if(current != NULL){
printNode(current);
pre_order_traverse(current -> leftPtr);
pre_order_traverse(current -> rightPtr);
}
}
void mid_order_traverse(TREE_NODE * current)
{
if(current != NULL){
mid_order_traverse(current -> leftPtr);
printNode(current);
mid_order_traverse(current -> rightPtr);
}
}
void after_order_traverse(TREE_NODE * current)
{
if(current != NULL){
after_order_traverse(current -> leftPtr);
after_order_traverse(current -> rightPtr);
printNode(current);
}
}
BinaryTree.h
#include <stdio.h>
#include "BinaryTree.h"
int main()
{
createTree(20);
insertNode(12);
insertNode(5);
insertNode(9);
insertNode(16);
insertNode(17);
insertNode(25);
insertNode(28);
insertNode(26);
insertNode(29);
pre_order_traverse(root);
printf("\n");
mid_order_traverse(root);
printf("\n");
after_order_traverse(root);
return 1;
}
BinaryTree.c
运行:
