栈、队列和二叉树

栈：先进后出。

进制转换原理图：

下面是栈的代码

stack.h

#ifndef STACK_H
#define STACK_H

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

typedef struct StackNode{
    elemType data;
    struct StackNode *next;
}Stack;

//创建栈节点/栈--创建单链表节点
struct StackNode *create_node(elemType data0；
//压栈
bool Push_stack(Stack*头皮，elemType data);
//出栈--单链表头删法
bool pop_stack(Stack *top,elemType *data);
#endif

stack.c

#include "stack.h"

//创建栈节点/栈--创建单链表节点
struct StackNode *create_node(elemType data)
{
　　struct StackNode *node = malloc(sizeof(struct StackNode));
　　if(node == NULL){
　　　　perror("mallloc fail:");
　　　　return NULL;
　　}
　　node->data = data;
　　node->next = NULL;
　　return node;
}

//压栈--单链表头插法
bopl push_stack(Stack *top,elemType data)
{
　　if(top == NULL){
　　　　perror("栈不存在");
　　　　return false;
　　//创建一个节点
　　Stack *node = create_node(data);
　　node->next = top->next;
　　top->next = node;
　　retrun true;
}

//出栈--单链表头删法
bool delete_stack(Stack *top,elemType *data)
{
　　if(top == NULL)
　　{
　　　　perror("栈不存在");
　　　　return false;
　　}
　　Stack *node = top->next;

　　if(node == NULL)
　　{
　　　　perror("栈是空的");
　　　　return false;
　　}
　　//把node从栈上删除
　　top->next =node->next;
　　//先把node中的数据存好再删除节点
　　*data = node->data;
　　free(node);
　　node = NULL;
　　return true;
}

 1 1栈.c
 2 
 3 #include <stdio.h>
 4 #include "stack.h"
 5 
 6 int main
 7 {
 8     //创建栈
 9     Stack  *top = create_node(0);
10     
11     for(int i = 0;i<10;i++)
12     {
13         push_stack(top,i);
14     }
15     
16     //出栈
17     int data = 0;
18     while(pop_stack(top,&data))
19         printf("%d",data);
20         printf("\n");
21 
22     //栈实现进制转换
23     int obj = 0;
24     scanf("%d",&obj);
25     
26     while(obj)
27     {
28         push_stack(top,obj%2);
29         obj = obj/2;
30     }
31     while(pop_stack(top,&data));
32     printf("%d",data);
33     printf("\n");
34 
35     return 0;
36 }

队列：先进先出

下面是队列的代码：

扫描二维码关注公众号，回复： 9607882 查看本文章

1队列.c

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

typedef int elemType;
struct Node{
　　elemType data;
　　struct Node *next;
};

typedef struct _Queue
{
　　int length;
　　struct Node *start;
　　struct Node *end;
}Queue;

//创建队列
Queue *create_queue(0
{
　　Queue *q = malloc(sizeof(Queue));
　　//创建一个队列
　　q->length = 0;
　　q->start = q->end = NULL;
　　return q;
}

//入队列--链表尾插法
bool enter_queue(Queue *q,elemType data)
{
　　if(q == NULL)
　　{
　　　　perror("队列错误");　　
　　　　return false;
　　}
　　if(q->length == 0)//队列为空
　　{
　　　　struct Node *node = malloc(sizeof(struct Node));
　　　　node->data = data;
　　　　node->next = NULL;
　　　　q->start = q->end = NULL;
　　　　q->length = 1;
　　}else{
　　　　struct Node *node = malloc(sizeof(struct Node));
　　　　node->data = data;
　　　　node->next = NULL;
　　　　//node放在end后面
　　　　q->end->next = node;　　
　　　　//把end指向链表尾部
　　　　q->end = node;
　　　　q->length++;
　　}
　　return true;
}

//出队列--链表头删法
bool out_queue(Queue *q,elemType data)
{
　　if(q == NULL)
　　{
　　　　perror("队列错误");
　　　　return false;
　　}
　　if(q->length == 0)
　　{
　　　　return false;
　　}

　　//从start开始删除数据
　　if(q->start == q->end)
　　{
　　　　*data = q->start->data;
　　　　free(q->start);
　　　　q->start = q->end = NULL;
　　　　q->length = 0;
　　}else{
　　　　*data = q->start->data;
　　　　//暂存start
　　　　struct Node *tmp = q->start;
　　　　//start往后移动
　　　　q->start = q->start->next;
　　　　q->length--;
　　}
　　return true;
}

int get_queue_length(Queue *q)
{
　　if(q == NULL)
　　{
　　　　perror('队列错误");
　　　　return -1;
　　}
　　return q->length;
}

int main
{
　　Queue *q = create_queue();
　　for(int i= 0;i<10;i++)
　　{
　　　　enter_queue(q,i);
　　}

　　int data = 0;
　　while(out_queue(q,&data)
　　　　printf("%d",data);
　　return 0;
}

二叉树

树的基本概念：树只有一个根节点，多个叶节点。树的层数，树的深度，树的叶子。

二叉树：一个根节点，每个节点最多两个直接后继。

二叉树的特性：

完全二叉树：

满二叉树：

设计二叉树

struct BTree
{
    int data;
    struct BTree *lchild;
    struct BTree *rchild;
}

二叉树的遍历：

前序遍历：先根节点，在左叶子，最后右叶子。（前序遍历第一个就是根节点）

中序遍历：先左节点，再根节点，最后右节点。（中序遍历根节点左边是左边的树，右边是右边的树）

后序遍历：先左节点，再右节点，最后根节点。（后序遍历最后一个是根节点）

前序遍历：ABDEFGCH

中序遍历：DBFEGAHC

后序遍历：DFGEBHCA

前序遍历：ABCEDFGH

中序遍历：BECAGFHD

写出后序遍历

实现二叉树

原理图

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

typedef struct BTree
{
　　char data;
　　struct BTree *lchild;
　　struct BTree *rchild;
}BiTree;

//前序创建树
BiTree *create_tree()
{
　　char ch ='\0';
　　scanf("%c",&ch);
　　printf("***************%c\n",ch);
　　
　　if(ch == '#')
　　{
　　　　return NULL;
　　}else{
　　　　BiTree *root = malloc(sizeof(BiTree));
　　　　root->data = ch;
　　　　root->lchild = create_tree();
　　　　root->rchild = create_tree();
　　　　return root;
　　}
}

//三种遍历都是不停地递归，直到这边遍历完了，再递归遍历另一边
//前序遍历
void show_tree(BiTree *root)
{
　　if(root == NULL)return;
　　printf("c\n",root->data);
　　show_tree(root->lchild);
　　show_tree(root->rchild);
}

//中序遍历
void_mid_tree(BiTree *root)
{
　　if(root == NULL)return;
　　mid_tree(root->lchild);
　　printf("%c",root->data);
　　mid_tree(root->rchild);
}

//后序遍历
void tail_tree(BiTree *root)
{
　　if(root == NULL)return;
　　tail_tree(root->lchild);
　　tail_tree(root->lchild);
　　printf("%c",root->data);
}

//销毁二叉树
void destroy_tree(BiTree *root)
{
　　//后序遍历销毁
　　if(root == NULL)return;
　　destroy_tree(root->lchild);
　　destroy_tree(root->rchild);
　　free(root);
　　root = NULL;
}

int main()
{
　　BiTree *root = create_tree();
　　show_tree(root);
　　printf("\n");
　　mid_tree(root);
　　printf("\n");
　　tail_tree(root);
　　printf("\n");
　　return 0;
}

PS：有哪里写的不对的，请指正，互相学习。

栈、队列和二叉树

猜你喜欢