数据结构-函数题

6-1 求采用邻接矩阵作为存储结构的无向图各顶点的度 

本题要求实现一个函数，输出无向图每个顶点的数据元素的值，以及每个顶点度的值。

void degree(MGraph G)
{
	int i,j;
	for(i=0;i<G.vexnum;i++)
	{
		int du=0;
		for(j=0;j<G.vexnum;j++)
		{
			if(G.arcs[i][j]==1)//如果G.arcs[i][j]!=0,du++; 
			{
				du++;
			}
		}
		printf("%c:%d\n",G.vexs[i],du);
	} 
}

 6-2 顺序表的查找操作

本题要求实现一个函数，要求从顺序表中查找指定元素，并返回第一个查找成功的元素在表中的位置序号，若查找失败，则返回0；

int LocateElem(SqList L,ElemType e)
{
	int i;
	for(i=0;i<L.length;i++)
	{
		if(L.elem[i]==e)//L.elem[i] 
		{
			return i+1;
		}
	} 
	return 0;
}

 6-3 二叉树叶结点计数

实现一个函数，返回二叉树bt中叶结点的数量。

题目保证二叉树中所有元素均为整数。

/*统计二叉树中叶子结点的数目并没,有次序要求，
可以用三种遍历中的任意一种来完成.
一、后序遍历统计 
叶子结点：既没有左孩子，又没有右孩子 
*/ 
int countLeaves(struct BinTree *bt)
{
	int cnt=0;
	if(bt!=NULL)
	{
		countLeaves(bt->leftt);
		countLeaves(bt->right);
		if(bt->left==NULL&&bt->right==NULL)
		{
			cnt++;
		}
	} 
	return cnt;
}
/*
方法二：采用分治方法，如果二叉树为空树，返回0，
如果二叉树只有一个结点 ，返回1
否则为左右子树叶子结点的和 
*/
int countLeaves(struct BinTree *bt)
{
    int count=0;
    if(bt==NULL)
        return 0;
    else if(bt->left==NULL && bt->right==NULL)
        return count+1;
    else
    {
        count=countLeaves(bt->left)+countLeaves(bt->right);
        return count;
    }
}


 

 6-4 按值查找单链表

本题要求实现一个函数，Locate_LinkList(LinkList L, datatype x)函数是在带头结点单链表中查找值为x的结点。函数须返回找到结点的指针,没有找到返回空。

其中 L 和 x 都是用户传入的参数。 L 是单链表的头指针； x 是需要查找的值。函数须返回找到结点的指针,没有找到返回空。

LNode *Locate_LinkList(LinkList L, datatype x)
{
	LNode *p;
	p=L->next;
	while(p!=NULL&&p->data!=x)//当它不为空并这个数据值不等于x 
	{
		p=p->next;//则找下一个 
	}
	return p;//返回找到该节点的指针 
}

6-5二叉树层序遍历

void LevelorderTraversal( BinTree BT )
{
    BinTree A[100];
    BinTree p;
    int rear=0,front=0;
    if(BT==NULL)
       return ;
    else
    {
    	A[rear++]=BT;
    	while(rear!=front)
    	{
    		p=A[front++];
    		printf(" %c",p->Data);
    		if(p->Left)
    		    A[rear++]=p->Left;
    		if(p->Right)
    		    A[rear++]=p->Right;
		}
	}
}

6-6 单链表逆转

List Reverse( List L )
{
    List pre,temp;
    pre=NULL;
    while(L)
    {
        temp=L->Next;
        L->Next=pre;
        pre=L;
        L=temp;
    }
    return pre;
}

 6-7 求链式表的表长

int Length( List L )
{
    int len=0;
    while(L)
    {
        L=L->Next;
        len++;
    }
    return len;
}

 6-8 链式表的按序号查找

ElementType FindKth( List L, int K )
{
    if(L==NULL||K<=0)
        return ERROR;
    else
    {
        for(int i=1;i<K;i++)
        {
            if(L->Next==NULL)
                return ERROR;
            L=L->Next;
        }
        return L->Data;
    }
}

 6-9 求二叉树高度

int GetHeight( BinTree BT )
{
    int hl=0,hr=0,h;
    if(BT)
    {
        hl=GetHeight(BT->Left);
        hr=GetHeight(BT->Right);
        h=hl>hr?hl:hr;
        return h+1;
    }
    else
        return 0;
}

 6-10先序输出叶结点

