数据结构篇
1.栈
2.循环队列
3.基本二叉树
4.基本二叉树进阶
栈
stack.h
#pragma once
typedef struct tag{
int m_val;
struct tag *pNext;
}Node_t,*pNode_t;
typedef struct {
pNode_t phead;
int size;
}Stack_t,*pStack_t;
void initStack(pStack_t);
void pop(pStack_t);
void push(pStack_t,int);
int top(pStack_t);
int size(pStack_t);
int empty(pStack_t);
stack.c
#include "stack.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
void initStack(pStack_t stack){
memset(stack,0,sizeof(Stack_t));
}
void pop(pStack_t stack){
pNode_t pCur = stack->phead;
if(0 == stack->size)
{
return;
}else if(1 < stack->size)
{
stack->phead = pCur->pNext;
}
free(pCur);
pCur = NULL;
stack->size--;
}
void push(pStack_t stack,int val){
pNode_t pNew = (pNode_t)calloc(1,sizeof(Node_t));
pNew->m_val = val;
pNew->pNext = stack->phead;
stack->phead = pNew;
stack->size++;
}
int top(pStack_t stack){
if(!stack->size)
{
printf("stack is empty\n");
return 0;
}
return stack->phead->m_val;
}
int size(pStack_t stack){
return stack->size;
}
int empty(pStack_t stack){
return !stack->size;
}
main.c
#include "stack.h"
void func()
{
Stack_t stack;
initStack(&stack);
push(&stack,5);
printf("%d\n",top(&stack));
push(&stack,10);
printf("%d\n",top(&stack));
}
int main()
{
func();
return 0;
}
循环队列
squeue.h
#pragma once
#include <stdio.h>
#include <stdlib.h>
#define MaxSize 5
typedef int ElemType;
typedef struct{
ElemType data[MaxSize];
int front,rear;
}SqQueue_t;
void initQueue(SqQueue_t*);
void enQueue(SqQueue_t*,ElemType);
void deQueue(SqQueue_t*,ElemType*);
squeue.c
#include "squeue.h"
void initQueue(SqQueue_t* queue){
queue->front=queue->rear=0;
}
void enQueue(SqQueue_t* queue,ElemType x){ // 入队
if((queue->rear+1)%MaxSize == queue->front) // 队列满了
{
printf("queue is full\n");
}
queue->data[queue->rear] = x;
queue->rear = (queue->rear+1)%MaxSize;
}
void deQueue(SqQueue_t* queue,ElemType* x){ // 出队
if(queue->front == queue->rear)
{
printf("queue is empty\n");
return;
}
*x = queue->data[queue->front];
queue->front = (queue->front+1)%MaxSize;
}
main.c
#include <iostream>
#include "squeue.h"
void func()
{
SqQueue_t Q;
ElemType e;
initQueue(&Q);
enQueue(&Q,10);
deQueue(&Q,&e);
}
int main()
{
func();
return 0;
}
基本二叉树
main.c
#include <iostream>
#include "tree.h"
#define N 10
void func()
{
ElemType c[]="ABCDEFGHIJ";
pNode_t p[N];
int i=0,j=0;
for (i=0;i<N;++i)
{
p[i] = (pNode_t)calloc(1,sizeof(Node_t));
p[i]->c = c[i];
}
// 层次建树
for (i=1;i<N;++i) //外层控制要进树的元素
{
if(NULL == p[j]->pleft)//内层比较找位置
{
p[j]->pleft = p[i];
}else if(NULL == p[j]->pright)
{
p[j]->pright = p[i];
j++;
}
}
preOrder(p[0]); //中序遍历
printf("\n----------------------------\n");
midOrder(p[0]); // 前序遍历
printf("\n----------------------------\n");
lastOrder(p[0]); // 后序遍历
printf("\n----------------------------\n");
}
int main()
{
func();
return 0;
}
tree.h
#pragma once
#include <stdio.h>
#include <stdlib.h>
typedef char ElemType;
typedef struct node{
ElemType c;
struct node *pleft;
struct node *pright;
}Node_t,*pNode_t;
void preOrder(pNode_t);
void midOrder(pNode_t);
void lastOrder(pNode_t);
tree.cpp
#include "tree.h"
void preOrder(pNode_t root){
if(root)
{
putchar(root->c);
preOrder(root->pleft);
preOrder(root->pright);
}
}
void midOrder(pNode_t root){
if(root)
{
midOrder(root->pleft);
putchar(root->c);
midOrder(root->pright);
}
}
void lastOrder(pNode_t root){
if(root)
{
lastOrder(root->pleft);
lastOrder(root->pright);
putchar(root->c);
}
}
基本二叉树进阶
tree.h
#pragma once
#include <stdio.h>
#include <stdlib.h>
typedef char ElemType;
typedef struct node{
ElemType c;
struct node *pleft;
struct node *pright;
}Node_t,*pNode_t;
typedef struct queue_t{
pNode_t insertPos;
struct queue_t *pNext;
}Queue_t,*pQueue_t;
void preOrder(pNode_t);
void midOrder(pNode_t);
void lastOrder(pNode_t);
void buildBinaryTree(pNode_t*,pQueue_t*,pQueue_t*,ElemType);
tree.c
#include "tree.h"
void preOrder(pNode_t root){
if(root)
{
putchar(root->c);
preOrder(root->pleft);
preOrder(root->pright);
}
}
void midOrder(pNode_t root){
if(root)
{
midOrder(root->pleft);
putchar(root->c);
midOrder(root->pright);
}
}
void lastOrder(pNode_t root){
if(root)
{
lastOrder(root->pleft);
lastOrder(root->pright);
putchar(root->c);
}
}
void buildBinaryTree(pNode_t *root,pQueue_t *queH,pQueue_t *queT,ElemType val){
pNode_t treeNew = (pNode_t)calloc(1,sizeof(Node_t));
pQueue_t queNew = (pQueue_t)calloc(1,sizeof(Queue_t));
pQueue_t queCur = *queH;
treeNew->c = val;
queNew->insertPos = treeNew;
if(NULL == *root)
{
*root = treeNew;
*queH = queNew;
*queT = queNew;
}else{
(*queT)->pNext = queNew;
*queT = queNew;
if(NULL == queCur->insertPos->pleft)
{
queCur->insertPos->pleft = treeNew;
}else if(NULL == queCur->insertPos->pright)
{
queCur->insertPos->pright = treeNew;
*queH = queCur->pNext;
free(queCur);
queCur = NULL;
}
}
}
main.c
#include <iostream>
#include "tree.h"
#define N 10
void func()
{
ElemType c[]="ABCDEFGHIJ";
pNode_t p[N];
int i=0,j=0;
for (i=0;i<N;++i)
{
p[i] = (pNode_t)calloc(1,sizeof(Node_t));
p[i]->c = c[i];
}
// 层次建树
for (i=1;i<N;++i) //外层控制要进树的元素
{
if(NULL == p[j]->pleft)//内层比较找位置
{
p[j]->pleft = p[i];
}else if(NULL == p[j]->pright)
{
p[j]->pright = p[i];
j++;
}
}
preOrder(p[0]); //中序遍历
printf("\n----------------------------\n");
midOrder(p[0]); // 前序遍历
printf("\n----------------------------\n");
lastOrder(p[0]); // 后序遍历
printf("\n----------------------------\n");
}
void func_two()
{
ElemType val;
pNode_t treeRoot = NULL;
pQueue_t queH = NULL,queT = NULL;
while(scanf("%c",&val)!=EOF)
{
if(val == '\n')
{
break;
}
buildBinaryTree(&treeRoot,&queH,&queT,val);
}
preOrder(treeRoot); //中序遍历
printf("\n----------------------------\n");
midOrder(treeRoot); // 前序遍历
printf("\n----------------------------\n");
lastOrder(treeRoot); // 后序遍历
printf("\n----------------------------\n");
}
int main()
{
// func();
func_two();
return 0;
}
浙公网安备 33010602011771号