数据结构部分

• 顺序有序存储的线性表，删除重复元素

/**顺序有序存储的线性表，删除重复元素*/
int purge(int a[], int n){
	int i,k=0;
	if(n>1){
		for(i=1; i<n; i++){
			if(a[i]!=a[k]){
				a[++k]=a[i];
			}
		
		}
		n=k+1;
	}
	return n;
}

 

• 前序遍历，根左右的顺序，在进栈前访问

#define M 50
/*前序遍历，根左右的顺序，在进栈前访问*/
void preOrder(BTREE T)
{
	BTREE STACK[M],p=T;
	int top=-1;
	if(T!=NULL)
		do{
			while(p!=NULL){
				VISIT(p);/*访问当前节点*/
				STACK[++top]=p;/*进栈*/
				p=p->lchild;
			
			}
			p=STACK[top--];/*退栈*/
			p=p-rchild;
		}while(!(p==NULL && top==-1));
}

• 中序遍历，左根右的顺序，在退栈后访问

#define M 50
/*中序遍历，左根右的顺序，在退栈后访问*/
void inOrder(BTREE T)
{
	BTREE STACK[M],p=T;
	int top=-1;
	if(T!=NULL)
		do{
			while(p!=NULL){
				STACK[++top]=p;/*进栈*/
				p=p->lchild;
			
			}
			p=STACK[top--];/*退栈*/
			VISIT(p);/*访问当前节点*/
			p=p-rchild;
		}while(!(p==NULL && top==-1));
}

• 后序遍历，左右根的顺序，子节点优先于根节点，所以必须2次进栈，故用一个标识是否2次进栈

#define M 50
/**后序遍历，左右根的顺序，子节点优先于根节点，所以必须2次进栈，故用一个标识是否2次进栈*/
void postOrder(BTREE T)
{
	BTREE STACK1[M],p=T;
	int STACK2[M],flag,top=-1;
	if(T!=NULL){
		do{
			while(p!=NULL){
				STACK1[++top]=p;/*进栈*/
				STACK2[top]=0;
				p=p->lchild;
			
			}
			p=STACK1[top];/*退栈*/
			flag=STACK2[top--];
			if(flag==0){/*再次进栈，右节点访问后再访问根节点*/
				STACK1[++top]=p;
				STACK2[top]=1;
				p=p->rchild;
			}else{
				VISIT(p);
				p=NULL;
			}
		}while(!(p==NULL && top==-1));
	}
}

• 层次遍历，使用队列，从上到下，从左到右

#define M 50
/*层次遍历，使用队列，从上到下，从左到右*/
void layerOrder(BTREE T){
	BTREE queue[M],p;
	int front,rear;
	if(T!=NULL){
		queue[0]=T;
		front=-1;
		rear=0;
		while(front<rear){
			p=queue[++front];
			visit(p);
			if(p->lchild!=NULL){
				queue[++rear]=p->lchild;
			}
			
			if(p->rchild!=NULL){
				queue[++rear]=p->rchild;
			}	
		}
	}
}