void PreorderPrintLeaves( BinTree BT )
{
    if(BT)
    {
        PreorderPrintLeaves(BT->Left);
        PreorderPrintLeaves(BT->Right);
        if(BT->Left==NULL&&BT->Right==NULL)
        {
            printf(" %c",BT->Data);
        }
    }
}

6-11 二分查找

Position BinarySearch( List L, ElementType X )
{
    int l=0,r=L->Last;
    while(l<=r)
    {
        int mid=(l+r)/2;
        if(L->Data[mid]==X)
        {
            return mid;
        }
        else if(L->Data[mid]<X)
        {
            l=mid+1;
        }
        else{
            r=mid-1;
        }
    }
    return NotFound;
}

 6-12 二叉树的遍历

void InorderTraversal( BinTree BT )
{
    if(BT)
    {
        InorderTraversal(BT->Left);
        printf(" %c",BT->Data);
        InorderTraversal(BT->Right);  
    }
}
void PreorderTraversal( BinTree BT )
{
    if(BT)
    {
        printf(" %c",BT->Data);
        PreorderTraversal(BT->Left);
       PreorderTraversal(BT->Right);  
    }
}
void PostorderTraversal( BinTree BT )
{
    if(BT)
    {
         PostorderTraversal(BT->Left);
        PostorderTraversal(BT->Right); 
        printf(" %c",BT->Data);
    }
}
void LevelorderTraversal( BinTree BT )
{
    BinTree A[1100];
    BinTree p;
    int rear=0,front=0;
    if(BT)
    {
        A[rear++]=BT;
        while(rear!=front)
        {
            p=A[front++];
            printf(" %c",p->Data);
            if(p->Left)
                A[rear++]=p->Left;
            if(p->Right)
                A[rear++]=p->Right;
        }
    }
    else
        return ;
}

6-13 链式表操作集

Position Find( List L, ElementType X )
{
	while(L)
	{
		if(L->Data==X)
		    return L;
		L=L->Next;
	}
	return ERROR;
}
/*将 x插入在位置p指向的结点之前，返回链表的表头。
如果参数P指向非法位置，则打印并返回*/ 
List Insert( List L, ElementType X, Position P )
{
	if(P==L)
	{
		List Node=(List)malloc(sizeof(List));
		Node->Data=X;
		Node->Next=L;
		return Node;
	}
	List q=L;
	while(q)
	{
		if(q->Next==P)
		{
			List Node=(List)malloc(sizeof(List));
			Node->Data=X;
			Node->Next=q->Next;
			q->Next=Node;
			return L;
		}
		q=q->Next;
	}
	printf("Wrong Position for Insertion\n");
	return ERROR;
}
List Delete( List L, Position P )
{
	if(L==P)
	   return L->Next;
	List q=L;
	while(q)
	{
		if(q->Next==P)
		{
			q->Next=q->Next->Next;
			return L;
		}
		q=q->Next;
	}
	printf("Wrong Position for Deletion\n");
	return ERROR;
}

 6-14 顺序表操作集

List MakeEmpty()
{
	List L=(List)malloc(sizeof(struct LNode));
	L->Last=-1;
	return L;
}
Position Find( List L, ElementType X )
{
	for(int i=0;i<=L->Last;i++)
	{
		if(L->Data[i]==X)
		{
			return i;
		}
	}
	return ERROR;
}
bool Insert( List L, ElementType X, Position P )
{
	if(L->Last>=MAXSIZE-1)
	{
		printf("FULL");
		return false;
	}
	if(P>L->Last+1||P<0)
	{
		printf("ILLEGAL POSITION");
		return false;
	}
	for(int i=L->Last;i>=P;i--)//dengyu
	{
		L->Data[i+1]=L->Data[i]; 
	}
	L->Data[P]=X;
	L->Last++;
	return true;
}
bool Delete( List L, Position P )
{
	if(P>L->Last||P<0)
	{
		printf("POSITION %d EMPTY",P);
		return false;
	}
	for(int i=P;i<L->Last;i++)//xiaoyu
	{
		L->Data[i]=L->Data[i+1];
	}
	L->Last--;
	return true;
}

 6-15 直接插入排序

void InsertSort(SqList L)
{
	int i,j;
	int temp;
	for(i=1;i<=L.Length;i++)
	{
		for(j=i+1;j<=L.Length;j++)
		{
			if(L.elem[i]>elem[j])
			{
				temp=L.elem[j];
				L.elem[j]=L.elem[i];
				L.elem[i]=temp;
			}
		}
	}
}