8月10 队列实现杨辉三角 二叉树 链式队列

#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;
}