数据结构代码

1.线性表

1.顺序表

typedef struct{
	int data[maxSize];
	int length;
}Sqlist; 

2.单链表

typedef struct LNode{
	int data;
	struct DLNode *next;
}LNode;

3.双链表

typedef struct DLNode{
	int data;
	struct DLNode *prior;
	struct DLNode *next;
}DLNode;

2.栈和队列

1.顺序栈

int stack[maxSize];
int top=-1;
进栈：stack[++top]=x;
出栈：x=stack[top--];
	

2.链栈

typedef struct LNode{
	int data;
	struct LNode *next;
}lst;
栈空： lst->next==NULL; 
进栈： p->next=lst->next; lst->next=p;
出栈： p=lst->next; x=p->data; lst->next=p->next; free(p);

3.顺序队列

typedef struct{
	int data[maxSize];
	int front,reat;
}SeQueue;
进队：qu.rear=(qu.rear+1)%maxsize; qu.data[qu.rear]=x;
出队：qu.front=(qu.front+1)%maxsize; x=qu.data[qu.front];
判空：qu.rear==qu.front; 

4.链队

typedef	struct QNode{
	int data;
	struct QNode *next;
}QNode;
typedef struct{
	QNode *front;
	QNode *rear;
}LiQueue;
队空：lqu->rear==NULL 或者 lqu->front==NULL
进队: lqu->rear->next=p;lqu->rear=p;
出队：p=lqu->front;lqu->front=p->next;x=p->data;free(p);

3.树与二叉树

1.二叉链表

typedef struct BTNode
{
	char data;
	struct BTNode *lchild;
	stryct BTNode *rchild;
}BTNode;

2.先序遍历

void preorder(BTNode *p)
{
	if(p!=NULL)
	{
		visit(p); //1.前
		preorder(p->lchild);
		//2.中
		preorder(p->rchild);
		//3.后
	}
}

3.中缀表达式求值问题

int comp(BTNode *p)
{
	int A,B;
	if(p!=NULL)	
	{
		if(p->lchild!=NULL&&p->rchild!=NULL)
		{
			A=comp(p->lchild);
			B=comp(p->rchild);
			return op(A,B,p->data);
		}
		else	return p->data-'0';
	}
	else return 0;
}

4.求二叉树的深度

int getDepth(BTNode *p)
{
	int LD,RD;
	if(!p)	return 0;
	else
	{
		LD=getDepth(p->lchild);
		RD=getDepth(p->rchild);
		return (LD>RD?LD:RD)+1;
	}
}

5.先序遍历第K个值

int n=0;
void trave(BTNode *p,int k)
{
	if(p!=NULL)
	{
		++n;
		if(k==n)	{cout<<p->data<<endl; return ;}
		trave(p->lchild,k);
		trave(p->rchild,k);
	}
}	

6.层序遍历

void level(BTNode *p)
{
	int front,rear;
	BTNode *que[maxSize];
	front=rear=0;
	BTNode *q;
	if(p!=NULL)
	{
		rear=(rear+1)%maxSize;
		que[rear]=p;
		while(front!=rear)
		{
			front=(front+1)%maxSize;
			q=que[front];
			visit(q);
			if(q->lchild!=NULL)	{rear=(rear+1)%maxSize;que[rear]=q->lchild;}
			if(q->rchild!=NULL)	{rear=(rear+1)%maxSize;que[rear]=q->rchild;}
		}
	}
}

7.先序非递归

void preorder(BTNode *bt)
{
	if(!bt)
	{
		BTNode *Stack[maxSize];
		int top=-1;
		BTNode *p;
		Stack[++top]=bt;
		while(top!=-1)
		{
			p=Stack[top--];
			visit(p);
			if(p->rchild!=NULL)	Stack[++top]=p->rchild;
			if(p->lchild!=NULL)	Stack[++top]=p->lchild;
		}
	}

8.中序非递归

1.根结点入栈
2.循环执行，若栈顶左存在，则左入栈；若不存在则输出栈顶并检查右，如右存在则右入栈
3.栈空时结束

9.后序非递归

void preorder(BTNode *bt)
{
	if(!bt)
	{
		BTNode *Stack1[maxSize]，*Stack2[maxSize];
		int top1=-1,top2=-1;
		BTNode *p;
		Stack1[++top]=bt;
		while(top1!=-1)
		{
			p=Stack1[top--];
			Stack2[++top2];
			visit(p);
			if(p->lchild!=NULL)	Stack1[++top]=p->lchild;
			if(p->rchild!=NULL)	Stack1[++top]=p->rchild;
		}
	}
	while(top2!=-1)
	{
		p=Stack[top2--];
		visit(p);
	}
}

4.图

typedef struct
{
	int edges[maxSize][maxSize];
	int n,e;
	VertexType vex[maxSize];
}MGraph;