#include<stdio.h>
#include<stdlib.h>
#include"queue.h"
void Traverse(Queue q)
{
int i;
for(i = q.front;i != q.rear ;i++)
{
if(q.data[i] != 0)
{
printf("%d ",q.data[i]);
}
}
printf("\n");
}
int main()
{
int ret, num, i, top;
Queue q1, q2;
if(init(&q1) != SUCCESS || init(&q2) !=SUCCESS)
{
printf("Init failure\n");
exit(1);
}
printf("please input line:\n");
scanf("%d", &num);
for(i = 0;i < num;i++)
{
if(i == 0)
{
Enterqueue(&q1, 0);
Enterqueue(&q1, 1);
Enterqueue(&q1, 0);
}
else
{
while(Length(q1) != 1)
{
top = Delete(&q1);
Enterqueue(&q2, top + Getfront(q1));
}
while(Length(q2) != 0)
{
Enterqueue(&q1, Delete(&q2));
}
Enterqueue(&q1, 0);
}
Traverse(q1);
}
return 0;
}
#include<stdio.h>
#include"queue.h"
int init(Queue *q)
{
if(NULL == q)
{
return FAILURE;
}
q->rear = q->front = 0;
return SUCCESS;
}
int Empty(Queue q)
{
return (q.front == q.rear) ? TRUE :FALSE;
}
int Enterqueue(Queue *q, int e)
{
if(NULL == q)
{
return FAILURE;
}
if((q->rear + 1) % SIZE == q->front)
{
return FAILURE;
}
q->data[q->rear] = e;
q->rear = (q->rear + 1) % SIZE;
return SUCCESS;
}
int Getfront(Queue q)
{
if(q.rear == q.front)
{
return FAILURE;
}
return q.data[q.front];
}
int Length(Queue q)
{
return (q.rear - q.front + SIZE )% SIZE;
}
int Delete(Queue *q)
{
if(NULL == q)
{
return FAILURE;
}
if(q->rear == q->front)
{
return FAILURE;
}
int e = q->data[q->front];
q->front = (q->front + 1) % SIZE;
return e;
}
int Clear(Queue *q)
{
if(NULL == q)
{
return FAILURE;
}
q->front = q->rear;
return SUCCESS;
}
#ifndef _QUEUE_H
#define _QUEUE_H
#define SIZE 1000
#define SUCCESS 10000
#define FAILURE 10001
#define TRUE 10002
#define FALSE 10003
struct queue
{
int data[SIZE];
int front; //队头指针(下标)
int rear; //队尾指针
};
typedef struct queue Queue;
int init(Queue *q);
int Empty(Queue q);
int Enterqueue(Queue *q, int e);
int Getfront(Queue q);
int Length(Queue q);
二叉树遍历
#include<stdio.h>
#include<stdlib.h>
struct node
{
int data;
struct node *right, *left;
};
typedef struct node TreeNode;
TreeNode *CreateTree(int *a)
{
int i;
TreeNode *node[11] = {0};
for(i = 0;i < 10;i++)
{
node[i] = (TreeNode *)malloc(sizeof(TreeNode));
if(NULL == node[i])
{
printf("malloc error!\n");
}
node[i]->data = a[i];
node[i]->right = NULL;
node[i]->left = NULL;
}
for(i = 0;i < 10 / 2;i++)
{
node[i]->left = node[2 * i + 1];
node[i]->right = node[2 * i + 2];
}
return node[0];
};
int PreOrder(TreeNode *T) //前序遍历 根左右
{
if(NULL == T)
{
return 1;
}
printf("%d ",T->data);
PreOrder(T->left);
PreOrder(T->right);
return 0;
}
int InOrder(TreeNode *T) //中序 左根右
{
if(NULL == T)
{
return 1;
}
InOrder(T->left);
printf("%d ",T->data);
InOrder(T->right);
return 0;
}
int BeOrder(TreeNode *T) //后序 左右根
{
if(NULL == T)
{
return 1;
}
BeOrder(T->left);
BeOrder(T->right);
printf("%d ",T->data);
return 0;
}
int main()
{
int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
TreeNode *root;
root = CreateTree(a);
PreOrder(root);
printf("\n");
InOrder(root);
printf("\n");
BeOrder(root);
printf("\n");
return 0;
}
链式队列
#ifndef _LINKQUEUE_H
#define _LINKQUEUE_H
#define SUCCESS 10000
#define FAILURE 10001
#define TRUE 10002
#define FALSE 10003
struct node
{
int data;
struct node *next;
};
typedef struct node Node;
struct queue
{
Node *front;
Node *rear;
};
typedef struct queue Q;
int init(Q **s);
int insert(Q *s,int e);
int deletequeue(Q *q);
int empty(Q *q);
int getfirst(Q *q);
int destroy(Q **q);
int clear(Q *q);
#endif
#include<stdlib.h>
#include<stdio.h>
#include"linkqueue.h"
int init(Q **s)
{
(*s) = (Q *)malloc(sizeof(Q));
if(NULL == (*s))
{
return FAILURE;
}
Node *p = (Node *)malloc(sizeof(Node));
if(NULL == p)
{
return FAILURE;
}
p->next = NULL;
(*s)->front = (*s)->rear = p;
return SUCCESS;
}
int insert(Q *s,int e)
{
if(NULL == s)
{
return FAILURE;
}
Node *q = (Node *)malloc(sizeof(Node));
if(NULL == q)
{
return FAILURE;
}
q->data = e;
q->next = NULL;
s->rear->next = q;
s->rear = q;
return SUCCESS;
}
int deletequeue(Q *q)
{
if(NULL == q || q->rear == q->front)
{
return FAILURE;
}
int e;
Node *p = q->front->next;
e = p->data;
q->front->next = p->next;
if(!p->next)
{
q->rear = q->front;
}
free(p);
return e;
}
int getfirst(Q *q)
{
if(NULL == q || q->rear == q->front)
{
return FAILURE;
}
return q->front->next->data;
}
int empty(Q *q)
{
if(NULL == q)
{
return FAILURE;
}
return (q->front == q->rear) ? TRUE : FALSE;
}
int clear(Q *q)
{
if(NULL == q)
{
return FAILURE;
}
Node *p = q->front->next;
while(p)
{
q->front->next = p->next;
free(p);
p = q->front->next;
}
q->rear = q->front; //防止rear成为野指针
return SUCCESS;
}
int destroy(Q **q)
{
if(q == NULL || (*q) == NULL)
{
return FAILURE;
}
free((*q)->front);
free(*q);
*q = NULL;
return SUCCESS;
}
#include<stdio.h>
#include"linkqueue.h"
int main()
{
Q *queue;
int ret, i;
ret = init(&queue);
if(ret == SUCCESS)
{
printf("init success\n");
}
else
{
printf("init failure\n");
}
for(i = 0;i < 5;i++)
{
ret = insert(queue, i);
if(ret == SUCCESS)
{
printf("insert %d success\n",i);
}
else
{
printf("insert %d failure\n",i);
}
}
for(i = 0;i < 3;i++)
{
ret = deletequeue(queue);
if(ret == FAILURE)
{
printf("delete failure\n");
}
else
{
printf("delete %d success\n",ret);
}
}
ret = getfirst(queue);
if(ret == FAILURE)
{
printf("get failure\n");
}
else
{
printf("first is %d\n",ret);
}
ret = empty(queue);
if(ret == TRUE)
{
printf("empty\n");
}
else
{
printf("not empty\n",ret);
}
ret = clear(queue);
if(ret == FAILURE)
{
printf("clear failure\n");
}
else
{
printf("clear success\n");
}
ret =destroy(&queue);
if(ret == FAILURE)
{
printf("destroy failure\n");
}
else
{
printf("destroy success\n");
}
return 0;
}