数据结构与算法20170804

本文介绍数据结构与算法的知识，相信很多人在学校都学习过，同时为了贴近实际，文章直接附上编译通过可直接使用的源码。

一、数据结构

1.线性表：

1)带头结点的链表

/*****************************************************************************
* Copyright (C) 2017-2018 Hanson Yu  All rights reserved.
------------------------------------------------------------------------------
* File Module        :     LinkList.c
* Description        :     LinkList operation center
* Created            :     2017.03.02.
* Author            :     Yu Weifeng
* Function List         :     
* Last Modified     :     
* History            :     
******************************************************************************/
#include"stdio.h"
#include"malloc.h"
#include"stdlib.h"
#include"string.h"

typedef struct LinkList
{
    char cData;
    struct LinkList *pNext;
}T_LinkList,*PT_LinkList;
#define LINK_LIST_LEN 10

static int CreatLinkList(PT_LinkList *o_ptLinkListHead);
static int LinkListInsert(T_LinkList *i_ptLinkListHead,int i_dwPosition,int i_dwElement);
static int LinkListDelete(T_LinkList *i_ptLinkListHead,int i_dwPosition,int *o_dwElement);
static int LinkListTraverse(T_LinkList *i_ptLinkListHead);
/*****************************************************************************
-Fuction        : main
-Description    : main
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/03/29      V1.0.0         Yu Weifeng       Created
******************************************************************************/
int main(int argc,char **argv)
{
    int dwElement=0;
    PT_LinkList ptLinkListHead=NULL;
    CreatLinkList(&ptLinkListHead);
    LinkListInsert(ptLinkListHead,1,1);
    LinkListInsert(ptLinkListHead,2,23);
    LinkListInsert(ptLinkListHead,3,24);
    LinkListInsert(ptLinkListHead,4,26);
    LinkListInsert(ptLinkListHead,5,66);
    LinkListInsert(ptLinkListHead,6,99);
    
    printf("插入结果:");
    LinkListTraverse(ptLinkListHead);
    LinkListDelete(ptLinkListHead,6,&dwElement);
    LinkListDelete(ptLinkListHead,4,&dwElement);
    
    printf("删除结果:");
    LinkListTraverse(ptLinkListHead);
    
    printf("插入结果:");
    LinkListInsert(ptLinkListHead,3,5);
    LinkListTraverse(ptLinkListHead);
    return 0;
}
/*****************************************************************************
-Fuction        : CreatLinkList
-Description    : CreatLinkList
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/03/29      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int CreatLinkList(PT_LinkList *o_ptLinkListHead)
{//鐢熸垚涓€涓�ご缁撶偣
    int ret=-1;
    *o_ptLinkListHead=(T_LinkList *)malloc(sizeof(T_LinkList));// 产生头结点，并使L指向此头结点
    if(NULL==*o_ptLinkListHead)
    {
        printf("LinkListErr
");
        ret=-1;
    }
    else
    {
        (*o_ptLinkListHead)->pNext=NULL;
        ret=0;
    }
    return ret;
}
/*****************************************************************************
-Fuction        : LinkListInsert
-Description    : LinkListInsert
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/03/29      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int LinkListInsert(T_LinkList *i_ptLinkListHead,int i_dwPosition,int i_dwElement)
{
    int ret=-1;
    T_LinkList *pLinkListNode=i_ptLinkListHead;
    T_LinkList *pInsertListNode=NULL;    
    int j=0;
    while((pLinkListNode!=NULL)&&(j<i_dwPosition-1))//寻找插入位置的前一个结点(计算表长(包含头结点)进行比较)
    {//插入位置小于等于1直接退出，没有判断pLinkListNode!=NULL
        pLinkListNode=pLinkListNode->pNext;//计算表长，插入位置的前一个结点包括头结点(第一个位置的时候)，
        //所以长度包含头结点
        j++;//插入位置的前一个结点或者链表长度不够时表示链表长度
    }    
    if((pLinkListNode==NULL)||(j>i_dwPosition-1))
    {//链表长度不够为NULL，或者插入位置小于1异常，(第一个位置为1)
        ret=-1;        
        printf("InsertPositionErr,Len:%d,Pos:%d
",j,i_dwPosition);
    }
    else
    {
        pInsertListNode=(T_LinkList *)malloc(sizeof(T_LinkList));
        if(NULL==pInsertListNode)
        {
            printf("pInsertListNodeMallocErr
");
            ret=-1;
        }    
        else
        {
            pInsertListNode->pNext=NULL;
            pInsertListNode->cData=i_dwElement;
            pInsertListNode->pNext=pLinkListNode->pNext;
            pLinkListNode->pNext=pInsertListNode;
            ret=0;
        }
    }
    return ret;
}

/*****************************************************************************
-Fuction        : LinkListDelete
-Description    : LinkListDelete
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/03/29      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int LinkListDelete(T_LinkList *i_ptLinkListHead,int i_dwPosition,int *o_dwElement)
{
    int ret=-1;
    T_LinkList *ptLinkListNode=i_ptLinkListHead;
    T_LinkList *ptDeleteListNode=NULL;
    int j=0;
    while((ptLinkListNode->pNext!=NULL)&&(j<i_dwPosition-1))//找到删除点的前驱
    {
        ptLinkListNode=ptLinkListNode->pNext;
        j++;
    }
    if((NULL==ptLinkListNode->pNext)||(j>i_dwPosition-1))
    {
        ret=-1;
        printf("LinkListDeleteErr,Len:%d,Pos:%d
",j,i_dwPosition);
    }
    else
    {
        ptDeleteListNode=ptLinkListNode->pNext;
        *o_dwElement=ptDeleteListNode->cData;
        ptLinkListNode->pNext=ptDeleteListNode->pNext;
        free(ptDeleteListNode);
        ret=0;
    }
    return ret;
}
/*****************************************************************************
-Fuction        : LinkListDelete
-Description    : LinkListDelete
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/03/29      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int LinkListTraverse(T_LinkList *i_ptLinkListHead)
{
    int ret=-1;
    T_LinkList *ptLinkListNode=i_ptLinkListHead;
    if(ptLinkListNode->pNext==NULL)
    {
        printf("LinkListTraverseErr,LinkListEmpty
");
    }
    else
    {
        while(NULL!=ptLinkListNode->pNext)
        {
            ptLinkListNode=ptLinkListNode->pNext;
            printf("%d ",ptLinkListNode->cData);
        }
        printf("
");
        ret=0;
    }
    return ret;
}

2)带头结点表意更清晰的链表

/*****************************************************************************
* Copyright (C) 2017-2018 Hanson Yu  All rights reserved.
------------------------------------------------------------------------------
* File Module        :     LinkList.c
* Description        :     LinkList operation center
* Created            :     2017.03.02.
* Author            :     Yu Weifeng
* Function List         :     
* Last Modified     :     
* History            :     
******************************************************************************/
#include"stdio.h"
#include"malloc.h"
#include"stdlib.h"
#include"string.h"

typedef struct LinkListElement
{
    char cData;
}T_LinkListElement,*PT_LinkListElement;

typedef struct LinkList
{
    T_LinkListElement tData;
    struct LinkList *ptNext;
}T_LinkList,*PT_LinkList;
#define LINK_LIST_LEN 10

static int InitLinkList(PT_LinkList *o_pptLinkListHead);
static int InsertNodeToLinkList(T_LinkList *i_ptLinkListHead,int i_dwPosition,T_LinkListElement *i_ptElement);
static int DeleteNodeFromLinkList(T_LinkList *i_ptLinkListHead,int i_dwPosition,T_LinkListElement *o_ptElement);
static int TraverseLinkList(T_LinkList *i_ptLinkListHead);
/*****************************************************************************
-Fuction        : main
-Description    : main
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/03/29      V1.0.0         Yu Weifeng       Created
******************************************************************************/
int main(int argc,char **argv)
{
    PT_LinkList ptLinkListHead=NULL;
    T_LinkListElement tLinkListElement;
    InitLinkList(&ptLinkListHead);
    tLinkListElement.cData=1;
    InsertNodeToLinkList(ptLinkListHead,1,&tLinkListElement);
    tLinkListElement.cData=23;
    InsertNodeToLinkList(ptLinkListHead,2,&tLinkListElement);
    tLinkListElement.cData=24;
    InsertNodeToLinkList(ptLinkListHead,3,&tLinkListElement);
    tLinkListElement.cData=26;
    InsertNodeToLinkList(ptLinkListHead,4,&tLinkListElement);
    tLinkListElement.cData=66;
    InsertNodeToLinkList(ptLinkListHead,5,&tLinkListElement);
    tLinkListElement.cData=99;
    InsertNodeToLinkList(ptLinkListHead,6,&tLinkListElement);
    
    printf("插入结果:");
    TraverseLinkList(ptLinkListHead);
    DeleteNodeFromLinkList(ptLinkListHead,6,&tLinkListElement);
    DeleteNodeFromLinkList(ptLinkListHead,4,&tLinkListElement);
    
    printf("删除结果:");
    TraverseLinkList(ptLinkListHead);
    
    printf("插入结果:");
    tLinkListElement.cData=5;
    InsertNodeToLinkList(ptLinkListHead,3,&tLinkListElement);
    TraverseLinkList(ptLinkListHead);
    return 0;
}
/*****************************************************************************
-Fuction        : InitLinkList
-Description    : InitLinkList
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/03/29      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int InitLinkList(PT_LinkList *o_pptLinkListHead)
{//鐢熸垚涓€涓�ご缁撶偣
    int ret=-1;
    *o_pptLinkListHead=(T_LinkList *)malloc(sizeof(T_LinkList));// 产生头结点，并使L指向此头结点
    if(NULL==*o_pptLinkListHead)
    {
        printf("LinkListErr
");
        ret=-1;
    }
    else
    {
        (*o_pptLinkListHead)->ptNext=NULL;
        ret=0;
    }
    return ret;
}
/*****************************************************************************
-Fuction        : GetLinkListLength
-Description    : GetLinkListLength
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/03/29      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int GetLinkListLength(T_LinkList *i_ptLinkListHead)
{
    int iLength=0;
    T_LinkList *ptLinkListNode=NULL;
    if(NULL==i_ptLinkListHead)
    {
        printf("ListNull,GetLinkListLength err
");
    }
    else
    {
        ptLinkListNode=i_ptLinkListHead->ptNext;//头结点指向的下一个为开始放结点的地方
        while(NULL!=ptLinkListNode)
        {
            iLength++;
            ptLinkListNode=ptLinkListNode->ptNext;
        }
    }
    return iLength;
}

/*****************************************************************************
-Fuction        : InsertNodeToLinkList
-Description    : InsertNodeToLinkList
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/03/29      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int InsertNodeToLinkList(T_LinkList *i_ptLinkListHead,int i_dwPosition,T_LinkListElement *i_ptElement)
{
    int ret=-1;
    T_LinkList *ptLinkListNode=i_ptLinkListHead;
    T_LinkList *ptInsertListNode=NULL;    
    int iLen=0;
    iLen=GetLinkListLength(i_ptLinkListHead);
    if(i_dwPosition<1||i_dwPosition-1>iLen)
    {
        ret=-1;        
        printf("InsertPositionErr,Len:%d,Pos:%d
",iLen,i_dwPosition);
    }
    else
    {
        while(--i_dwPosition)
        {
            ptLinkListNode=ptLinkListNode->ptNext;
        }
        ptInsertListNode=(T_LinkList *)malloc(sizeof(T_LinkList));
        if(NULL==ptInsertListNode)
        {
            printf("pInsertListNodeMallocErr
");
            ret=-1;
        }    
        else
        {
            ptInsertListNode->ptNext=NULL;
            memcpy(&ptInsertListNode->tData,i_ptElement,sizeof(T_LinkListElement));
            ptInsertListNode->ptNext=ptLinkListNode->ptNext;
            ptLinkListNode->ptNext=ptInsertListNode;
            ret=0;
        }
    }
    return ret;
}

/*****************************************************************************
-Fuction        : DeleteNodeFromLinkList
-Description    : DeleteNodeFromLinkList
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/03/29      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int DeleteNodeFromLinkList(T_LinkList *i_ptLinkListHead,int i_dwPosition,T_LinkListElement *o_ptElement)
{
    int ret=-1;
    T_LinkList *ptLinkListNode=i_ptLinkListHead;
    T_LinkList *ptDeleteListNode=NULL;
    int iLen=0;
    iLen=GetLinkListLength(i_ptLinkListHead);
    if(i_dwPosition<1||i_dwPosition>iLen)
    {
        ret=-1;
        printf("LinkListDeleteErr,Len:%d,Pos:%d
",iLen,i_dwPosition);
    }
    else
    {
        while(--i_dwPosition)
        {
            ptLinkListNode=ptLinkListNode->ptNext;
        }
        ptDeleteListNode=ptLinkListNode->ptNext;
        memcpy(o_ptElement,&ptDeleteListNode->tData,sizeof(T_LinkListElement));
        ptLinkListNode->ptNext=ptDeleteListNode->ptNext;
        free(ptDeleteListNode);
        ret=0;
    }
    return ret;
}
/*****************************************************************************
-Fuction        : TraverseLinkList
-Description    : TraverseLinkList
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/03/29      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int TraverseLinkList(T_LinkList *i_ptLinkListHead)
{
    int ret=-1;
    T_LinkList *ptLinkListNode=i_ptLinkListHead;
    if(ptLinkListNode->ptNext==NULL)
    {
        printf("LinkListTraverseErr,LinkListEmpty
");
    }
    else
    {
        while(NULL!=ptLinkListNode->ptNext)
        {
            ptLinkListNode=ptLinkListNode->ptNext;
            printf("%d ",ptLinkListNode->tData.cData);
        }
        printf("
");
        ret=0;
    }
    return ret;
}

3)不带头结点表意更清晰的链表

/*****************************************************************************
* Copyright (C) 2017-2018 Hanson Yu  All rights reserved.
------------------------------------------------------------------------------
* File Module        :     LinkList.c
* Description        :     LinkList operation center
* Created            :     2017.03.02.
* Author            :     Yu Weifeng
* Function List         :     
* Last Modified     :     
* History            :     
******************************************************************************/
#include"stdio.h"
#include"malloc.h"
#include"stdlib.h"
#include"string.h"
#include "AdjacencyListGraph.h"

/*typedef struct LinkListElement
{
    char cData;
}T_LinkListElement,*PT_LinkListElement;

typedef struct LinkList
{
    T_LinkListElement tData;
    struct LinkList *ptNext;
}T_LinkList,*PT_LinkList;*/
typedef T_ArcNode T_LinkList;

#define LINK_LIST_LEN 10

static int InsertNodeToLinkList(T_LinkList **i_pptLinkListHead,int i_dwPosition,T_LinkListElement *i_ptElement);
static int DeleteNodeFromLinkList(T_LinkList **i_pptLinkListHead,int i_dwPosition,T_LinkListElement *o_ptElement);
static int TraverseLinkList(T_LinkList *i_ptLinkListHead);
static void ClearLinkList(T_LinkList *i_ptLinkListHead);

#define DestroyLinkList ClearLinkList // DestroyList()和ClearList()的操作是一样的

/*****************************************************************************
-Fuction        : main
-Description    : main
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/03/29      V1.0.0         Yu Weifeng       Created
******************************************************************************/
/*int main(int argc,char **argv)
{
    PT_LinkList ptLinkListHead=NULL;
    T_LinkListElement tLinkListElement;
    tLinkListElement.cData=1;
    InsertNodeToLinkList(&ptLinkListHead,1,&tLinkListElement);
    tLinkListElement.cData=23;
    InsertNodeToLinkList(&ptLinkListHead,2,&tLinkListElement);
    tLinkListElement.cData=24;
    InsertNodeToLinkList(&ptLinkListHead,3,&tLinkListElement);
    tLinkListElement.cData=26;
    InsertNodeToLinkList(&ptLinkListHead,4,&tLinkListElement);
    tLinkListElement.cData=66;
    InsertNodeToLinkList(&ptLinkListHead,5,&tLinkListElement);
    tLinkListElement.cData=99;
    InsertNodeToLinkList(&ptLinkListHead,6,&tLinkListElement);
    
    printf("插入结果:");
    TraverseLinkList(ptLinkListHead);
    DeleteNodeFromLinkList(&ptLinkListHead,6,&tLinkListElement);
    DeleteNodeFromLinkList(&ptLinkListHead,4,&tLinkListElement);
    
    printf("删除结果:");
    TraverseLinkList(ptLinkListHead);
    
    printf("插入结果:");
    tLinkListElement.cData=5;
    InsertNodeToLinkList(&ptLinkListHead,3,&tLinkListElement);
    TraverseLinkList(ptLinkListHead);
    return 0;
}*/
/*****************************************************************************
-Fuction        : GetLinkListLength
-Description    : GetLinkListLength
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/03/29      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int GetLinkListLength(T_LinkList *i_ptLinkListHead)
{
    int iLength=0;
    T_LinkList *ptLinkListNode=i_ptLinkListHead;
    if(NULL==ptLinkListNode)
    {
        //printf("ListNull
");
    }
    else
    {
        while(NULL!=ptLinkListNode)
        {
            iLength++;
            ptLinkListNode=ptLinkListNode->ptNext;
        }
    }
    return iLength;
}

/*****************************************************************************
-Fuction        : InsertNodeToLinkList
-Description    : InsertNodeToLinkList
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/03/29      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int InsertNodeToLinkList(T_LinkList **i_pptLinkListHead,int i_dwPosition,T_LinkListElement *i_ptElement)
{
    int ret=-1;
    T_LinkList *ptLinkListNode=*i_pptLinkListHead;
    T_LinkList *ptInsertListNode=NULL;    
    int iLen=0;
    int iPreInsertPos=0;
    iLen=GetLinkListLength(ptLinkListNode);
    if(i_dwPosition<1||i_dwPosition-1>iLen)
    {// i值不合法// i大于表长+1
        ret=-1;        
        printf("InsertPositionErr,Len:%d,Pos:%d
",iLen,i_dwPosition);
    }
    else
    {
        ptInsertListNode=(T_LinkList *)malloc(sizeof(T_LinkList));
        if(NULL==ptInsertListNode)
        {
            printf("pInsertListNodeMallocErr
");
            ret=-1;
        }    
        else
        {
            ptInsertListNode->ptNext=NULL;
            memcpy(&ptInsertListNode->tData,i_ptElement,sizeof(T_LinkListElement));
            if(1==i_dwPosition)// 插在表头
            {
                ptInsertListNode->ptNext=*i_pptLinkListHead;
                *i_pptLinkListHead=ptInsertListNode;// 改变L
            }
            else
            {
                iPreInsertPos=i_dwPosition-1;
                while(--iPreInsertPos)// 寻找第i-1个结点插入点的前一个位置
                {//不能直接用插入点的位置，因为插入点前一个位置的next指针也要修改
                    ptLinkListNode=ptLinkListNode->ptNext;//前一个结点的next指针修改后才能连接起来
                }
                ptInsertListNode->ptNext=ptLinkListNode->ptNext;//原先结点放到现在后面
                ptLinkListNode->ptNext=ptInsertListNode;//与前一个结点连接
            }
            ret=0;
        }
    }
    return ret;
}

/*****************************************************************************
-Fuction        : DeleteNodeFromLinkList
-Description    : DeleteNodeFromLinkList
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/03/29      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int DeleteNodeFromLinkList(T_LinkList **i_pptLinkListHead,int i_dwPosition,T_LinkListElement *o_ptElement)
{
    int ret=-1;
    T_LinkList *ptLinkListNode=*i_pptLinkListHead;
    T_LinkList *ptDeleteListNode=NULL;
    int iLen=0;
    int iPreDeletePos=0;
    iLen=GetLinkListLength(ptLinkListNode);
    if(i_dwPosition<1||i_dwPosition>iLen||(0==iLen))
    {// i值不合法// i大于表长//空表
        ret=-1;
        printf("LinkListDeleteErr,Len:%d,Pos:%d
",iLen,i_dwPosition);
    }
    else
    {
        if(1==i_dwPosition)
        {
            memcpy(o_ptElement,&ptLinkListNode->tData,sizeof(T_LinkListElement));
            *i_pptLinkListHead=ptLinkListNode->ptNext;// L由第2个结点开始
            free(ptLinkListNode);// 删除并释放第1个结点
        }
        else
        {
            iPreDeletePos=i_dwPosition-1;
            while(--iPreDeletePos)//寻找第i-1个结点
            {
                ptLinkListNode=ptLinkListNode->ptNext;
            }
            ptDeleteListNode=ptLinkListNode->ptNext;// 删除并释放结点
            memcpy(o_ptElement,&ptDeleteListNode->tData,sizeof(T_LinkListElement));
            ptLinkListNode->ptNext=ptDeleteListNode->ptNext;
            free(ptDeleteListNode);
        }
        ret=0;
    }
    return ret;
}
/*****************************************************************************
-Fuction        : TraverseLinkList
-Description    : TraverseLinkList
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/03/29      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int TraverseLinkList(T_LinkList *i_ptLinkListHead)
{
    int ret=-1;
    T_LinkList *ptLinkListNode=i_ptLinkListHead;
    if(ptLinkListNode==NULL)
    {
        printf("LinkListTraverseErr,LinkListEmpty
");
    }
    else
    {
        while(NULL!=ptLinkListNode)
        {
            //printf("%d ",ptLinkListNode->tData.cData);
            ptLinkListNode=ptLinkListNode->ptNext;
        }
        printf("
");
        ret=0;
    }
    return ret;
}

/*****************************************************************************
-Fuction        : ClearLinkList
-Description    : ClearLinkList
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/03/29      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void ClearLinkList(T_LinkList *i_ptLinkListHead)
{ // 初始条件：线性表L已存在。操作结果：将L重置为空表(见图2
13)
    T_LinkList *ptLinkListNode;
    while(i_ptLinkListHead) // L不空
    {
        ptLinkListNode=i_ptLinkListHead; // p指向首元结点
        i_ptLinkListHead=i_ptLinkListHead->ptNext; // L指向第2个结点(新首元结点)
        free(ptLinkListNode); // 释放首元结点
    }
}

/*****************************************************************************
-Fuction        : GetLinkListNodeLocation
-Description    : GetLinkListNodeLocation
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/03/29      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int GetLinkListNodeLocation(T_LinkList *i_ptLinkListHead,T_LinkListElement *i_ptElement,int (*Compare)(T_LinkListElement *i_ptElement1,T_LinkListElement *i_ptElement2))
{
    int iLocation=0;
    T_LinkList *ptLinkListNode=i_ptLinkListHead;
    while(NULL!=ptLinkListNode)
    {
        iLocation++;
        if(0==Compare(&ptLinkListNode->tData,i_ptElement))
        {
            break;
        }
        else
        {
            ptLinkListNode=ptLinkListNode->ptNext;
        }
    }
    if(NULL==ptLinkListNode)
    {
        iLocation=0;//没找到返回0
    }
    else
    {
    }
    return iLocation;
}

/*****************************************************************************
-Fuction        : GetLinkListNodePoint
-Description    : GetLinkListNodePoint
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/03/29      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static T_LinkList *GetLinkListNodePoint(T_LinkList *i_ptLinkListHead,T_LinkListElement *i_ptElement,int (*Compare)(T_LinkListElement *i_ptElement1,T_LinkListElement *i_ptElement2),T_LinkList **o_pptElementPreNode)
{
    int i,j;
    T_LinkList *ptLinkListNode=NULL;
    i=GetLinkListNodeLocation(i_ptLinkListHead,i_ptElement,Compare);
    if(0==i)
    {
    }
    else
    {
        if(1==i)
        {
            ptLinkListNode=i_ptLinkListHead;
            *o_pptElementPreNode=NULL;//前驱为null
        }
        else
        {
            ptLinkListNode=i_ptLinkListHead;    
            for(j=2;j<i;j++)
            {
                ptLinkListNode=ptLinkListNode->ptNext;
            }
            *o_pptElementPreNode=ptLinkListNode;
            ptLinkListNode=ptLinkListNode->ptNext;
        }
    }
    return ptLinkListNode;
}

/*****************************************************************************
-Fuction        : DeleteElementFromLinkList
-Description    : DeleteElementFromLinkList
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/03/29      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int DeleteElementFromLinkList(T_LinkList *i_ptLinkListHead,T_LinkListElement *m_ptElement,int (*Compare)(T_LinkListElement *i_ptElement1,T_LinkListElement *i_ptElement2))
{
    int iRet=-1;
    T_LinkList *ptLinkListNode=NULL;
    T_LinkList *ptLinkListPreNode=NULL;
    
    ptLinkListNode=GetLinkListNodePoint(i_ptLinkListHead,m_ptElement,Compare,&ptLinkListPreNode);
    if(NULL==ptLinkListNode)
    {
        iRet=-1;
    }
    else// 找到此结点
    {
        if(NULL==ptLinkListPreNode)// 该结点是首元结点
        {
            DeleteNodeFromLinkList(&i_ptLinkListHead,1,m_ptElement);
        }
        else// 该结点不是首元结点，ptLinkListPreNode指向其前驱
        {
            DeleteNodeFromLinkList(&ptLinkListPreNode,2,m_ptElement);
        }
        iRet=0;
    }
    return iRet;
}

4)双向链表

/*****************************************************************************
* Copyright (C) 2017-2018 Hanson Yu  All rights reserved.
------------------------------------------------------------------------------
* File Module        :     DualLinkList.c
* Description        :     DualLinkList operation center
* Created            :     2017.04.02.
* Author            :     Yu Weifeng
* Function List         :     
* Last Modified     :     
* History            :     
******************************************************************************/
#include"stdio.h"
#include"malloc.h"
#include"stdlib.h"
#include"string.h"

typedef struct DualLinkList
{
    char cData;    
    struct DualLinkList *ptPrior;
    struct DualLinkList *ptNext;
}T_DualLinkList,*PT_DualLinkList;

static int ListLength(T_DualLinkList *i_ptDualLinkListHead);
static int GetElementPoint(T_DualLinkList *i_ptDualLinkListHead,int i_dwPosition,T_DualLinkList **o_pptElementPoint);
static int ListInit(T_DualLinkList **i_pptDualLinkListHead);
static int ListInsert(T_DualLinkList *i_ptDualLinkListHead,int i_dwPosition,int i_dwElement);
static int ListDelete(T_DualLinkList *i_ptDualLinkListHead,int i_dwPosition,int *o_dwElement);
static int ListTraverse(T_DualLinkList *i_ptDualLinkListHead);
static int ListSortOneCmpOne(T_DualLinkList *i_ptDualLinkListHead);
static int ListSortOneCmpAll(T_DualLinkList *i_ptDualLinkListHead);

/*****************************************************************************
-Fuction        : main
-Description    : main
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/03/29      V1.0.0         Yu Weifeng       Created
******************************************************************************/
int main(int argc,char **argv)
{
    int dwElement=0;
    T_DualLinkList *ptLinkListHead=NULL;
    ListInit(&ptLinkListHead);
    ListInsert(ptLinkListHead,1,1);
    ListInsert(ptLinkListHead,2,99);
    ListInsert(ptLinkListHead,3,24);
    ListInsert(ptLinkListHead,4,26);
    ListInsert(ptLinkListHead,5,8);
    ListInsert(ptLinkListHead,6,33);
    printf("插入结果:");
    ListTraverse(ptLinkListHead);
    
    ListSortOneCmpOne(ptLinkListHead);
    printf("两两比较冒泡排序结果:");
    ListTraverse(ptLinkListHead);
    
    ListDelete(ptLinkListHead,4,&dwElement);    
    printf("删除结果:");
    ListTraverse(ptLinkListHead);
    
    printf("插入结果:");
    ListInsert(ptLinkListHead,3,5);
    ListTraverse(ptLinkListHead);
    
    ListSortOneCmpAll(ptLinkListHead);
    printf("一对多比较冒泡排序结果:");
    ListTraverse(ptLinkListHead);
    
    return 0;
}
/*****************************************************************************
-Fuction        : ListInit
-Description    : ListInit
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/03/29      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int ListInit(T_DualLinkList **i_pptDualLinkListHead)
{
    int iRet=0;
    T_DualLinkList *ptListNode=NULL; 
    ptListNode=(T_DualLinkList *)malloc(sizeof(T_DualLinkList));
    if(NULL==ptListNode)
    {
        iRet=-1;
        printf("ListInitMallocErr,ListInitFail!
");
        exit(-1);
    }
    else
    {
        ptListNode->ptNext=ptListNode->ptPrior=ptListNode;
        *i_pptDualLinkListHead=ptListNode;
        iRet=0;
    }
    return iRet;
}
/*****************************************************************************
-Fuction        : ListInit
-Description    : ListInit
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/03/29      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int ListInsert(T_DualLinkList *i_ptDualLinkListHead,int i_dwPosition,int i_dwElement)
{
    int iRet=0;
    T_DualLinkList *ptListNode=i_ptDualLinkListHead; 
    T_DualLinkList *ptListInsertNode=NULL;
    if((i_dwPosition<1)||(i_dwPosition>ListLength(i_ptDualLinkListHead)+1))
    {
        printf("ListInserErr
");
        iRet=-1;
    }
    else
    {
        if(0!=GetElementPoint(i_ptDualLinkListHead,i_dwPosition-1,&ptListNode))//找插入点的前驱
        {//或者找插入点位置也是可以的
            printf("ListInsertGetElementPoint Err
");
            iRet=-1;
        }
        else
        {
            ptListInsertNode=(T_DualLinkList *)malloc(sizeof(T_DualLinkList));
            if(NULL==ptListInsertNode)
            {
                iRet=-1;
                printf("ListInsertMallocErr
");
            }
            else
            {
                ptListInsertNode->cData=i_dwElement;
                ptListInsertNode->ptNext=ptListNode->ptNext;
                ptListInsertNode->ptPrior=ptListNode;
                ptListNode->ptNext->ptPrior=ptListInsertNode;
                ptListNode->ptNext=ptListInsertNode;
                iRet=0;
            }
        }
    }
    return iRet;
}
/*****************************************************************************
-Fuction        : ListInit
-Description    : ListInit
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/03/29      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int ListDelete(T_DualLinkList *i_ptDualLinkListHead,int i_dwPosition,int *o_dwElement)
{
    int iRet=0;
    T_DualLinkList *ptListNode=NULL; 
    if((i_dwPosition<1)||(i_dwPosition>ListLength(i_ptDualLinkListHead)))
    {
        printf("ListDelete Err
");
        iRet=-1;
    }
    else
    {
        if(0!=GetElementPoint(i_ptDualLinkListHead,i_dwPosition,&ptListNode))//找删除点位置
        {
            printf("ListDeleteGetElementPoint Err
");
            iRet=-1;
        }
        else
        {
            *o_dwElement=ptListNode->cData;
            ptListNode->ptPrior->ptNext=ptListNode->ptNext;
            ptListNode->ptNext->ptPrior=ptListNode->ptPrior;
            free(ptListNode);
            iRet=0;
        }
    }
    return iRet;
}
/*****************************************************************************
-Fuction        : ListInit
-Description    : ListInit
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/03/29      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int ListTraverse(T_DualLinkList *i_ptDualLinkListHead)
{
    int iRet=0;
    T_DualLinkList *ptListNode=NULL; 
    if(NULL==i_ptDualLinkListHead)
    {
        iRet=-1;
        printf("ListTraverse Err,HeadNull
");
    }
    else
    {
        ptListNode=i_ptDualLinkListHead->ptNext;
        while(i_ptDualLinkListHead!=ptListNode)
        {
            printf("%d ",ptListNode->cData);
            ptListNode=ptListNode->ptNext;
        }
        printf("
");
        iRet=0;
    }
    return iRet;
}
/*****************************************************************************
-Fuction        : ListInit
-Description    : ListInit
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/03/29      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int ListSortOneCmpOne(T_DualLinkList *i_ptDualLinkListHead)
{
    int iRet=0;
    char cData;
    int i=0,j=0;
    T_DualLinkList *ptListSortNode=NULL;
    if(NULL==i_ptDualLinkListHead)
    {
        iRet=-1;
        printf("ListSortOneCmpOne Err,HeadNull
");
    }
    else
    {
        for(i=0;i<ListLength(i_ptDualLinkListHead)-1;i++)//总趟数
        {
            ptListSortNode=i_ptDualLinkListHead->ptNext;//最大的在后面所以最后一个不需要比较
            for(j=0;j<ListLength(i_ptDualLinkListHead)-i-1;j++)//但是第一个也就是前面还要比较
            {
                if(ptListSortNode->cData>ptListSortNode->ptNext->cData)//两两比较找出最大的放最后面
                {//大的放后面
                    cData=ptListSortNode->cData;
                    ptListSortNode->cData=ptListSortNode->ptNext->cData;
                    ptListSortNode->ptNext->cData=cData;
                }
                ptListSortNode=ptListSortNode->ptNext;
            }
        }
        iRet=0;
    }
    return iRet;
}
/*****************************************************************************
-Fuction        : ListInit
-Description    : ListInit
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/03/29      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int ListSortOneCmpAll(T_DualLinkList *i_ptDualLinkListHead)
{
    int iRet=0;
    char cData;
    int i=0,j=0;
    T_DualLinkList *ptListNode=i_ptDualLinkListHead; 
    T_DualLinkList *ptListSortNode=NULL;
    if(NULL==i_ptDualLinkListHead)
    {
        iRet=-1;
        printf("ListSortOneCmpAll Err,HeadNull
");
    }
    else
    {
        for(i=0;i<ListLength(i_ptDualLinkListHead)-1;i++)//总趟数
        {
            ptListSortNode=ptListNode=ptListNode->ptNext;
            for(j=0;j<ListLength(i_ptDualLinkListHead)-i-1;j++)//一趟比较次数
            {
                if(ptListNode->cData>ptListSortNode->ptNext->cData)//一比较多找出最小的放最前面
                {//小的放前面
                    cData=ptListNode->cData;
                    ptListNode->cData=ptListSortNode->ptNext->cData;
                    ptListSortNode->ptNext->cData=cData;
                }
                ptListSortNode=ptListSortNode->ptNext;
            }
        }
        iRet=0;
    }
    return iRet;
}

/*****************************************************************************
-Fuction        : GetElementPoint
-Description    : GetElementPoint
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/03/29      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int GetElementPoint(T_DualLinkList *i_ptDualLinkListHead,int i_dwPosition,T_DualLinkList **o_pptElementPoint)
{
    int iRet=0;    
    int j=0;
    T_DualLinkList *ptDualLinkListNode=i_ptDualLinkListHead;
    if((i_dwPosition<0)||(i_dwPosition>ListLength(i_ptDualLinkListHead)))
    {
        iRet=-1;
        printf("GetElementPoint Err
");
    }
    else
    {
        for(j=0;j<i_dwPosition;j++)
        {
            ptDualLinkListNode=ptDualLinkListNode->ptNext;
        }
        *o_pptElementPoint=ptDualLinkListNode;
        iRet=0;
    }
    return iRet;
}

/*****************************************************************************
-Fuction        : ListLength
-Description    : 双向链表是循环链表遍历长度需要比对的是头
结点
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/03/29      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int ListLength(T_DualLinkList *i_ptDualLinkListHead)
{
    int iLength=0;
    T_DualLinkList *ptDualLinkListNode=i_ptDualLinkListHead->ptNext;
    while(i_ptDualLinkListHead!=ptDualLinkListNode)//双向循环链表区别
    {
        iLength++;
        ptDualLinkListNode=ptDualLinkListNode->ptNext;
    }
    return iLength;
}

5)顺序表

/*****************************************************************************
* Copyright (C) 2017-2018 Hanson Yu  All rights reserved.
------------------------------------------------------------------------------
* File Module        :     SequenceList.c
* Description        :     SequenceList operation center
* Created            :     2017.05.22.
* Author            :     Yu Weifeng
* Function List         :     
* Last Modified     :     
* History            :     
******************************************************************************/
#include"stdio.h"
#include"malloc.h"
#include"stdlib.h"
#include"string.h"

typedef struct SeqListElement//顺序表结点里只有数据元素
{
    char cData;
}T_SeqListElement,*PT_SeqListElement;//结点等同于数据元素

typedef struct SeqList
{
    T_SeqListElement *ptBase;//所以为了方便,直接表元素代替表结点
    int iCurLength;
    int iMaxLength;
}T_SeqList,*PT_SeqList;

#define LIST_INIT_SIZE 10 // 线性表存储空间的初始分配量
#define LIST_INCREMENT 2 // 线性表存储空间的分配增量


static int InitSeqList(T_SeqList *m_ptSeqList);
static int IsSeqListEmpty(T_SeqList *i_ptSeqList);
static int InsertElementToSeqList(T_SeqList *i_ptSeqList,int i_dwInsertPos,T_SeqListElement *i_ptInsertElement);
static int DeleteElementFromSeqList(T_SeqList *i_ptSeqList,int i_dwInsertPos,T_SeqListElement *o_ptDeleteElement);
static int TraverseSequenceList(T_SeqList *i_ptSeqList);
/*****************************************************************************
-Fuction        : main
-Description    : main
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/03/29      V1.0.0         Yu Weifeng       Created
******************************************************************************/
int main(int argc,char **argv)
{
    T_SeqListElement tElement={0};
    T_SeqList tSeqList={0};
    InitSeqList(&tSeqList);
    tElement.cData=1;
    InsertElementToSeqList(&tSeqList,1,&tElement);
    tElement.cData=23;
    InsertElementToSeqList(&tSeqList,2,&tElement);
    tElement.cData=24;
    InsertElementToSeqList(&tSeqList,3,&tElement);
    tElement.cData=26;
    InsertElementToSeqList(&tSeqList,4,&tElement);
    tElement.cData=66;
    InsertElementToSeqList(&tSeqList,5,&tElement);
    tElement.cData=99;
    InsertElementToSeqList(&tSeqList,6,&tElement);
    printf("插入结果:");
    TraverseSequenceList(&tSeqList);
    
    DeleteElementFromSeqList(&tSeqList,6,&tElement);
    DeleteElementFromSeqList(&tSeqList,4,&tElement);
    printf("删除结果:");
    TraverseSequenceList(&tSeqList);
    
    printf("插入结果:");
    tElement.cData=5;
    InsertElementToSeqList(&tSeqList,3,&tElement);
    TraverseSequenceList(&tSeqList);
    return 0;
}


/*****************************************************************************
-Fuction        : InitSeqList
-Description    : InitSeqList
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/03/29      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int InitSeqList(T_SeqList *m_ptSeqList)
{
    int ret=-1;
    m_ptSeqList->ptBase=(T_SeqListElement *)malloc(sizeof(T_SeqListElement)*LIST_INIT_SIZE);
    if(NULL==m_ptSeqList->ptBase)
    {
        printf("InitSeqList Err
");
        ret=-1;
    }
    else
    {
        m_ptSeqList->iCurLength=0;
        m_ptSeqList->iMaxLength=LIST_INIT_SIZE;
        ret=0;
    }
    return ret;
}

/*****************************************************************************
-Fuction        : IsSeqListEmpty
-Description    : IsSeqListEmpty
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/03/29      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int IsSeqListEmpty(T_SeqList *i_ptSeqList)
{
    int ret=-1;
    if(0==i_ptSeqList->iCurLength)
    {
        ret=0;
    }
    else
    {
        ret=-1;
    }
    return ret;
}

/*****************************************************************************
-Fuction        : InsertSeqList
-Description    : InsertSeqList
-Input            : i_dwInsertPos 从1 开始算的
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/03/29      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int InsertElementToSeqList(T_SeqList *i_ptSeqList,int i_dwInsertPos,T_SeqListElement *i_ptInsertElement)
{
    int ret=-1;
    T_SeqListElement *ptNewBase=NULL;
    T_SeqListElement *ptInsertElement=NULL;
    T_SeqListElement *ptSeqListElement=NULL;
    if(i_dwInsertPos<1||i_dwInsertPos>i_ptSeqList->iCurLength+1)// i_dwInsertPos值不合法
    {
        ret=-1;
    }
    else
    {
        if(i_ptSeqList->iCurLength>=i_ptSeqList->iMaxLength)// 当前存储空间已满,增加分配
        {
            ptNewBase=(T_SeqListElement *)realloc(i_ptSeqList->ptBase,(i_ptSeqList->iMaxLength+LIST_INCREMENT)*sizeof(T_SeqListElement));
            if(NULL==ptNewBase)
            {
                printf("InsertSeqList realloc err
");
                ret=-1;
                exit(-1);
            }
            else
            {
                i_ptSeqList->ptBase=ptNewBase;
                i_ptSeqList->iMaxLength+=LIST_INCREMENT;
            }
        }
        else
        {
        }
        ptInsertElement=i_ptSeqList->ptBase+i_dwInsertPos-1;//从0开始算等价于i_ptSeqList->ptBase[i_dwInsertPos-1]
        for(ptSeqListElement=i_ptSeqList->ptBase+i_ptSeqList->iCurLength-1;ptSeqListElement>=ptInsertElement;ptSeqListElement--)
        {// 插入位置及之后的元素右移
            memcpy(ptSeqListElement+1,ptSeqListElement,sizeof(T_SeqListElement));
        }
        memcpy(ptInsertElement,i_ptInsertElement,sizeof(T_SeqListElement));
        i_ptSeqList->iCurLength++;
        ret=0;
    }
    return ret;
}

/*****************************************************************************
-Fuction        : DeleteElementFromSeqList
-Description    : DeleteElementFromSeqList
-Input            : i_dwInsertPos 从1 开始算的
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/03/29      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int DeleteElementFromSeqList(T_SeqList *i_ptSeqList,int i_dwInsertPos,T_SeqListElement *o_ptDeleteElement)
{
    int ret=-1;
    T_SeqListElement *ptNewBase=NULL;
    T_SeqListElement *ptDeleteElement=NULL;
    T_SeqListElement *ptSeqListElement=NULL;
    if(i_dwInsertPos<1||i_dwInsertPos>i_ptSeqList->iCurLength)// i_dwInsertPos值不合法
    {
        ret=-1;
    }
    else
    {
        ptDeleteElement=i_ptSeqList->ptBase+i_dwInsertPos-1;//从0开始算等价于i_ptSeqList->ptBase[i_dwInsertPos-1]
        memcpy(o_ptDeleteElement,ptDeleteElement,sizeof(T_SeqListElement));
        for(ptSeqListElement=ptDeleteElement+1;ptSeqListElement<=i_ptSeqList->ptBase+i_ptSeqList->iCurLength-1;ptSeqListElement++)
        {// 被删除元素之后的元素左移
            memcpy(ptSeqListElement-1,ptSeqListElement,sizeof(T_SeqListElement));
        }
        i_ptSeqList->iCurLength--;
        ret=0;
    }
    return ret;
}

/*****************************************************************************
-Fuction        : TraverseSequenceList
-Description    : TraverseSequenceList
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/03/29      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int TraverseSequenceList(T_SeqList *i_ptSeqList)
{
    int ret=-1;
    int i;
    for(i=0;i<i_ptSeqList->iCurLength;i++)
    {
        printf("%d ",i_ptSeqList->ptBase[i].cData);
    }
    printf("
");
    return ret;
}

2.队列：

1)链式队列

/*****************************************************************************
* Copyright (C) 2017-2018 Hanson Yu  All rights reserved.
------------------------------------------------------------------------------
* File Module        :     LinkQueue.c
* Description        :     LinkQueue operation center
* Created            :     2017.04.24.
* Author            :     Yu Weifeng
* Function List         :     
* Last Modified     :     
* History            :     
******************************************************************************/
#include"stdio.h"
#include"malloc.h"
#include"stdlib.h"
#include"string.h"
#include "LinkQueue.h"

static void TraverseLinkQueue(T_LinkQueue *i_ptLinkQueue);

/*****************************************************************************
-Fuction        : main
-Description    : main
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/04/21      V1.0.0         Yu Weifeng       Created
******************************************************************************/
/*int main(int argc,char **argv)
{
    T_LinkQueue tLinkQueue={0};
    char cElementData=0;
    InitLinkQueue(&tLinkQueue);
    
    EnterLinkQueue(&tLinkQueue,1);
    EnterLinkQueue(&tLinkQueue,2);
    EnterLinkQueue(&tLinkQueue,3);
    EnterLinkQueue(&tLinkQueue,4);
    EnterLinkQueue(&tLinkQueue,5);
    printf("进入队列结果:");
    TraverseLinkQueue(&tLinkQueue);
    
    ExitLinkQueue(&tLinkQueue,&cElementData);
    printf("退出队列元素:%d
",cElementData);
    ExitLinkQueue(&tLinkQueue,&cElementData);
    printf("退出队列元素:%d
",cElementData);
    ExitLinkQueue(&tLinkQueue,&cElementData);
    printf("退出队列元素:%d
",cElementData);
    
    printf("退出队列结果:");
    TraverseLinkQueue(&tLinkQueue);
    
    return 0;
}*/
/*****************************************************************************
-Fuction        : InitLinkQueue
-Description    : InitLinkQueue
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/04/21      V1.0.0         Yu Weifeng       Created
******************************************************************************/
int InitLinkQueue(T_LinkQueue *i_ptLinkQueue)
{
    int iRet=-1;
    i_ptLinkQueue->ptFront=(T_QueueElement *)malloc(sizeof(T_QueueElement));
    if(NULL==i_ptLinkQueue->ptFront)
    {
        iRet=-1;
        printf("InitLinkQueue Malloc err
");
        exit(-1);
    }
    else
    {
        i_ptLinkQueue->ptRear=i_ptLinkQueue->ptFront;
        i_ptLinkQueue->ptRear->ptNext=NULL;
        iRet=0;
    }
    return iRet;
}
/*****************************************************************************
-Fuction        : EnterLinkQueue
-Description    : 考虑满的问题，不满则考虑插入到里面没有元素
                  的情况，即空的情况也就是最开始的时候
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/04/21      V1.0.0         Yu Weifeng       Created
******************************************************************************/
int EnterLinkQueue(T_LinkQueue *i_ptLinkQueue,T_QueueDataElement i_tElement)
{
    int iRet=-1;
    T_QueueElement *ptQueueNode=NULL;
    ptQueueNode=(T_QueueElement *)malloc(sizeof(T_QueueElement));
    if(NULL==ptQueueNode)
    {
        iRet=-1;
        printf("EnterLinkQueue Malloce err");
    }
    else
    {    
        memcpy(&ptQueueNode->tData,&i_tElement,sizeof(T_QueueElement));//最开始ptRear指向头结点
        ptQueueNode->ptNext=NULL;//头结点不放元素
        i_ptLinkQueue->ptRear->ptNext=ptQueueNode;//所以只能放在头结点的下一个元素
        i_ptLinkQueue->ptRear=ptQueueNode;
        iRet=0;
    }
    return iRet;
}
/*****************************************************************************
-Fuction        : ExitLinkQueue
-Description    : 考虑空的问题，不空则考虑删除的是最后一个
                  元素的情况，即删除后为空的情况
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/04/21      V1.0.0         Yu Weifeng       Created
******************************************************************************/
int ExitLinkQueue(T_LinkQueue *i_ptLinkQueue,T_QueueDataElement *o_ptElement)
{
    int iRet=-1;
    T_QueueElement *ptQueueNode=NULL;
    if(i_ptLinkQueue->ptFront==i_ptLinkQueue->ptRear)
    {
        iRet=-1;
        printf("LinkQueueEmpty Exit err
");
    }
    else
    {
        ptQueueNode=i_ptLinkQueue->ptFront->ptNext;
        memcpy(o_ptElement,&ptQueueNode->tData,sizeof(T_QueueElement));
        i_ptLinkQueue->ptFront->ptNext=ptQueueNode->ptNext;//最开始时
        if(ptQueueNode==i_ptLinkQueue->ptRear)//当取出的是队列仅有的一个元素，即剩下只有队头元素(头结点)
        {//队列里没有元素了，则对头和队尾要相等
            i_ptLinkQueue->ptRear=i_ptLinkQueue->ptFront;//
        }
        else{
        }
        free(ptQueueNode);
        iRet=0;
    }
    return iRet;
}
/*****************************************************************************
-Fuction        : ExitLinkQueue
-Description    : 考虑空的问题，不空则考虑删除的是最后一个
                  元素的情况，即删除后为空的情况
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/04/21      V1.0.0         Yu Weifeng       Created
******************************************************************************/
int IsLinkQueueEmpty(T_LinkQueue *i_ptLinkQueue)
{
    int iRet=-1;
    T_QueueElement *ptQueueNode=NULL;
    if(i_ptLinkQueue->ptFront!=i_ptLinkQueue->ptRear)
    {
        iRet=-1;
    }
    else
    {
        iRet=0;
    }
    return iRet;
}

/*****************************************************************************
-Fuction        : TraverseLinkQueue
-Description    : TraverseLinkQueue
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/04/21      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void TraverseLinkQueue(T_LinkQueue *i_ptLinkQueue)
{
    T_QueueElement *ptQueueNode=NULL;
    ptQueueNode=i_ptLinkQueue->ptFront->ptNext;
    while(NULL!=ptQueueNode)
    {
        //printf("%d",ptQueueNode->tData);
        ptQueueNode=ptQueueNode->ptNext;
    }
    printf("
");
}

/*****************************************************************************
* Copyright (C) 2017-2018 Hanson Yu  All rights reserved.
------------------------------------------------------------------------------
* File Module        :     LinkQueue.h
* Description        :     LinkQueue operation center
* Created            :     2017.04.24.
* Author            :     Yu Weifeng
* Function List         :     
* Last Modified     :     
* History            :     
******************************************************************************/
#ifndef _LINK_QUEUE_H
#define _LINK_QUEUE_H

//#include "ChildSiblingTree.h"
typedef struct QueueDataElement
{
//    T_ChildSiblingTreeNode *ptData;
    int iData;
}T_QueueDataElement,*PT_QueueDataElement;


typedef struct QueueElement
{
    T_QueueDataElement tData;
    struct QueueElement *ptNext;
}T_QueueElement,*PT_QueueElement;

typedef struct LinkQueue
{
    T_QueueElement *ptFront;
    T_QueueElement *ptRear;
}T_LinkQueue,*PT_LinkQueue;



int InitLinkQueue(T_LinkQueue *i_pptLinkQueue);
int EnterLinkQueue(T_LinkQueue *i_ptLinkQueue,T_QueueDataElement i_tElement);
int ExitLinkQueue(T_LinkQueue *i_ptLinkQueue,T_QueueDataElement *o_ptElement);

#endif

2)顺序队列

/*****************************************************************************
* Copyright (C) 2017-2018 Hanson Yu  All rights reserved.
------------------------------------------------------------------------------
* File Module        :     SequenceQueue.c
* Description        :     SequenceQueue operation center
顺序表示的队列一定是循环队列
因为顺序表示的队列要使用已经出队的空间就必须使用
循环的方法指向已经出队的空间
* Created            :     2017.04.24.
* Author            :     Yu Weifeng
* Function List         :     
* Last Modified     :     
* History            :     
******************************************************************************/
#include"stdio.h"
#include"malloc.h"
#include"stdlib.h"
#include"string.h"

typedef struct SeqQueueElement//顺序队列结点里只有数据元素
{
    char cData;
}T_SeqQueueElement,*PT_SeqQueueElement;//结点等同于数据元素

typedef struct SeqQueue
{
    T_SeqQueueElement *ptBase;//所以为了方便,直接队列元素代替队列结点
    int iFront;
    int iRear;
}T_SeqQueue,*PT_SeqQueue;

#define SEQUENCE_QUEUE_MAX_LEN    5
static int InitSeqQueue(T_SeqQueue *i_ptSeqQueue);
static int EnterSeqQueue(T_SeqQueue *i_ptSeqQueue,T_SeqQueueElement i_tElement);
static int ExitSeqQueue(T_SeqQueue *i_ptSeqQueue,T_SeqQueueElement *o_ptElement);
static void TraverseSeqQueue(T_SeqQueue *i_ptSeqQueue);

/*****************************************************************************
-Fuction        : main
-Description    : main
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/04/21      V1.0.0         Yu Weifeng       Created
******************************************************************************/
int main(int argc,char **argv)
{
    T_SeqQueue tSeqQueue={0};
    T_SeqQueueElement tElementData={0};
    InitSeqQueue(&tSeqQueue);
    tElementData.cData=1;
    EnterSeqQueue(&tSeqQueue,tElementData);
    tElementData.cData=2;
    EnterSeqQueue(&tSeqQueue,tElementData);
    tElementData.cData=5;
    EnterSeqQueue(&tSeqQueue,tElementData);
    tElementData.cData=6;
    EnterSeqQueue(&tSeqQueue,tElementData);
    printf("进入队列结果:");
    TraverseSeqQueue(&tSeqQueue);
    
    ExitSeqQueue(&tSeqQueue,&tElementData);
    printf("退出队列元素:%d
",tElementData.cData);
    ExitSeqQueue(&tSeqQueue,&tElementData);
    printf("退出队列元素:%d
",tElementData.cData);
    ExitSeqQueue(&tSeqQueue,&tElementData);
    printf("退出队列元素:%d
",tElementData.cData);
    
    printf("退出队列结果:");
    TraverseSeqQueue(&tSeqQueue);
    return 0;
}
/*****************************************************************************
-Fuction        : InitSeqQueue
-Description    : InitSeqQueue
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/04/21      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int InitSeqQueue(T_SeqQueue *i_ptSeqQueue)
{
    int iRet=-1;
    i_ptSeqQueue->ptBase=(T_SeqQueueElement *)malloc(sizeof(T_SeqQueueElement)*SEQUENCE_QUEUE_MAX_LEN);
    if(NULL==i_ptSeqQueue->ptBase)
    {
        printf("InitSeqQueue MallocErr
");
        exit(-1);
    }
    else
    {
        i_ptSeqQueue->iRear=i_ptSeqQueue->iFront=0;
        iRet=0;
    }
    return iRet;
}

/*****************************************************************************
-Fuction        : EnterSeqQueue
-Description    : 考虑满的问题，不满则考虑插入到里面没有元素
                  的情况，即空的情况也就是最开始的时候
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/04/21      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int EnterSeqQueue(T_SeqQueue *i_ptSeqQueue,T_SeqQueueElement i_tElement)
{
    int iRet=-1;
    if((i_ptSeqQueue->iRear+1)%SEQUENCE_QUEUE_MAX_LEN==i_ptSeqQueue->iFront)
    {//要放元素的下一个位置,即队尾的下一个位置如果等于队头则满
        printf("EnterSeqQueue err,SeqQueueFull
");
        iRet=-1;
    }
    else
    {
        i_ptSeqQueue->ptBase[i_ptSeqQueue->iRear]=i_tElement;//iRear指向待放元素的位置
        i_ptSeqQueue->iRear=(i_ptSeqQueue->iRear+1)%SEQUENCE_QUEUE_MAX_LEN;
        iRet=0;
    }
    return iRet;
}

/*****************************************************************************
-Fuction        : ExitSeqQueue
-Description    : 考虑空的问题，不空则考虑删除的是最后一个
                  元素的情况，即删除后为空的情况
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/04/21      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int ExitSeqQueue(T_SeqQueue *i_ptSeqQueue,T_SeqQueueElement *o_ptElement)
{
    int iRet=-1;
    if(i_ptSeqQueue->iFront==i_ptSeqQueue->iRear)
    {
        printf("EnterSeqQueue err,SeqQueueEmpty
");
    }
    else
    {
        *o_ptElement=i_ptSeqQueue->ptBase[i_ptSeqQueue->iFront];
        i_ptSeqQueue->iFront=(i_ptSeqQueue->iFront+1)%SEQUENCE_QUEUE_MAX_LEN;
        iRet=0;
    }
    return iRet;
}
/*****************************************************************************
-Fuction        : TraverseSeqQueue
-Description    : 遍历直到最后一个元素,所以其中循环条件一般考虑
                  最后一个元素时的情形
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/04/21      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void TraverseSeqQueue(T_SeqQueue *i_ptSeqQueue)
{
    int i=i_ptSeqQueue->iFront;
    while(i!=i_ptSeqQueue->iRear)
    {
        printf("%d ",i_ptSeqQueue->ptBase[i].cData);
        i=(i+1)%SEQUENCE_QUEUE_MAX_LEN;
    }
    printf("
");
}

3.栈

1)顺序栈

/*****************************************************************************
* Copyright (C) 2017-2018 Hanson Yu  All rights reserved.
------------------------------------------------------------------------------
* File Module        :     SequenceStack.c
* Description        :     SequenceStack operation center
* Created            :     2017.04.22.
* Author            :     Yu Weifeng
* Function List         :     
* Last Modified     :     
* History            :     
******************************************************************************/
#include"stdio.h"
#include"malloc.h"
#include"stdlib.h"
#include"string.h"

typedef struct StackElement
{
    T_LinkBiTreeNode *ptData;
    
}T_StackElement,*PT_StackElement;
typedef struct SeqStack
{
    T_StackElement *ptBase; 
    T_StackElement *ptTop; 
    int iLen;
}T_SeqStack,*PT_SeqStack;

#define MAX_STACK_LENGTH                100
#define INCREMENT_STACK_LENGTH        (2)

/*****************************************************************************
-Fuction        : InitStack
-Description    : InitStack
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/04/21      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int InitSeqStack(T_SeqStack *i_ptSeqStack)
{
    int iRet=-1;
    i_ptSeqStack->ptBase=(T_StackElement *)malloc(MAX_STACK_LENGTH*sizeof(T_StackElement));
    if(NULL==i_ptSeqStack->ptBase)
    {
        iRet=-1;
        printf("mallocFail,InitStack err");
        exit(-1);
    }
    else
    {
        i_ptSeqStack->ptTop=i_ptSeqStack->ptBase;
        i_ptSeqStack->iLen=MAX_STACK_LENGTH;
        iRet=0;
    }
    return iRet;
}

/*****************************************************************************
-Fuction        : Push
-Description    : Push
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/04/21      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int PushSeqStack(T_SeqStack *i_ptSeqStack,T_StackElement *i_ptStackElement)
{
    int iRet=-1;
    if((i_ptSeqStack->ptTop-i_ptSeqStack->ptBase)==i_ptSeqStack->iLen)
    {//追加内存，返回地址可能是新的，但是原来的内容保持不变(会拷贝)
        i_ptSeqStack->ptBase=(T_StackElement *)realloc(i_ptSeqStack->ptBase,(i_ptSeqStack->iLen+INCREMENT_STACK_LENGTH)*
                            sizeof(T_StackElement));
        if(NULL==i_ptSeqStack->ptBase)
        {
            iRet=-1;
            printf("StackFull,ReallocFail,Push err");
            exit(-1);
        }
        else
        {//返回内存地址可能会变，不是原先的了
            i_ptSeqStack->ptTop=i_ptSeqStack->ptBase+i_ptSeqStack->iLen;
            i_ptSeqStack->iLen=i_ptSeqStack->iLen+INCREMENT_STACK_LENGTH;
        }
    }
    else
    {
    }
    memcpy(i_ptSeqStack->ptTop,i_ptStackElement,sizeof(T_StackElement));
    i_ptSeqStack->ptTop++;
    iRet=0;
    return iRet;
}

/*****************************************************************************
-Fuction        : Pop
-Description    : Pop
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/04/21      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int PopSeqStack(T_SeqStack *i_ptSeqStack,T_StackElement *o_ptStackElement)
{
    int iRet=-1;
    if(i_ptSeqStack->ptTop==i_ptSeqStack->ptBase)
    {
        iRet=-1;
        printf("StackEmpty,Pop err");
    }
    else
    {
        i_ptSeqStack->ptTop--;
        memcpy(o_ptStackElement,i_ptSeqStack->ptTop,sizeof(T_StackElement));
        iRet=0;
    }
    return iRet;
}


/*****************************************************************************
-Fuction        : SeqStackEmpty
-Description    : SeqStackEmpty
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/04/21      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int IsSeqStackEmpty(T_SeqStack *i_ptSeqStack)
{
    int iRet=-1;
    if(i_ptSeqStack->ptTop==i_ptSeqStack->ptBase)
    {
        iRet=0;
        //printf("StackEmpty
");
    }
    else
    {
        iRet=-1;
    }
    return iRet;
}


/*****************************************************************************
-Fuction        : GetSeqStackTopElement
-Description    : 
// 若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/04/21      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int GetSeqStackTopElement(T_SeqStack *i_ptSeqStack,T_StackElement *o_ptStackElement)
{
    int iRet=-1;
    if(i_ptSeqStack->ptTop>i_ptSeqStack->ptBase)
    {
         memcpy(o_ptStackElement,i_ptSeqStack->ptTop-1,sizeof(T_StackElement));
         iRet=0;
    }
    else
    {
        iRet=-1;
    }
    return iRet;
}

2)栈的应用(走迷宫)

/*****************************************************************************
* Copyright (C) 2017-2018 Hanson Yu  All rights reserved.
------------------------------------------------------------------------------
* File Module        :     DualLinkList.c
* Description        :     DualLinkList operation center
* Created            :     2017.04.22.
* Author            :     Yu Weifeng
* Function List         :     
* Last Modified     :     
* History            :     
******************************************************************************/
#include"stdio.h"
#include"malloc.h"
#include"stdlib.h"
#include"string.h"

typedef struct MazePosType
{
    int x;
    int y;
}T_MazePosType,*PT_MazePosType;
typedef struct StackElement
{
    int iOrder;
    T_MazePosType tPos;
    int iDirection;
}T_StackElement,*PT_StackElement;
typedef struct SeqStack
{
    T_StackElement *ptBase; 
    T_StackElement *ptTop; 
    int iLen;
}T_SeqStack,*PT_SeqStack;

#define MAX_MAZE_LENGTH                25
#define MAX_STACK_LENGTH                (MAX_MAZE_LENGTH*MAX_MAZE_LENGTH)
#define INCREMENT_STACK_LENGTH        (2)

static int InitStack(T_SeqStack *i_ptSeqStack);
static int Push(T_SeqStack *i_ptSeqStack,T_StackElement *i_ptStackElement);
static int Pop(T_SeqStack *i_ptSeqStack,T_StackElement *o_ptStackElement);
static int StackEmpty(T_SeqStack *i_ptSeqStack);

static void PrintMaze(int i_daiMaze[][MAX_MAZE_LENGTH],int i_iX,int i_iY);
static void InitMaze(int i_dwPassValue,int i_daiMaze[][MAX_MAZE_LENGTH],int *o_piX,int *o_piY,T_MazePosType *ptBeginPos,T_MazePosType *ptEndPos);
static int PassJudge(int i_daiMaze[][MAX_MAZE_LENGTH],T_MazePosType *i_ptMazePos);
static void FootMark(int i_daiMaze[][MAX_MAZE_LENGTH],T_MazePosType *i_ptMazePos,int i_iCurStep);
static void NextPos(T_MazePosType *i_ptMazePos,int i_iDirection);
static void NoWayMark(int i_daiMaze[][MAX_MAZE_LENGTH],T_MazePosType *i_ptMazePos);


/*****************************************************************************
-Fuction        : main
-Description    : main
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/04/21      V1.0.0         Yu Weifeng       Created
******************************************************************************/
int main(int argc,char **argv)
{
    int aMaze[MAX_MAZE_LENGTH][MAX_MAZE_LENGTH]={0};
    int iRowNum,iRankNum;
    T_MazePosType tBeginPos={0};
    T_MazePosType tEndPos={0};
    InitMaze(1,aMaze,&iRowNum,&iRankNum,&tBeginPos,&tEndPos);
    if(0==MazePath(aMaze,&tBeginPos,&tEndPos))
    {
        printf("从入口到出口一条通路如下:
");
        PrintMaze(aMaze,iRowNum,iRankNum);
    }
    else
    {
        printf("此迷宫没有通路
");
    }
    
    return 0;
}

/*****************************************************************************
-Fuction        : MazePath
-Description    : 当前位置不是墙直接入栈直到终点，不是终点
继续下个位置。当前位置是墙，如果栈不为空，出栈找到
墙的前一个位置，如果这个位置四个方向都走过了不通并且
栈不空，继续出栈找到前一个位置还有方向没走过的，
找到后换方向，换下一位置继续判断
同时由于该位置不是墙(前面判断过了)所以继续入栈
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/04/21      V1.0.0         Yu Weifeng       Created
******************************************************************************/
int MazePath(int i_daiMaze[][MAX_MAZE_LENGTH],T_MazePosType *i_ptBeginPos,T_MazePosType *i_ptEndPos)
{
    T_MazePosType tCurrentPos={0};
    int iCurrentStep=1;//为1第一个位置，防止与0的墙混淆
    T_SeqStack tSeqStack;
    T_StackElement tStackElement={0};
    memcpy(&tCurrentPos,i_ptBeginPos,sizeof(T_MazePosType));
    InitStack(&tSeqStack);
    do
    {
        if(0==PassJudge(i_daiMaze,&tCurrentPos))//当前位置不是墙
        {
            FootMark(i_daiMaze,&tCurrentPos,iCurrentStep);
            tStackElement.iOrder=iCurrentStep;
            tStackElement.tPos=tCurrentPos;
            tStackElement.iDirection=0;
            Push(&tSeqStack,&tStackElement);                
            iCurrentStep++;
            if((tCurrentPos.x==i_ptEndPos->x)&&(tCurrentPos.y==i_ptEndPos->y))
            return 0;
            NextPos(&tCurrentPos,tStackElement.iDirection);
            //printf("Line:%d,Step:%d,x:%d,y:%d
", __LINE__,iCurrentStep,tStackElement.tPos.x,tStackElement.tPos.y);
        }
        else// 当前位置不能通过,是墙(当前位置没入栈,墙没法走不入栈)
        {
            if(0!=StackEmpty(&tSeqStack))
            {
                Pop(&tSeqStack,&tStackElement);     // 退栈找到前一位置(墙前一个位置)
                iCurrentStep--;// 足迹减1
                while((tStackElement.iDirection==3)&&(0!=StackEmpty(&tSeqStack)))// 前一位置处于最后一个方向(北)
                {
                    NoWayMark(i_daiMaze,&tStackElement.tPos);//走不通，没法走了，不入栈，出栈掉
                    Pop(&tSeqStack,&tStackElement);     
                    iCurrentStep--;// 足迹减1
                }
                if(tStackElement.iDirection<3)
                {
                    tStackElement.iDirection++;
                    iCurrentStep++;
                    tCurrentPos=tStackElement.tPos;
                    NextPos(&tCurrentPos,tStackElement.iDirection);
                    Push(&tSeqStack,&tStackElement);//(不是墙,换了方向)可以走，入栈
                }
                else{
                }
            }
            else
            {
            }
        }
    }while(0!=StackEmpty(&tSeqStack));
    return -1;
}
/*****************************************************************************
-Fuction        : PrintMaze
-Description    : PrintMaze
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/04/21      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void PrintMaze(int i_daiMaze[][MAX_MAZE_LENGTH],int i_iX,int i_iY)
{
    int i,j;
    for(i=0;i<i_iX;i++)
    {
        for(j=0;j<i_iY;j++)
        {
            printf("%3d",i_daiMaze[i][j]);
        }
        printf("
");
    }
}
/*****************************************************************************
-Fuction        : InitMaze
-Description    : InitMaze
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/04/21      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void InitMaze(int i_dwPassValue,int i_daiMaze[][MAX_MAZE_LENGTH],int *o_piX,int *o_piY,T_MazePosType *ptBeginPos,T_MazePosType *ptEndPos)
{
    int i,j,x,y;
    int iWallNum=0;
    int iWallX=0,iWallY=0;
    printf("请输入迷宫的行数,列数(包括外墙):");
    scanf("%d,%d",&x,&y);
    *o_piX=x;
    *o_piY=y;
    for(i=0;i<y;i++)//外墙全为0
    {
        i_daiMaze[0][i]=0;
        i_daiMaze[x-1][i]=0;
    }
    for(i=1;i<x-1;i++)
    {
        i_daiMaze[i][0]=0;
        i_daiMaze[i][y-1]=0;
    }
    for(i=1;i<x-1;i++)// 定义除外墙，其余都是通道，初值为k
    {
        for(j=1;j<y-1;j++)
        {
            i_daiMaze[i][j]=i_dwPassValue;
        }
    }
    printf("请输入迷宫内墙单元数:");
    scanf("%d",&iWallNum);
    printf("请依次输入迷宫内墙每个单元的行数,列数:
");
    for(i=0;i<iWallNum;i++)
    {
        scanf("%d,%d",&iWallX,&iWallY);
        i_daiMaze[iWallX][iWallY]=0;// 修改墙的值为0
    }
    printf("迷宫结构如下:
");
    PrintMaze(i_daiMaze,x,y);
    printf("请输入入口的行数,列数:");
    scanf("%d,%d",&ptBeginPos->x,&ptBeginPos->y);
    printf("请输入出口的行数,列数:");
    scanf("%d,%d",&ptEndPos->x,&ptEndPos->y);
}
/*****************************************************************************
-Fuction        : PassJudge
-Description    : PassJudge
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/04/21      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int PassJudge(int i_daiMaze[][MAX_MAZE_LENGTH],T_MazePosType *i_ptMazePos)
{
    int iRet=-1;
    if(i_daiMaze[i_ptMazePos->x][i_ptMazePos->y]!=1)
    {
        iRet=-1;
    }
    else
    {
        iRet=0;
    }
    return iRet;
}
/*****************************************************************************
-Fuction        : FootMark
-Description    : FootMark
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/04/21      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void FootMark(int i_daiMaze[][MAX_MAZE_LENGTH],T_MazePosType *i_ptMazePos,int i_iCurStep)
{
    i_daiMaze[i_ptMazePos->x][i_ptMazePos->y]=i_iCurStep;
}
/*****************************************************************************
-Fuction        : NextPos
-Description    : NextPos
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/04/21      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void NextPos(T_MazePosType *i_ptMazePos,int i_iDirection)
{
    static T_MazePosType s_atMazePos[4]={{0,1},{1,0},{0,-1},{-1,0}};// {行增量,列增量},移动方向,依次为东南西北
    i_ptMazePos->x+=s_atMazePos[i_iDirection].x;
    i_ptMazePos->y+=s_atMazePos[i_iDirection].y;
}
/*****************************************************************************
-Fuction        : NoWayMark
-Description    : NoWayMark
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/04/21      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void NoWayMark(int i_daiMaze[][MAX_MAZE_LENGTH],T_MazePosType *i_ptMazePos)
{
    i_daiMaze[i_ptMazePos->x][i_ptMazePos->y]=-1;

}
/*****************************************************************************
-Fuction        : InitStack
-Description    : InitStack
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/04/21      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int InitStack(T_SeqStack *i_ptSeqStack)
{
    int iRet=-1;
    i_ptSeqStack->ptBase=(T_StackElement *)malloc(MAX_STACK_LENGTH*sizeof(T_StackElement));
    if(NULL==i_ptSeqStack->ptBase)
    {
        iRet=-1;
        printf("mallocFail,InitStack err");
        exit(-1);
    }
    else
    {
        i_ptSeqStack->ptTop=i_ptSeqStack->ptBase;
        i_ptSeqStack->iLen=MAX_MAZE_LENGTH;
        iRet=0;
    }
    return iRet;
}

/*****************************************************************************
-Fuction        : Push
-Description    : Push
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/04/21      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int Push(T_SeqStack *i_ptSeqStack,T_StackElement *i_ptStackElement)
{
    int iRet=-1;
    if((i_ptSeqStack->ptTop-i_ptSeqStack->ptBase)==i_ptSeqStack->iLen)
    {//追加内存，返回地址可能是新的，但是原来的内容保持不变(会拷贝)
        i_ptSeqStack->ptBase=(T_StackElement *)realloc(i_ptSeqStack->ptBase,(i_ptSeqStack->iLen+INCREMENT_STACK_LENGTH)*
                            sizeof(T_StackElement));
        if(NULL==i_ptSeqStack->ptBase)
        {
            iRet=-1;
            printf("StackFull,ReallocFail,Push err");
            exit(-1);
        }
        else
        {//返回内存地址可能会变，不是原先的了
            i_ptSeqStack->ptTop=i_ptSeqStack->ptBase+i_ptSeqStack->iLen;
            i_ptSeqStack->iLen=i_ptSeqStack->iLen+INCREMENT_STACK_LENGTH;
        }
    }
    else
    {
    }
    memcpy(i_ptSeqStack->ptTop,i_ptStackElement,sizeof(T_StackElement));
    i_ptSeqStack->ptTop++;
    iRet=0;
    return iRet;
}

/*****************************************************************************
-Fuction        : Pop
-Description    : Pop
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/04/21      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int Pop(T_SeqStack *i_ptSeqStack,T_StackElement *o_ptStackElement)
{
    int iRet=-1;
    if(i_ptSeqStack->ptTop==i_ptSeqStack->ptBase)
    {
        iRet=-1;
        printf("StackEmpty,Pop err");
    }
    else
    {
        i_ptSeqStack->ptTop--;
        memcpy(o_ptStackElement,i_ptSeqStack->ptTop,sizeof(T_StackElement));
        iRet=0;
    }
    return iRet;
}


/*****************************************************************************
-Fuction        : Pop
-Description    : Pop
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/04/21      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int StackEmpty(T_SeqStack *i_ptSeqStack)
{
    int iRet=-1;
    if(i_ptSeqStack->ptTop==i_ptSeqStack->ptBase)
    {
        iRet=0;
        printf("StackEmpty
");
    }
    else
    {
        iRet=-1;
    }
    return iRet;
}

4.二叉树与树

1)链式二叉树

/*****************************************************************************
* Copyright (C) 2017-2018 Hanson Yu  All rights reserved.
------------------------------------------------------------------------------
* File Module        :     LinkBiTree.c
* Description        :     LinkBiTree operation center
* Created            :     2017.05.11.
* Author            :     Yu Weifeng
* Function List         :     
* Last Modified     :     
* History            :     
******************************************************************************/
#include "stdio.h"
#include "malloc.h"
#include "stdlib.h"
#include "string.h"
#include "math.h"
#include "LinkBiTree.h"
#include "LinkQueue.c"
#include "SequenceStack.c"





static void InitLinkBiTree(T_LinkBiTreeNode **i_pptLinkBiTree);
static void DestroyLinkBiTree(T_LinkBiTreeNode *i_ptLinkBiTree);
static int IsLinkBiTreeEmpty(T_LinkBiTreeNode *i_ptLinkBiTree);
static int GetLinkBiTreeDepth(T_LinkBiTreeNode *i_ptLinkBiTree);
static char GetLinkBiTreeRootData(T_LinkBiTreeNode *i_ptLinkBiTree);
static char GetLinkBiTreeNodeData(T_LinkBiTreeNode *i_ptLinkBiTreeNode);
static void AssignToLinkBiTreeNode(T_LinkBiTreeNode *i_ptLinkBiTreeNode,char i_cData);

static char GetLinkBiTreeParentData(T_LinkBiTreeNode *i_ptLinkBiTree,char i_cData);
static char GetLinkBiTreeLeftChildData(T_LinkBiTreeNode *i_ptLinkBiTree,char i_cData);
static char GetLinkBiTreeRightChildData(T_LinkBiTreeNode *i_ptLinkBiTree,char i_cData);
static char GetLinkBiTreeLeftSiblingData(T_LinkBiTreeNode *i_ptLinkBiTree,char i_cData);
static char GetLinkBiTreeRightSiblingData(T_LinkBiTreeNode *i_ptLinkBiTree,char i_cData);


static int CreateLinkBiTree(T_LinkBiTreeNode **i_pptLinkBiTree);
static T_LinkBiTreeNode *GetLinkBiTreeNodePoint(T_LinkBiTreeNode *i_ptLinkBiTree,char i_cData);
static int InsertChildInLinkBiTree(T_LinkBiTreeNode *i_ptLinkBiTreeNode,int i_iLeftOrRight,T_LinkBiTreeNode *i_ptInsertLinkBiTree);
static int DeleteChildInLinkBiTree(T_LinkBiTreeNode *i_ptLinkBiTreeNode,int i_iLeftOrRight);
static void PreOrderTraverseLinkBiTree(T_LinkBiTreeNode *i_ptLinkBiTree);
static void InOrderTraverseLinkBiTree(T_LinkBiTreeNode *i_ptLinkBiTree);
static void PostOrderTraverseLinkBiTree(T_LinkBiTreeNode *i_ptLinkBiTree);
static void LevelOrderTraverseLinkBiTree(T_LinkBiTreeNode *i_ptLinkBiTree);
static void UseStackInOrderTraverseLinkBiTree(T_LinkBiTreeNode *i_ptLinkBiTree);
static void OptimizeUseStackInOrderTraverseLinkBiTree(T_LinkBiTreeNode *i_ptLinkBiTree);

#define ClearLinkBiTree     DestroyLinkBiTree     // 清空二叉树和销毁二叉树的操作一样
#define     NIL     ' '
/*****************************************************************************
-Fuction        : main
-Description    : main
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/15      V1.0.0         Yu Weifeng       Created
******************************************************************************/
int main(int argc,char **argv)
{
    T_LinkBiTreeNode *ptLinkBiTree=NULL;    
    T_LinkBiTreeNode *ptLinkBiTreeNoRightChild=NULL;
    T_LinkBiTreeNode *ptLinkBiTreeNode=NULL;
    int iLeftOrRight=0;
    char cData;
    char cOtherData;
    InitLinkBiTree(&ptLinkBiTree);
    printf("构造空二叉树后,树空否？%d(0:是1:否)树的深度=%d
",IsLinkBiTreeEmpty(ptLinkBiTree),GetLinkBiTreeDepth(ptLinkBiTree));
    cData=GetLinkBiTreeRootData(ptLinkBiTree);
    if(cData!=NIL)
    printf("二叉树的根为%c
",cData);
    else
    printf("树空，无根
");
    printf("请先序输入二叉树(如:ab三个空格表示a为根结点,b为左子树的二叉树)
");
    CreateLinkBiTree(&ptLinkBiTree);
    printf("构造二叉树后,树空否？%d(0:是1:否)树的深度=%d
",IsLinkBiTreeEmpty(ptLinkBiTree),GetLinkBiTreeDepth(ptLinkBiTree));
    cData=GetLinkBiTreeRootData(ptLinkBiTree);
    if(cData!=NIL)
    printf("二叉树的根为%c
",cData);
    else
    printf("树空，无根
");
    printf("中序递归遍历二叉树:
");
    InOrderTraverseLinkBiTree(ptLinkBiTree);
    printf("
后序递归遍历二叉树:
");
    PostOrderTraverseLinkBiTree(ptLinkBiTree);

    printf("
请输入一个结点的值: ");
    scanf("%*c%c",&cData);//%*c吃掉回车符
    ptLinkBiTreeNode=GetLinkBiTreeNodePoint(ptLinkBiTree,cData); // p为e1的指针
    printf("结点的值为%c
",GetLinkBiTreeNodeData(ptLinkBiTreeNode));
    printf("欲改变此结点的值，请输入新值: ");
    scanf("%*c%c%*c",&cData); // 后一个%*c吃掉回车符，%*c不赋值任何变量,为调用CreateBiTree()做准备
    AssignToLinkBiTreeNode(ptLinkBiTreeNode,cData);//"*"表示该输入项读入后不赋予任何变量，即跳过该输入值
    printf("层序遍历二叉树:
");
    LevelOrderTraverseLinkBiTree(ptLinkBiTree);

    cOtherData=GetLinkBiTreeParentData(ptLinkBiTree,cData);
    if(cOtherData!=NIL)
    printf("%c的双亲是%c
",cData,cOtherData);
    else
    printf("%c没有双亲
",cData);
    cOtherData=GetLinkBiTreeLeftChildData(ptLinkBiTree,cData);
    if(cOtherData!=NIL)
    printf("%c的左孩子是%c
",cData,cOtherData);
    else
    printf("%c没有左孩子
",cData);
    cOtherData=GetLinkBiTreeRightChildData(ptLinkBiTree,cData);
    if(cOtherData!=NIL)
    printf("%c的右孩子是%c
",cData,cOtherData);
    else
    printf("%c没有右孩子
",cData);
    cOtherData=GetLinkBiTreeLeftSiblingData(ptLinkBiTree,cData);
    if(cOtherData!=NIL)
    printf("%c的左兄弟是%c
",cData,cOtherData);
    else
    printf("%c没有左兄弟
",cData);
    cOtherData=GetLinkBiTreeRightSiblingData(ptLinkBiTree,cData);
    if(cOtherData!=NIL)
    printf("%c的右兄弟是%c
",cData,cOtherData);
    else
    printf("%c没有右兄弟
",cData);

    
    InitLinkBiTree(&ptLinkBiTreeNoRightChild);
    printf("构造一个右子树为空的二叉树c:
");
    printf("请先序输入二叉树(如:ab三个空格表示a为根结点,b为左子树的二叉树)
");
    CreateLinkBiTree(&ptLinkBiTreeNoRightChild);
    printf("先序递归遍历二叉树c:
");
    PreOrderTraverseLinkBiTree(ptLinkBiTreeNoRightChild);
    printf("
层序遍历二叉树c:
");
    LevelOrderTraverseLinkBiTree(ptLinkBiTreeNoRightChild);

    printf("树c插到树T中,请输入树T中树c的双亲结点   c为左(0)或右(1)子树: ");
    scanf("%*c%c,%d",&cData,&iLeftOrRight);    
    ptLinkBiTreeNode=GetLinkBiTreeNodePoint(ptLinkBiTree,cData);  // p是T中树c的双亲结点指针
    InsertChildInLinkBiTree(ptLinkBiTreeNode,iLeftOrRight,ptLinkBiTreeNoRightChild);
    printf("先序递归遍历二叉树:
");
    PreOrderTraverseLinkBiTree(ptLinkBiTree);
    printf("
中序非递归遍历二叉树:
");
    UseStackInOrderTraverseLinkBiTree(ptLinkBiTree);
    
    printf("删除子树,请输入待删除子树的双亲结点    左(0)或右(1)子树: ");
    scanf("%*c%c,%d",&cData,&iLeftOrRight);    
    ptLinkBiTreeNode=GetLinkBiTreeNodePoint(ptLinkBiTree,cData); 
    DeleteChildInLinkBiTree(ptLinkBiTreeNode,iLeftOrRight);
    printf("先序递归遍历二叉树:
");
    PreOrderTraverseLinkBiTree(ptLinkBiTree);
    printf("
中序非递归遍历二叉树(另一种方法):
");
    OptimizeUseStackInOrderTraverseLinkBiTree(ptLinkBiTree);
    DestroyLinkBiTree(ptLinkBiTree);
}





/*****************************************************************************
-Fuction        : InitLinkBiTree
-Description    : InitLinkBiTree
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/15      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void InitLinkBiTree(T_LinkBiTreeNode **i_pptLinkBiTree)
{
    *i_pptLinkBiTree=NULL;
}
/*****************************************************************************
-Fuction        : CreateLinkBiTree
-Description    : 按先序次序输入二叉树中结点的值(为字符型)
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/15      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int CreateLinkBiTree(T_LinkBiTreeNode **i_pptLinkBiTree)
{
    int iRet=0;
    char cData;
    scanf("%c",&cData);
    if(cData==NIL)//Nil表示空(子)树
    {
        *i_pptLinkBiTree=NULL;
    }
    else
    {
        *i_pptLinkBiTree=(T_LinkBiTreeNode *)malloc(sizeof(T_LinkBiTreeNode));
        if(NULL==*i_pptLinkBiTree)
        {
            printf("CreateLinkBiTree malloc err
");
            iRet=-1;
        }
        else
        {
            (*i_pptLinkBiTree)->cData=cData;
            CreateLinkBiTree(&(*i_pptLinkBiTree)->ptLeftChild);
            CreateLinkBiTree(&(*i_pptLinkBiTree)->ptRightChild);
        }
    }
    return iRet;
}
/*****************************************************************************
-Fuction        : DestroyLinkBiTree
-Description    : DestroyLinkBiTree
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/15      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void DestroyLinkBiTree(T_LinkBiTreeNode *i_ptLinkBiTree)
{
    if(NULL==i_ptLinkBiTree)
    {
    }
    else
    {
        if(NULL==i_ptLinkBiTree->ptLeftChild)
        {
        }
        else
        {
            DestroyLinkBiTree(i_ptLinkBiTree->ptLeftChild);
        }
        if(NULL==i_ptLinkBiTree->ptRightChild)
        {
        }
        else
        {
            DestroyLinkBiTree(i_ptLinkBiTree->ptRightChild);
        }
        free(i_ptLinkBiTree);
        i_ptLinkBiTree=NULL;
    }
}
/*****************************************************************************
-Fuction        : PreOrderTraverseLinkBiTree
-Description    : PreOrderTraverseLinkBiTree
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/15      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void PreOrderTraverseLinkBiTree(T_LinkBiTreeNode *i_ptLinkBiTree)
{
    if(NULL==i_ptLinkBiTree)
    {
    }
    else
    {
        printf("%c ",i_ptLinkBiTree->cData);
        PreOrderTraverseLinkBiTree(i_ptLinkBiTree->ptLeftChild);
        PreOrderTraverseLinkBiTree(i_ptLinkBiTree->ptRightChild);
    }
}
/*****************************************************************************
-Fuction        : InOrderTraverseLinkBiTree
-Description    : InOrderTraverseLinkBiTree
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/15      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void InOrderTraverseLinkBiTree(T_LinkBiTreeNode *i_ptLinkBiTree)
{
    if(NULL==i_ptLinkBiTree)
    {
    }
    else
    {
        InOrderTraverseLinkBiTree(i_ptLinkBiTree->ptLeftChild);
        printf("%c ",i_ptLinkBiTree->cData);
        InOrderTraverseLinkBiTree(i_ptLinkBiTree->ptRightChild);
    }
}
/*****************************************************************************
-Fuction        : PostOrderTraverseLinkBiTree
-Description    : PostOrderTraverseLinkBiTree
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/15      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void PostOrderTraverseLinkBiTree(T_LinkBiTreeNode *i_ptLinkBiTree)
{
    if(NULL==i_ptLinkBiTree)
    {
    }
    else
    {
        PostOrderTraverseLinkBiTree(i_ptLinkBiTree->ptLeftChild);
        PostOrderTraverseLinkBiTree(i_ptLinkBiTree->ptRightChild);
        printf("%c ",i_ptLinkBiTree->cData);
    }
}
/*****************************************************************************
-Fuction        : LevelOrderTraverseLinkBiTree
-Description    : 
// 初始条件：二叉树T存在，Visit是对结点操作的应用函数
// 操作结果：层序递归遍历T(利用队列)，对每个结点调用函数Visit一次且仅一次
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/15      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void LevelOrderTraverseLinkBiTree(T_LinkBiTreeNode *i_ptLinkBiTree)
{
    T_LinkQueue tLinkQueue={0};
    T_LinkBiTreeNode *ptBiTreeNode=NULL;
    T_QueueDataElement tQueueElement;
    InitLinkQueue(&tLinkQueue);
    tQueueElement.ptData=i_ptLinkBiTree;
    EnterLinkQueue(&tLinkQueue,tQueueElement);
    while(0!=IsLinkQueueEmpty(&tLinkQueue))
    {
        ExitLinkQueue(&tLinkQueue,&tQueueElement);
        printf("%c ",tQueueElement.ptData->cData);
        ptBiTreeNode=tQueueElement.ptData;
        if(NULL==ptBiTreeNode->ptLeftChild)
        {
        }
        else
        {
            tQueueElement.ptData=ptBiTreeNode->ptLeftChild;
            EnterLinkQueue(&tLinkQueue,tQueueElement);
        }
        if(NULL==ptBiTreeNode->ptRightChild)
        {
        }
        else
        {
            tQueueElement.ptData=ptBiTreeNode->ptRightChild;
            EnterLinkQueue(&tLinkQueue,tQueueElement);//左右孩子入队后，如果该结点还有兄弟没处理，
        }//接下来处理的就是之前入队的兄弟结点
    }
    printf("
");
}
/*****************************************************************************
-Fuction        : UseStackInOrderTraverseLinkBiTree
-Description    : // 中序遍历二叉树T的非递归算法(利用栈)，
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/15      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void UseStackInOrderTraverseLinkBiTree(T_LinkBiTreeNode *i_ptLinkBiTree)
{
    T_SeqStack tSeqStack={0};
    T_StackElement tStackElement={0};
    InitSeqStack(&tSeqStack);
    tStackElement.ptData=i_ptLinkBiTree;
    while(NULL!=tStackElement.ptData||0!=IsSeqStackEmpty(&tSeqStack))
    {
        if(NULL!=tStackElement.ptData)//指针不为空一直入栈
        {
            PushSeqStack(&tSeqStack,&tStackElement);
            tStackElement.ptData=tStackElement.ptData->ptLeftChild;//先放左子树
        }
        else
        {//当左子树为空则出栈为左子树的父结点
            PopSeqStack(&tSeqStack,&tStackElement);//当为右孩子为空则出栈为根结点
            printf("%c ",tStackElement.ptData->cData);
        //当左子树时，右孩子为空不会被入栈
            tStackElement.ptData=tStackElement.ptData->ptRightChild;//当为根结点时右孩子入栈
        }
    }
    printf("
");
}
/*****************************************************************************
-Fuction        : OptimizeUseStackInOrderTraverseLinkBiTree
-Description    : 先PUSH
// 中序遍历二叉树T的非递归算法(利用栈)，
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/15      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void OptimizeUseStackInOrderTraverseLinkBiTree(T_LinkBiTreeNode *i_ptLinkBiTree)
{
    T_SeqStack tSeqStack={0};
    T_StackElement tStackElement={0};
    InitSeqStack(&tSeqStack);
    tStackElement.ptData=i_ptLinkBiTree;
    PushSeqStack(&tSeqStack,&tStackElement);//先PUSH
    while(0!=IsSeqStackEmpty(&tSeqStack))
    {
        while(0==GetSeqStackTopElement(&tSeqStack,&tStackElement)&&NULL!=tStackElement.ptData)
        {
            tStackElement.ptData=tStackElement.ptData->ptLeftChild;// 向左走到尽头,左优先
            PushSeqStack(&tSeqStack,&tStackElement);
        }
        PopSeqStack(&tSeqStack,&tStackElement);// 空指针退栈
        if(0!=IsSeqStackEmpty(&tSeqStack))// 访问结点，向右一步
        {//由于前面空指针退栈，再次出栈就是左孩子了
            PopSeqStack(&tSeqStack,&tStackElement);//当为右孩子为空前面有空出栈,
            printf("%c ",tStackElement.ptData->cData);//所以出栈为根结点
        //当左子树时，右孩子为空前面会出栈
            tStackElement.ptData=tStackElement.ptData->ptRightChild;//当为根结点时右孩子入栈
            PushSeqStack(&tSeqStack,&tStackElement);//当右孩子子树为空则访问右孩子，实现中序遍历
        }
        else
        {
        }
    }
    printf("
");
}

/*****************************************************************************
-Fuction        : IsLinkBiTreeEmpty
-Description    : IsLinkBiTreeEmpty
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/15      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int IsLinkBiTreeEmpty(T_LinkBiTreeNode *i_ptLinkBiTree)
{
    int iRet=0;
    if(NULL==i_ptLinkBiTree)
    {
    }
    else
    {
        iRet=-1;
    }
    return iRet;
}
/*****************************************************************************
-Fuction        : GetLinkBiTreeDepth
-Description    : GetLinkBiTreeDepth
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/15      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int GetLinkBiTreeDepth(T_LinkBiTreeNode *i_ptLinkBiTree)
{
    int iTreeDepth=0;
    int iLeftTreeDepth=0,iRightTreeDepth=0;
    if(NULL==i_ptLinkBiTree)
    {
        iTreeDepth=0;// 空树深度为0
    }
    else
    {
        if(NULL==i_ptLinkBiTree->ptLeftChild)
        {
            iLeftTreeDepth=0;//就一个时就本身时，深度为1，后面就会要加一
        }
        else
        {
            iLeftTreeDepth=GetLinkBiTreeDepth(i_ptLinkBiTree->ptLeftChild);// 为左子树的深度
        }//求得子树的深度，需要加上本身的深度，所以后面也会要加一
        if(NULL==i_ptLinkBiTree->ptRightChild)
        {
            iRightTreeDepth=0;
        }
        else
        {
            iRightTreeDepth=GetLinkBiTreeDepth(i_ptLinkBiTree->ptRightChild);// 为右子树的深度
        }
        iTreeDepth=iLeftTreeDepth>iRightTreeDepth?iLeftTreeDepth+1:iRightTreeDepth+1;
        // T的深度为其左右子树的深度中的大者+1
    }

    return iTreeDepth;
}
/*****************************************************************************
-Fuction        : GetLinkBiTreeRootData
-Description    : GetLinkBiTreeRootData
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/15      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static char GetLinkBiTreeRootData(T_LinkBiTreeNode *i_ptLinkBiTree)
{
    char cData;
    if(0==IsLinkBiTreeEmpty(i_ptLinkBiTree))
    {
        cData=NIL;
    }
    else
    {
        cData=i_ptLinkBiTree->cData;
    }
    return cData;
}
/*****************************************************************************
-Fuction        : GetLinkBiTreeNodeData
-Description    : GetLinkBiTreeNodeData
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/15      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static char GetLinkBiTreeNodeData(T_LinkBiTreeNode *i_ptLinkBiTreeNode)
{
    return i_ptLinkBiTreeNode->cData;
}
/*****************************************************************************
-Fuction        : AssignToLinkBiTreeNode
-Description    : AssignToLinkBiTreeNode
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/15      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void AssignToLinkBiTreeNode(T_LinkBiTreeNode *i_ptLinkBiTreeNode,char i_cData)
{
    i_ptLinkBiTreeNode->cData=i_cData;
}
/*****************************************************************************
-Fuction        : GetLinkBiTreeNodePoint
-Description    : // 返回二叉树T中指向元素值为s的结点的指针
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/15      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static T_LinkBiTreeNode *GetLinkBiTreeNodePoint(T_LinkBiTreeNode *i_ptLinkBiTree,char i_cData)
{
    T_LinkQueue tLinkQueue={0};
    T_QueueDataElement tExitQueueElement={0};
    T_QueueDataElement tEnterQueueElement={0};
    T_LinkBiTreeNode *ptLinkBiTreeNode=NULL;
    if(NULL==i_ptLinkBiTree)// 非空树
    {
    }
    else
    {
        InitLinkQueue(&tLinkQueue);
        tEnterQueueElement.ptData=i_ptLinkBiTree;
        EnterLinkQueue(&tLinkQueue,tEnterQueueElement);// 根指针入队
        while(0!=IsLinkQueueEmpty(&tLinkQueue))// 队不空// 出队
        {
            ExitLinkQueue(&tLinkQueue,&tExitQueueElement);
            //printf("EnterData:%c
",tExitQueueElement.ptData->cData);
            if(i_cData==tExitQueueElement.ptData->cData)
            {
                ptLinkBiTreeNode=tExitQueueElement.ptData;
                break;
            }
            else
            {
                if(NULL==tExitQueueElement.ptData->ptLeftChild)
                {
                }
                else
                {
                    tEnterQueueElement.ptData=tExitQueueElement.ptData->ptLeftChild;
                    EnterLinkQueue(&tLinkQueue,tEnterQueueElement);// 入队左孩子
                    //printf("1EnterLinkQueue:%c
",tEnterQueueElement.ptData->cData);
                }
                if(NULL==tExitQueueElement.ptData->ptRightChild)
                {
                }
                else
                {
                    tEnterQueueElement.ptData=tExitQueueElement.ptData->ptRightChild;
                    EnterLinkQueue(&tLinkQueue,tEnterQueueElement);// 入队右孩子
                    //printf("2EnterLinkQueue:%c
",tEnterQueueElement.ptData->cData);
                }
            }
        }
    }
    return ptLinkBiTreeNode;
}
/*****************************************************************************
-Fuction        : GetLinkBiTreeNodeParentData
-Description    : 
// 操作结果：若i_cData是T的非根结点，则返回它的双亲，否则返回“空”
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/15      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static char GetLinkBiTreeParentData(T_LinkBiTreeNode *i_ptLinkBiTree,char i_cData)
{
    T_LinkQueue tLinkQueue={0};
    T_QueueDataElement tExitQueueElement;
    T_QueueDataElement tEnterQueueElement;
    char  cData=NIL;
    if(NULL==i_ptLinkBiTree)
    {
    }
    else
    {
        InitLinkQueue(&tLinkQueue);
        tEnterQueueElement.ptData=i_ptLinkBiTree;
        EnterLinkQueue(&tLinkQueue,tEnterQueueElement);// 根指针入队
        while(0!=IsLinkQueueEmpty(&tLinkQueue))// 队不空// 出队
        {
            ExitLinkQueue(&tLinkQueue,&tExitQueueElement);
            //printf("EnterParentData:%c
",tExitQueueElement.ptData->cData);
            if(((NULL!=tExitQueueElement.ptData->ptLeftChild)&&(i_cData==tExitQueueElement.ptData->ptLeftChild->cData)) ||
                ((NULL!=tExitQueueElement.ptData->ptRightChild)&&(i_cData==tExitQueueElement.ptData->ptRightChild->cData)))
            {
                cData=tExitQueueElement.ptData->cData;
                break;
            }
            else
            {
                if(NULL==tExitQueueElement.ptData->ptLeftChild)
                {
                }
                else
                {
                    tEnterQueueElement.ptData=tExitQueueElement.ptData->ptLeftChild;
                    EnterLinkQueue(&tLinkQueue,tEnterQueueElement);// 入队左孩子
                }
                if(NULL==tExitQueueElement.ptData->ptRightChild)
                {
                }
                else
                {
                    tEnterQueueElement.ptData=tExitQueueElement.ptData->ptRightChild;
                    EnterLinkQueue(&tLinkQueue,tEnterQueueElement);// 入队右孩子
                }
            }
        }
    }
    return cData;
}
/*****************************************************************************
-Fuction        : GetLinkBiTreeLeftChildData
-Description    : 
// 初始条件：二叉树存在，i_cData是树中某个结点数据。
操作结果：返回i_cData的左孩子。若i_cData无左孩子,则返回“空”
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/15      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static char GetLinkBiTreeLeftChildData(T_LinkBiTreeNode *i_ptLinkBiTree,char i_cData)
{
    T_LinkBiTreeNode *ptBiTreeNode=NULL;
    char  cData=NIL;
    if(NULL==i_ptLinkBiTree)
    {
    }
    else
    {
        ptBiTreeNode=GetLinkBiTreeNodePoint(i_ptLinkBiTree,i_cData);
        if(NULL!=ptBiTreeNode&&NULL!=ptBiTreeNode->ptLeftChild)
        {
            cData=ptBiTreeNode->ptLeftChild->cData;
        }
        else{
        }
    }
    return cData;
}
/*****************************************************************************
-Fuction        : GetLinkBiTreeRightChildData
-Description    : 
// 初始条件：二叉树存在，i_cData是树中某个结点数据。
操作结果：返回i_cData的左孩子。若i_cData无左孩子,则返回“空”
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/15      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static char GetLinkBiTreeRightChildData(T_LinkBiTreeNode *i_ptLinkBiTree,char i_cData)
{
    T_LinkBiTreeNode *ptBiTreeNode=NULL;
    char  cData=NIL;
    if(NULL==i_ptLinkBiTree)
    {
    }
    else
    {
        ptBiTreeNode=GetLinkBiTreeNodePoint(i_ptLinkBiTree,i_cData);
        if(NULL!=ptBiTreeNode&&NULL!=ptBiTreeNode->ptRightChild)
        {
            cData=ptBiTreeNode->ptRightChild->cData;
        }
        else{
        }
    }
    return cData;
}
/*****************************************************************************
-Fuction        : GetLinkBiTreeLeftSiblingData
-Description    : 
// 初始条件：二叉树存在，i_cData是树中某个结点数据。
操作结果：返回i_cData的左孩子。若i_cData无左孩子,则返回“空”
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/15      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static char GetLinkBiTreeLeftSiblingData(T_LinkBiTreeNode *i_ptLinkBiTree,char i_cData)
{
    T_LinkBiTreeNode *ptBiTreeNode=NULL;
    char cParentData=NIL;
    char  cData=NIL;
    if(NULL==i_ptLinkBiTree)
    {
    }
    else
    {
        cParentData=GetLinkBiTreeParentData(i_ptLinkBiTree,i_cData);
        if(NIL==cParentData)
        {
        }
        else
        {
            ptBiTreeNode=GetLinkBiTreeNodePoint(i_ptLinkBiTree,cParentData);
            if(NULL!=ptBiTreeNode&&NULL!=ptBiTreeNode->ptLeftChild
                &&NULL!=ptBiTreeNode->ptRightChild &&i_cData==ptBiTreeNode->ptRightChild->cData)
            {
                cData=ptBiTreeNode->ptLeftChild->cData;
            }
            else{
            }
        }
    }
    return cData;
}
/*****************************************************************************
-Fuction        : GetLinkBiTreeRightSiblingData
-Description    : 
// 初始条件：二叉树存在，i_cData是树中某个结点数据。
操作结果：返回i_cData的左孩子。若i_cData无左孩子,则返回“空”
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/15      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static char GetLinkBiTreeRightSiblingData(T_LinkBiTreeNode *i_ptLinkBiTree,char i_cData)
{
    T_LinkBiTreeNode *ptBiTreeNode=NULL;
    char cParentData=NIL;
    char  cData=NIL;
    if(NULL==i_ptLinkBiTree)
    {
    }
    else
    {
        cParentData=GetLinkBiTreeParentData(i_ptLinkBiTree,i_cData);
        if(NIL==cParentData)
        {
        }
        else
        {
            ptBiTreeNode=GetLinkBiTreeNodePoint(i_ptLinkBiTree,cParentData);
            if(NULL!=ptBiTreeNode&&NULL!=ptBiTreeNode->ptLeftChild
                &&NULL!=ptBiTreeNode->ptRightChild &&i_cData==ptBiTreeNode->ptLeftChild->cData)
            {
                cData=ptBiTreeNode->ptRightChild->cData;
            }
            else{
            }
        }
    }
    return cData;
}
/*****************************************************************************
-Fuction        : InsertChildInLinkBiTree
-Description    : 
// 初始条件：二叉树T存在，i_ptLinkBiTreeNode指向T中某个结点，
i_iLeftOrRight为0或1，非空二叉树i_ptInsertLinkBiTree与T不相交且右子树为空
// 操作结果：根据i_iLeftOrRight为0或1，插入i_ptInsertLinkBiTree为T中
i_ptLinkBiTreeNode所指结点的左或右子树。i_ptLinkBiTreeNode所指结点的
// 原有左或右子树则成为i_ptInsertLinkBiTree的右子树
-Input            : 
-Output         : 
-Return         : -1 false         0 true
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/15      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int InsertChildInLinkBiTree(T_LinkBiTreeNode *i_ptLinkBiTreeNode,int i_iLeftOrRight,T_LinkBiTreeNode *i_ptInsertLinkBiTree)
{
    int iRet=-1;
    if(NULL==i_ptLinkBiTreeNode)
    {
        iRet=-1;
    }
    else
    {
        iRet=0;
        if(0==i_iLeftOrRight)
        {
            i_ptInsertLinkBiTree->ptRightChild=i_ptLinkBiTreeNode->ptLeftChild;
            i_ptLinkBiTreeNode->ptLeftChild=i_ptInsertLinkBiTree;
        }
        else if(1==i_iLeftOrRight)
        {
            i_ptInsertLinkBiTree->ptRightChild=i_ptLinkBiTreeNode->ptRightChild;
            i_ptLinkBiTreeNode->ptRightChild=i_ptInsertLinkBiTree;
        }
        else
        {
            printf("UnknowChild:%d,InsertChildInLinkBiTree err
",i_iLeftOrRight);
            iRet=-1;
        }
    }
    return iRet;
}
/*****************************************************************************
-Fuction        : InsertChildInLinkBiTree
-Description    : 
// 初始条件：二叉树T存在，i_ptLinkBiTreeNode指向T中某个结点，i_iLeftOrRight为0或1
// 操作结果：根据i_iLeftOrRight为0或1，删除T中i_ptLinkBiTreeNode所指结点的左或右子树
-Input            : 
-Output         : 
-Return         : -1 false         0 true
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/15      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int DeleteChildInLinkBiTree(T_LinkBiTreeNode *i_ptLinkBiTreeNode,int i_iLeftOrRight)
{
    int iRet=-1;
    if(NULL==i_ptLinkBiTreeNode)
    {
        iRet=-1;
    }
    else
    {
        iRet=0;
        if(0==i_iLeftOrRight)
        {
            ClearLinkBiTree(i_ptLinkBiTreeNode->ptLeftChild);
        }
        else if(1==i_iLeftOrRight)
        {
            ClearLinkBiTree(i_ptLinkBiTreeNode->ptRightChild);
        }
        else
        {
            printf("UnknowChild:%d,DeleteChildInLinkBiTree err
",i_iLeftOrRight);
            iRet=-1;
        }
    }
    return iRet;
}

/*****************************************************************************
* Copyright (C) 2017-2018 Hanson Yu  All rights reserved.
------------------------------------------------------------------------------
* File Module        :     LinkBiTree.h
* Description        :     LinkBiTree operation center
* Created            :     2017.05.17.
* Author            :     Yu Weifeng
* Function List         :     
* Last Modified     :     
* History            :     
******************************************************************************/
#ifndef _LINK_BI_TREE_H
#define _LINK_BI_TREE_H

typedef struct LinkBiTreeNode
{
    char cData;
    struct LinkBiTreeNode *ptLeftChild,*ptRightChild;
}T_LinkBiTreeNode,*PT_LinkBiTreeNode;




#endif

2)顺序二叉树

/*****************************************************************************
* Copyright (C) 2017-2018 Hanson Yu  All rights reserved.
------------------------------------------------------------------------------
* File Module        :     SeqBiTree.c
* Description        :     SeqBiTree operation center
* Created            :     2017.05.08.
* Author            :     Yu Weifeng
* Function List         :     
* Last Modified     :     
* History            :     
******************************************************************************/
#include "stdio.h"
#include "malloc.h"
#include "stdlib.h"
#include "string.h"
#include "math.h"
#include "LinkQueue.c"

typedef struct SeqBiTreeElement
{
    //char cData;//NULL表示空元素也就是空结点
    int iData;//0表示空元素也就是空结点
}T_SeqBiTreeElement,*PT_SeqBiTreeElement;

typedef struct PositionInTree
{
    int iLevel;//元素处在的层次 从1开始
    int iOrder;//元素在本层中的序号  从1开始
}T_PositionInTree,*PT_PositionInTree;

#define MAX_SEQ_BINARY_TREE_LEN    100

static void InitSeqBiTree(T_SeqBiTreeElement *i_ptSeqBiTree);
static void CreateSeqBiTree(T_SeqBiTreeElement *i_ptSeqBiTree);
static void LevelOrderTraverseSeqBiTree(T_SeqBiTreeElement *i_ptSeqBiTree);
static void PreOrderTraverseSeqBiTree(T_SeqBiTreeElement *i_ptSeqBiTree);
static void InOrderTraverseSeqBiTree(T_SeqBiTreeElement *i_ptSeqBiTree);
static void PostOrderTraverseSeqBiTree(T_SeqBiTreeElement *i_ptSeqBiTree);
static T_SeqBiTreeElement GetSeqBiTreeElement(T_SeqBiTreeElement *i_ptSeqBiTree,T_PositionInTree *i_ptPos);
static int AssignToSeqBiTreeElement(T_SeqBiTreeElement *i_ptSeqBiTree,T_PositionInTree *i_ptPos,T_SeqBiTreeElement *i_ptValue);
static void PreOrderTraverseSeqBiTree(T_SeqBiTreeElement *i_ptSeqBiTree);

static T_SeqBiTreeElement GetParentFromSeqBiTree(T_SeqBiTreeElement *i_ptSeqBiTree,T_SeqBiTreeElement *i_ptTreeElement);
static T_SeqBiTreeElement GetLeftChildFromSeqBiTree(T_SeqBiTreeElement *i_ptSeqBiTree,T_SeqBiTreeElement *i_ptTreeElement);
static T_SeqBiTreeElement GetRightChildFromSeqBiTree(T_SeqBiTreeElement *i_ptSeqBiTree,T_SeqBiTreeElement *i_ptTreeElement);
static T_SeqBiTreeElement GetLeftSiblingFromSeqBiTree(T_SeqBiTreeElement *i_ptSeqBiTree,T_SeqBiTreeElement *i_ptTreeElement);
static T_SeqBiTreeElement GetRightSiblingFromSeqBiTree(T_SeqBiTreeElement *i_ptSeqBiTree,T_SeqBiTreeElement *i_ptTreeElement);

static void PrintfSeqBiTree(T_SeqBiTreeElement *i_ptSeqBiTree);
static void InsertChildInSeqBiTree(T_SeqBiTreeElement *i_ptSeqBiTree,T_SeqBiTreeElement *i_ptInsertNode,int i_iLeftOrRight,T_SeqBiTreeElement *i_ptInsertTree);
static int DeleteChildInSeqBiTree(T_SeqBiTreeElement *i_ptSeqBiTree,T_PositionInTree*i_ptDeleteNodePos,int i_iLeftOrRight);

#define ClearSeqBiTree     InitSeqBiTree     // 在顺序存储结构中，两函数完全一样
#define DestroySeqBiTree     InitSeqBiTree         // 在顺序存储结构中，两函数完全一样
#define NIL 0
static int IsSeqBiTreeEmpty(T_SeqBiTreeElement *i_ptSeqBiTree);
static int GetSeqBiTreeDepth(T_SeqBiTreeElement *i_ptSeqBiTree);
/*****************************************************************************
-Fuction        : main
-Description    : main
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/08      V1.0.0         Yu Weifeng       Created
******************************************************************************/
int main(int argc,char **argv)
{
    T_SeqBiTreeElement atSeqBiTree[MAX_SEQ_BINARY_TREE_LEN]={0};
    T_SeqBiTreeElement atSeqBiTreeRightTreeNull[MAX_SEQ_BINARY_TREE_LEN]={0};
    T_PositionInTree tPos={0};
    T_SeqBiTreeElement tElement={0};
    T_SeqBiTreeElement tOtherElement={0};
    int iLeftOrRight;
    
    CreateSeqBiTree(atSeqBiTree);
    printf("建立二叉树后,树空否？%d(1:是0:否) 树的深度=%d
",IsSeqBiTreeEmpty(atSeqBiTree),GetSeqBiTreeDepth(atSeqBiTree));
    printf("层序遍历二叉树:");
    LevelOrderTraverseSeqBiTree(atSeqBiTree);
    printf("中序遍历二叉树:");
    InOrderTraverseSeqBiTree(atSeqBiTree);
    printf("后序遍历二叉树:");
    PostOrderTraverseSeqBiTree(atSeqBiTree);
    
    printf("请输入待修改结点的层号,本层序号:");
    scanf("%d,%d",&tPos.iLevel,&tPos.iOrder);
    tElement=GetSeqBiTreeElement(atSeqBiTree,&tPos);
    printf("待修改结点的原值为%d,请输入新值:",tElement.iData);
    scanf("%d",&tElement.iData);
    AssignToSeqBiTreeElement(atSeqBiTree,&tPos,&tElement);
    printf("先序遍历二叉树:");
    PreOrderTraverseSeqBiTree(atSeqBiTree);

    tOtherElement=GetParentFromSeqBiTree(atSeqBiTree,&tElement);
    printf("结点%d的双亲为%d
",tElement.iData,tOtherElement.iData);
    tOtherElement=GetLeftChildFromSeqBiTree(atSeqBiTree,&tElement);
    printf("结点%d的左孩子为%d
",tElement.iData,tOtherElement.iData);
    tOtherElement=GetRightChildFromSeqBiTree(atSeqBiTree,&tElement);
    printf("结点%d的右孩子为%d
",tElement.iData,tOtherElement.iData);
    tOtherElement=GetLeftSiblingFromSeqBiTree(atSeqBiTree,&tElement);
    printf("结点%d的左兄弟为%d
",tElement.iData,tOtherElement.iData);
    tOtherElement=GetRightSiblingFromSeqBiTree(atSeqBiTree,&tElement);
    printf("结点%d的右兄弟为%d
",tElement.iData,tOtherElement.iData);
    
    printf("建立右子树为空的树s:");
    CreateSeqBiTree(atSeqBiTreeRightTreeNull);
    printf("层序遍历二叉树:");
    LevelOrderTraverseSeqBiTree(atSeqBiTreeRightTreeNull);
    printf("树s插到树T中,请输入树T中树s的双亲结点,s为左(0)或右(1)子树:");
    scanf("%d,%d",&tElement.iData,&iLeftOrRight);
    InsertChildInSeqBiTree(atSeqBiTree,&tElement,iLeftOrRight,atSeqBiTreeRightTreeNull);
    PrintfSeqBiTree(atSeqBiTree);
    printf("删除子树,请输入待删除子树根结点的层号,本层序号,左(0)或右(1)子树:");
    scanf("%d,%d,%d",&tPos.iLevel,&tPos.iOrder,&iLeftOrRight);
    DeleteChildInSeqBiTree(atSeqBiTree,&tPos,iLeftOrRight);
    PrintfSeqBiTree(atSeqBiTree);

    ClearSeqBiTree(atSeqBiTree);
    printf("清除二叉树后,树空否？%d(1:是0:否) 树的深度=%d
",IsSeqBiTreeEmpty(atSeqBiTree),GetSeqBiTreeDepth(atSeqBiTree));
    
    return 0;
}
/*****************************************************************************
-Fuction        : InitSeqBiTree
-Description    : InitSeqBiTree
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/08      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void InitSeqBiTree(T_SeqBiTreeElement *i_ptSeqBiTree)
{
    int i;
    for(i=0;i<MAX_SEQ_BINARY_TREE_LEN;i++)
    {
        i_ptSeqBiTree[i].iData=0;//初始化，没有元素为0
    }

}
/*****************************************************************************
-Fuction        : CreateSeqBiTree
-Description    : CreateSeqBiTree
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/08      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void CreateSeqBiTree(T_SeqBiTreeElement *i_ptSeqBiTree)
{
    int i;
    int iData=0;
    char acBiTreeElement[MAX_SEQ_BINARY_TREE_LEN]={0};
    InitSeqBiTree(i_ptSeqBiTree);
    /*printf("请按层序输入结点的值(字符)，空格表示空结点，结点数:%d
",MAX_SEQ_BINARY_TREE_LEN);
    for(i=0;i<MAX_SEQ_BINARY_TREE_LEN;i++)
    {
        iData=getchar();
        if(iData==EOF)
        {
            break;
        }
        else
        {
            i_ptSeqBiTree[i].cData=(char)iData;
        }
    }*/
    printf("请按层序输入结点的值(整型)，0表示空结点，输999结束。结点数:%d
",MAX_SEQ_BINARY_TREE_LEN);
    for(i=0;i<MAX_SEQ_BINARY_TREE_LEN;i++)
    {
        scanf("%d",&iData);
        if(iData==999)
        {
            i_ptSeqBiTree[i].iData=0;
            break;
        }
        else
        {
            i_ptSeqBiTree[i].iData=iData;
        }
    }
    for(i=1;i<MAX_SEQ_BINARY_TREE_LEN;i++)
    {
        if((i!=0)&&(i_ptSeqBiTree[i].iData!=0)&&(i_ptSeqBiTree[(i+1)/2-1].iData==0))
        {
            printf("出现结点(不空)无双亲且不是根,程序退出
");
            exit(-1);
        }
        else
        {
        }
    }
}
/*****************************************************************************
-Fuction        : InitSeqBiTree
-Description    : InitSeqBiTree
-Input            : 
-Output         : 1代表空
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/08      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int IsSeqBiTreeEmpty(T_SeqBiTreeElement *i_ptSeqBiTree)
{
    int iRet=0;
    if(i_ptSeqBiTree[0].iData!=0)
    {
        iRet=0;
    }
    else
    {
        iRet=1;
    }
    return iRet;
}
/*****************************************************************************
-Fuction        : GetSeqBiTreeDepth
-Description    : GetSeqBiTreeDepth
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/08      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int GetSeqBiTreeDepth(T_SeqBiTreeElement *i_ptSeqBiTree)
{
    int iDepth;
    int i,j;
    for(i=MAX_SEQ_BINARY_TREE_LEN-1;i>=0;i--)//中间可能出现空节点
    {
        if(i_ptSeqBiTree[i].iData==0)
        {
        }
        else
        {
            break;//指向最后一个非空结点为其序号
        }
    }
    i++;//树的长度，或者从1开始算的序号
    //这样算树每层第一个序号就是1,2,4,8,方便比较计算
    j=-1;//没有根节点，即结点为空时，深度为0,所以从-1开始
    do{
        j++;
    }while(i>=pow(2,j));
    return j;
}
/*****************************************************************************
-Fuction        : GetSeqBiTreeElement
-Description    : GetSeqBiTreeElement
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/08      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static T_SeqBiTreeElement GetSeqBiTreeElement(T_SeqBiTreeElement *i_ptSeqBiTree,T_PositionInTree *i_ptPos)
{
    T_SeqBiTreeElement tTreeElement={0};
    tTreeElement=i_ptSeqBiTree[(int)(pow(2,i_ptPos->iLevel-1)+i_ptPos->iOrder-2)];
    return tTreeElement;
}
/*****************************************************************************
-Fuction        : AssignToSeqBiTreeElement
-Description    :
// 操作结果：给处于位置e(层,本层序号)的结点赋新值value
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/08      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int AssignToSeqBiTreeElement(T_SeqBiTreeElement *i_ptSeqBiTree,T_PositionInTree *i_ptPos,T_SeqBiTreeElement *i_ptValue)
{
    int iRet=0;
    int i=0;
    i=(int)(pow(2,i_ptPos->iLevel-1)+i_ptPos->iOrder-2);// 将层、本层序号转为数组的序号
    if((i_ptValue->iData!=0)&&(i_ptSeqBiTree[(i+1)/2-1].iData==0))// 给叶子赋非空值但双亲为空
    {
        iRet=-1;
        printf("DataNull,ButElementParentNull err
");
    }
    else if((i_ptValue->iData==0)&&((i_ptSeqBiTree[2*i+1].iData!=0)||(i_ptSeqBiTree[2*i+2].iData!=0)))// 给双亲赋空值但有叶子(不空)
    {
        iRet=-1;
        printf("DataNull,ButHaveChildNotNull err
");
    }
    else
    {
        memcpy(&i_ptSeqBiTree[i],i_ptValue,sizeof(T_SeqBiTreeElement));
        iRet=0;
    }
    return iRet;
}
/*****************************************************************************
-Fuction        : GetParentFromSeqBiTree
-Description    :
// 操作结果：若e是T的非根结点，则返回它的双亲；否则返回“空”
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/08      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static T_SeqBiTreeElement GetParentFromSeqBiTree(T_SeqBiTreeElement *i_ptSeqBiTree,T_SeqBiTreeElement *i_ptTreeElement)
{
    T_SeqBiTreeElement tSeqBiTreeElement={0};
    tSeqBiTreeElement.iData=0;
    int i=0;
    if(i_ptSeqBiTree[0].iData==0)// 空树
    {
    }
    else
    {
        for(i=1;i<MAX_SEQ_BINARY_TREE_LEN;i++)
        {
            if(i_ptSeqBiTree[i].iData==i_ptTreeElement->iData)// 找到
            {
                memcpy(&tSeqBiTreeElement,&i_ptSeqBiTree[(i+1)/2-1],sizeof(T_SeqBiTreeElement));
            }
            else
            {
            }
        }
    }
    return tSeqBiTreeElement;
}
/*****************************************************************************
-Fuction        : GetLeftChildFromSeqBiTree
-Description    :
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/08      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static T_SeqBiTreeElement GetLeftChildFromSeqBiTree(T_SeqBiTreeElement *i_ptSeqBiTree,T_SeqBiTreeElement *i_ptTreeElement)
{
    T_SeqBiTreeElement tSeqBiTreeElement={0};
    tSeqBiTreeElement.iData=0;
    int i=0;
    if(i_ptSeqBiTree[0].iData==0)// 空树
    {
    }
    else
    {
        for(i=0;i<MAX_SEQ_BINARY_TREE_LEN;i++)
        {
            if(i_ptSeqBiTree[i].iData==i_ptTreeElement->iData)// 找到
            {
                memcpy(&tSeqBiTreeElement,&i_ptSeqBiTree[2*i+1],sizeof(T_SeqBiTreeElement));
            }
            else
            {
            }
        }
    }
    return tSeqBiTreeElement;
}
/*****************************************************************************
-Fuction        : GetRightChildFromSeqBiTree
-Description    :
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/08      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static T_SeqBiTreeElement GetRightChildFromSeqBiTree(T_SeqBiTreeElement *i_ptSeqBiTree,T_SeqBiTreeElement *i_ptTreeElement)
{
    T_SeqBiTreeElement tSeqBiTreeElement={0};
    tSeqBiTreeElement.iData=0;
    int i=0;
    if(i_ptSeqBiTree[0].iData==0)// 空树
    {
    }
    else
    {
        for(i=0;i<MAX_SEQ_BINARY_TREE_LEN;i++)
        {
            if(i_ptSeqBiTree[i].iData==i_ptTreeElement->iData)// 找到
            {
                memcpy(&tSeqBiTreeElement,&i_ptSeqBiTree[2*i+2],sizeof(T_SeqBiTreeElement));
            }
            else
            {
            }
        }
    }
    return tSeqBiTreeElement;
}
/*****************************************************************************
-Fuction        : GetLeftSiblingFromSeqBiTree
-Description    :
// 操作结果：返回e的左兄弟。若e是T的左孩子或无左兄弟，则返回“空”
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/08      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static T_SeqBiTreeElement GetLeftSiblingFromSeqBiTree(T_SeqBiTreeElement *i_ptSeqBiTree,T_SeqBiTreeElement *i_ptTreeElement)
{
    T_SeqBiTreeElement tSeqBiTreeElement={0};
    tSeqBiTreeElement.iData=0;
    int i=0;
    if(i_ptSeqBiTree[0].iData==0)// 空树
    {
    }
    else
    {
        for(i=0;i<MAX_SEQ_BINARY_TREE_LEN;i++)
        {
            if((i_ptSeqBiTree[i].iData==i_ptTreeElement->iData)&&(i%2==0))
            {// 找到e且其序号为偶数(是右孩子)
                memcpy(&tSeqBiTreeElement,&i_ptSeqBiTree[i-1],sizeof(T_SeqBiTreeElement));
            }
            else
            {
            }
        }
    }
    return tSeqBiTreeElement;
}
/*****************************************************************************
-Fuction        : GetRightSiblingFromSeqBiTree
-Description    :
// 操作结果：返回e的右兄弟。若e是T的右孩子或无右兄弟，则返回“空”
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/08      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static T_SeqBiTreeElement GetRightSiblingFromSeqBiTree(T_SeqBiTreeElement *i_ptSeqBiTree,T_SeqBiTreeElement *i_ptTreeElement)
{
    T_SeqBiTreeElement tSeqBiTreeElement={0};
    tSeqBiTreeElement.iData=0;
    int i=0;
    if(i_ptSeqBiTree[0].iData==0)// 空树
    {
    }
    else
    {
        for(i=0;i<MAX_SEQ_BINARY_TREE_LEN;i++)
        {
            if((i_ptSeqBiTree[i].iData==i_ptTreeElement->iData)&&(i%2!=0))
            {// 找到e且其序号为奇数(是左孩子)
                memcpy(&tSeqBiTreeElement,&i_ptSeqBiTree[i+1],sizeof(T_SeqBiTreeElement));
            }
            else
            {
            }
        }
    }
    return tSeqBiTreeElement;
}
/*****************************************************************************
-Fuction        : MoveSeqBiTree
-Description    :
// 把从src的i_dwSrcPos结点开始的子树移为从dst的i_dwDstPos结点开始的子树
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/08      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void MoveSeqBiTree(T_SeqBiTreeElement *i_ptSrcSeqBiTree,int i_dwSrcPos,T_SeqBiTreeElement *i_ptDstSeqBiTree,int i_dwDstPos)
{
    if(i_ptSrcSeqBiTree[2*i_dwSrcPos+1].iData!=0)// 把q的j结点的左子树移为T的i结点的左子树
    {
        MoveSeqBiTree(i_ptSrcSeqBiTree,2*i_dwSrcPos+1,i_ptDstSeqBiTree,2*i_dwDstPos+1);
    }
    else
    {
    }
    if(i_ptSrcSeqBiTree[2*i_dwSrcPos+2].iData!=0)// 把q的j结点的右子树移为T的i结点的右子树
    {
        MoveSeqBiTree(i_ptSrcSeqBiTree,2*i_dwSrcPos+2,i_ptDstSeqBiTree,2*i_dwDstPos+2);
    }
    else
    {
    }
    memcpy(&i_ptDstSeqBiTree[i_dwDstPos],&i_ptSrcSeqBiTree[i_dwSrcPos],sizeof(T_SeqBiTreeElement));
    i_ptSrcSeqBiTree[i_dwSrcPos].iData=0;
}
/*****************************************************************************
-Fuction        : InsertChildInSeqBiTree
-Description    :
//操作结果:根据i_iLeftOrRight为0或1,插入i_ptInsertTree为i_ptSeqBiTree中
i_ptInsertNode结点的左或右子树。
i_ptInsertNode结点的原有左或右子树则成为i_ptInsertTree的右子树
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/08      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void InsertChildInSeqBiTree(T_SeqBiTreeElement *i_ptSeqBiTree,T_SeqBiTreeElement *i_ptInsertNode,int i_iLeftOrRight,T_SeqBiTreeElement *i_ptInsertTree)
{
    int i;
    int i_dwInsertChildPos=0;
    for(i=0;i<(int)(pow(2,GetSeqBiTreeDepth(i_ptSeqBiTree)))-1;i++)// 查找i_ptInsertNode的序号
    {
        if(0==memcmp(&i_ptSeqBiTree[i],i_ptInsertNode,sizeof(T_SeqBiTreeElement)))
        {
            break;
        }
        else
        {
        }
    }
    i_dwInsertChildPos=2*i+1+i_iLeftOrRight;//i_dwInsertChildPos为i_ptInsertNode的左或右孩子的序号
    if(i_ptSeqBiTree[i_dwInsertChildPos].iData!=0)
    {// 把从i_ptSeqBiTree的i_dwInsertChildPos结点开始的子树移为从i_dwInsertChildPos结点的右子树开始的子树
        MoveSeqBiTree(i_ptSeqBiTree,i_dwInsertChildPos,i_ptSeqBiTree,2*i_dwInsertChildPos+2);
        //结点开始的子树移动到结点孩子开始的子树,递归导致先执行最后结点移动到
        //目标的空节点上，此时原来元素已经保存，就可以继续移动结点，类似于
        //数组元素整体后移
    }
    else
    {
    }
    MoveSeqBiTree(i_ptInsertTree,0,i_ptSeqBiTree,i_dwInsertChildPos);// 把从i_ptInsertTree的开始的子树移为从i_ptSeqBiTree的i_dwInsertChildPos结点开始的子树
//由于前面的操作同时也导致了
//i_ptInsertNode结点的原有左或右子树则成为i_ptInsertTree的右子树
}
/*****************************************************************************
-Fuction        : DeleteChildInSeqBiTree
-Description    :
// 操作结果：根据LR为1或0，删除T中p所指结点的左或右子树
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/08      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int DeleteChildInSeqBiTree(T_SeqBiTreeElement *i_ptSeqBiTree,T_PositionInTree*i_ptDeleteNodePos,int i_iLeftOrRight)
{
    int iRet=0;
    int i;
    T_LinkQueue tLinkQueue={0};

    InitLinkQueue(&tLinkQueue);
    // 将层、本层序号转为矩阵的序号
    i=(int)pow(2,i_ptDeleteNodePos->iLevel-1)+i_ptDeleteNodePos->iOrder-2;// 将层、本层序号转为矩阵的序号
    if(i_ptSeqBiTree[i].iData==0)// 此结点空
    {
        iRet=-1;
        printf("DeleteNodeIsNull,err
");
    }
    else
    {
        i=2*i+1+i_iLeftOrRight;// 待删除子树的根结点在矩阵中的序号
        //printf("DeleteNodePos:%d
",i);
        while(iRet==0)
        {
            if(i_ptSeqBiTree[2*i+1].iData!=0)
            {
                EnterLinkQueue(&tLinkQueue,(char)(2*i+1));// 入队左结点的序号    
            }
            else{
            }
            if(i_ptSeqBiTree[2*i+2].iData!=0)
            {
                EnterLinkQueue(&tLinkQueue,(char)(2*i+2));    
            }
            else{
            }
            i_ptSeqBiTree[i].iData=0;
            iRet=ExitLinkQueue(&tLinkQueue,(char *)&i);// 队列不空
        }
        
    }
    return iRet;
}
/*****************************************************************************
-Fuction        : PreTraverseSeqBiTree
-Description    :
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/08      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void PreTraverseSeqBiTree(T_SeqBiTreeElement *i_ptSeqBiTree,int i_dwPos)
{
    printf("%d ",i_ptSeqBiTree[i_dwPos].iData);
    if(i_ptSeqBiTree[i_dwPos*2+1].iData!=0)// 左子树不空
    {
        PreTraverseSeqBiTree(i_ptSeqBiTree,i_dwPos*2+1);
    }
    else{
    }
    if(i_ptSeqBiTree[i_dwPos*2+2].iData!=0)// 右子树不空
    {
        PreTraverseSeqBiTree(i_ptSeqBiTree,i_dwPos*2+2);
    }
    else{
    }
}
/*****************************************************************************
-Fuction        : PreOrderTraverseSeqBiTree
-Description    :
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/08      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void PreOrderTraverseSeqBiTree(T_SeqBiTreeElement *i_ptSeqBiTree)
{
    if(IsSeqBiTreeEmpty(i_ptSeqBiTree))
    {
        printf("SeqBiTreeEmpty PreOrderTraverseSeqBiTree err
");
    }
    else
    {
        PreTraverseSeqBiTree(i_ptSeqBiTree,0);
        printf("
");
    }
}
/*****************************************************************************
-Fuction        : InTraverseSeqBiTree
-Description    :
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/08      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void InTraverseSeqBiTree(T_SeqBiTreeElement *i_ptSeqBiTree,int i_dwPos)
{
    if(i_ptSeqBiTree[i_dwPos*2+1].iData!=0)// 左子树不空
    {
        InTraverseSeqBiTree(i_ptSeqBiTree,i_dwPos*2+1);
    }
    else{
    }
    printf("%d ",i_ptSeqBiTree[i_dwPos].iData);
    if(i_ptSeqBiTree[i_dwPos*2+2].iData!=0)// 右子树不空
    {
        InTraverseSeqBiTree(i_ptSeqBiTree,i_dwPos*2+2);
    }
    else{
    }
}
/*****************************************************************************
-Fuction        : InOrderTraverseSeqBiTree
-Description    :
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/08      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void InOrderTraverseSeqBiTree(T_SeqBiTreeElement *i_ptSeqBiTree)
{
    if(IsSeqBiTreeEmpty(i_ptSeqBiTree))
    {
        printf("SeqBiTreeEmpty InOrderTraverseSeqBiTree err
");
    }
    else
    {
        InTraverseSeqBiTree(i_ptSeqBiTree,0);
        printf("
");
    }
}
/*****************************************************************************
-Fuction        : PostTraverseSeqBiTree
-Description    :
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/08      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void PostTraverseSeqBiTree(T_SeqBiTreeElement *i_ptSeqBiTree,int i_dwPos)
{
    if(i_ptSeqBiTree[i_dwPos*2+1].iData!=0)// 左子树不空
    {
        PostTraverseSeqBiTree(i_ptSeqBiTree,i_dwPos*2+1);
    }
    else{
    }
    if(i_ptSeqBiTree[i_dwPos*2+2].iData!=0)// 右子树不空
    {
        PostTraverseSeqBiTree(i_ptSeqBiTree,i_dwPos*2+2);
    }
    else{
    }
    printf("%d ",i_ptSeqBiTree[i_dwPos].iData);
}
/*****************************************************************************
-Fuction        : PostOrderTraverseSeqBiTree
-Description    :
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/08      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void PostOrderTraverseSeqBiTree(T_SeqBiTreeElement *i_ptSeqBiTree)
{
    if(IsSeqBiTreeEmpty(i_ptSeqBiTree))
    {
        printf("SeqBiTreeEmpty PostOrderTraverseSeqBiTree err
");
    }
    else
    {
        PostTraverseSeqBiTree(i_ptSeqBiTree,0);
        printf("
");
    }
}
/*****************************************************************************
-Fuction        : LevelOrderTraverseSeqBiTree
-Description    :// 层序遍历二叉树
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/08      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void LevelOrderTraverseSeqBiTree(T_SeqBiTreeElement *i_ptSeqBiTree)
{
    int i,j;
    i=MAX_SEQ_BINARY_TREE_LEN-1;
    while(i_ptSeqBiTree[i].iData==0)
    {
        i--;// 找到最后一个非空结点的序号
    }
    for(j=0;j<=i;j++)// 从根结点起，按层序遍历二叉树
    {
        if(0==i_ptSeqBiTree[j].iData)
        {
        }
        else
        {
            printf("%d ",i_ptSeqBiTree[j].iData);// 只遍历非空的结点
        }
    }
    printf("
");
}
/*****************************************************************************
-Fuction        : PrintfSeqBiTree
-Description    :// 逐层、按本层序号输出二叉树
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/08      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void PrintfSeqBiTree(T_SeqBiTreeElement *i_ptSeqBiTree)
{
    int i,j;
    T_PositionInTree tPos={0};
    T_SeqBiTreeElement tSeqBiTreeElement={0};
    for(i=1;i<=GetSeqBiTreeDepth(i_ptSeqBiTree);i++)
    {
        printf("第%d层: ",i);
        for(j=1;j<=pow(2,i-1);j++)
        {
            tPos.iLevel=i;
            tPos.iOrder=j;
            tSeqBiTreeElement=GetSeqBiTreeElement(i_ptSeqBiTree,&tPos);
            if(0==tSeqBiTreeElement.iData)
            {
            }
            else
            {
                printf("%d:%d ",j,tSeqBiTreeElement.iData);
            }
        }
        printf("
");
    }
}

3)孩子兄弟法表示的树

/*****************************************************************************
* Copyright (C) 2017-2018 Hanson Yu  All rights reserved.
------------------------------------------------------------------------------
* File Module        :     ChildSiblingTree.c
* Description        :     ChildSiblingTree operation center
* Created            :     2017.05.23.
* Author            :     Yu Weifeng
* Function List         :     
* Last Modified     :     
* History            :     
******************************************************************************/
#include "stdio.h"
#include "malloc.h"
#include "stdlib.h"
#include "string.h"
#include "math.h"
#include "ChildSiblingTree.h"
#include "LinkQueue.c"

static void InitChildSiblingTree(T_ChildSiblingTreeNode **i_pptChildSiblingTree);
static void DestroyChildSiblingTree(T_ChildSiblingTreeNode *i_ptChildSiblingTree);
static int IsChildSiblingTreeEmpty(T_ChildSiblingTreeNode *i_ptChildSiblingTree);
static int GetChildSiblingTreeDepth(T_ChildSiblingTreeNode *i_ptChildSiblingTree);
static char GetChildSiblingTreeNodeData(T_ChildSiblingTreeNode *i_ptChildSiblingTreeNode);
static char GetChildSiblingTreeRootData(T_ChildSiblingTreeNode *i_ptChildSiblingTree);
static int AssignToChildSiblingTreeNode(T_ChildSiblingTreeNode *i_ptChildSiblingBiTree,char i_cCurData,char i_cNewData);

static char GetChildSiblingTreeParentData(T_ChildSiblingTreeNode *i_ptChildSiblingTree,char i_cCurData);
static char GetChildSiblingTreeLeftChildData(T_ChildSiblingTreeNode *i_ptChildSiblingTree,char i_cCurData);
static char GetChildSiblingTreeRightSiblingData(T_ChildSiblingTreeNode *i_ptChildSiblingTree,char i_cCurData);


static void CreateChildSiblingTree(T_ChildSiblingTreeNode **i_pptChildSiblingTree);
static T_ChildSiblingTreeNode  *GetChildSiblingTreeNodePoint(T_ChildSiblingTreeNode *i_ptChildSiblingTree,char i_cData);
static int InsertChildInChildSiblingTree(T_ChildSiblingTreeNode *i_ptChildSiblingTree,T_ChildSiblingTreeNode *i_ptInsertNode,int i,T_ChildSiblingTreeNode *i_ptInsertTree);
static int DeleteChildInChildSiblingTree(T_ChildSiblingTreeNode *i_ptChildSiblingTree,T_ChildSiblingTreeNode *i_ptDeleteNode,int i);
static void PreOrderTraverseChildSiblingTree(T_ChildSiblingTreeNode *i_ptChildSiblingTree);
static void PostOrderTraverseChildSiblingTree(T_ChildSiblingTreeNode *i_ptChildSiblingTree);
static void LevelOrderTraverseChildSiblingTree(T_ChildSiblingTreeNode *i_ptChildSiblingTree);


#define     ClearChildSiblingTree     DestroyChildSiblingTree     // 清空二叉树和销毁二叉树的操作一样
#define     NIL             ' '
/*****************************************************************************
-Fuction        : main
-Description    : main
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/25      V1.0.0         Yu Weifeng       Created
******************************************************************************/
int main(int argc,char **argv)
{
    T_ChildSiblingTreeNode *ptChildSiblingTree=NULL;    
    T_ChildSiblingTreeNode *ptChildSiblingTreeNoRightChildTree=NULL;
    T_ChildSiblingTreeNode *ptChildSiblingTreeNode=NULL;
    int i=0;
    char cData;
    char cOtherData;
    InitChildSiblingTree(&ptChildSiblingTree);
    printf("构造空树后,树空否? %d(1:是0:否) 树根为%c 树的深度为%d
",IsChildSiblingTreeEmpty(ptChildSiblingTree),
        GetChildSiblingTreeRootData(ptChildSiblingTree),GetChildSiblingTreeDepth(ptChildSiblingTree));
    CreateChildSiblingTree(&ptChildSiblingTree);
    printf("构造树T后,树空否? %d(1:是0:否) 树根为%c 树的深度为%d
",IsChildSiblingTreeEmpty(ptChildSiblingTree),
        GetChildSiblingTreeRootData(ptChildSiblingTree),GetChildSiblingTreeDepth(ptChildSiblingTree));
    printf("先根遍历树T:
");
    PreOrderTraverseChildSiblingTree(ptChildSiblingTree);
    

    printf("
请输入待修改的结点的值,新值: ");
    scanf("%c,%c%*c",&cData,&cOtherData);
    AssignToChildSiblingTreeNode(ptChildSiblingTree,cData,cOtherData);
    printf("后根遍历修改后的树T:
");
    PostOrderTraverseChildSiblingTree(ptChildSiblingTree);
    printf("
%c的双亲是%c,长子是%c,下一个兄弟是%c
",cOtherData,GetChildSiblingTreeParentData(ptChildSiblingTree,cOtherData),
        GetChildSiblingTreeLeftChildData(ptChildSiblingTree,cOtherData),GetChildSiblingTreeRightSiblingData(ptChildSiblingTree,cOtherData));


    printf("建立树p:
");
    InitChildSiblingTree(&ptChildSiblingTreeNoRightChildTree);
    CreateChildSiblingTree(&ptChildSiblingTreeNoRightChildTree);
    printf("层序遍历树p:
");
    LevelOrderTraverseChildSiblingTree(ptChildSiblingTreeNoRightChildTree);

    printf("
将树p插到树T中，请输入T中p的双亲结点,子树序号: ");
    scanf("%c,%d%*c",&cData,&i);
    ptChildSiblingTreeNode=GetChildSiblingTreeNodePoint(ptChildSiblingTree,cData);
    InsertChildInChildSiblingTree(ptChildSiblingTree,ptChildSiblingTreeNode,i,ptChildSiblingTreeNoRightChildTree);
    printf("层序遍历树T:
");
    LevelOrderTraverseChildSiblingTree(ptChildSiblingTree);

    printf("
删除树T中结点e的第i棵子树，请输入e,i: ");
    scanf("%c,%d",&cData,&i);
    ptChildSiblingTreeNode=GetChildSiblingTreeNodePoint(ptChildSiblingTree,cData);
    DeleteChildInChildSiblingTree(ptChildSiblingTree,ptChildSiblingTreeNode,i);
    printf("层序遍历树T:
");
    LevelOrderTraverseChildSiblingTree(ptChildSiblingTree);

    DestroyChildSiblingTree(ptChildSiblingTree);

    return 0;
}

/*****************************************************************************
-Fuction        : InitChildSiblingTree
-Description    : InitChildSiblingTree
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/25      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void InitChildSiblingTree(T_ChildSiblingTreeNode **i_pptChildSiblingTree)
{
    *i_pptChildSiblingTree=NULL;
}

/*****************************************************************************
-Fuction        : DestroyChildSiblingTree
-Description    : DestroyChildSiblingTree
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/25      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void DestroyChildSiblingTree(T_ChildSiblingTreeNode *i_ptChildSiblingTree)
{
    if(NULL==i_ptChildSiblingTree)
    {
    }
    else
    {
        if(NULL==i_ptChildSiblingTree->ptFirstChild)
        {
        }
        else
        {
            DestroyChildSiblingTree(i_ptChildSiblingTree->ptFirstChild);
        }
        if(NULL==i_ptChildSiblingTree->ptFirstSibling)
        {
        }
        else
        {
            DestroyChildSiblingTree(i_ptChildSiblingTree->ptFirstSibling);
        }
        free(i_ptChildSiblingTree);
        i_ptChildSiblingTree=NULL;
    }
}

/*****************************************************************************
-Fuction        : CreateChildSiblingTree
-Description    : CreateChildSiblingTree
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/25      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void CreateChildSiblingTree(T_ChildSiblingTreeNode **i_pptChildSiblingTree)
{
    T_ChildSiblingTreeNode *ptTreeNodeFirstChild=NULL;
    char acData[20]={0};
    int iStringLen=0;
    int i;
    T_LinkQueue tLinkQueue={0};
    T_QueueDataElement tEnterQueueData={0};
    T_QueueDataElement tExitQueueData={0};

    InitLinkQueue(&tLinkQueue);
    printf("请输入根结点(字符型,空格为空): ");
    scanf("%c%*c",&acData[0]);
    if(NIL==acData[0])
    {
        *i_pptChildSiblingTree=NULL;
    }
    else
    {
        *i_pptChildSiblingTree=(T_ChildSiblingTreeNode *)malloc(sizeof(T_ChildSiblingTreeNode));
        if(NULL==*i_pptChildSiblingTree)
        {
        }
        else
        {
            (*i_pptChildSiblingTree)->cData=acData[0];
            (*i_pptChildSiblingTree)->ptFirstChild=NULL;
            (*i_pptChildSiblingTree)->ptFirstSibling=NULL;
            tEnterQueueData.ptData=*i_pptChildSiblingTree;
            EnterLinkQueue(&tLinkQueue,tEnterQueueData);
            while(0!=IsLinkQueueEmpty(&tLinkQueue))
            {
                ExitLinkQueue(&tLinkQueue,&tExitQueueData);
                printf("请按长幼顺序输入结点%c的所有孩子,不超过20个:",tExitQueueData.ptData->cData);
                memset(acData,0,sizeof(acData));
                //fgets从stdin中读字符，直至读到换行符或文件结束
                fgets(acData,sizeof(acData),stdin);//sizeof(acData)为size
                //如果size大于一行的字符串长度，那么当读到换行符时,
                //acData包含换行符并且后面还会加上''
                //如果size小于等于一行的字符串的长度，那么读入size-1个字符
                //acData中不包含换行符并且最后一位保留用来放''
                iStringLen=strlen(acData)-1;//去掉换行符
                //如果是gets,把输入的一行信息存入acData中，然后将换行符置换成串结尾符''。
                //用户要保证缓冲区的长度大于或等于最大的行长
                if(iStringLen>0)// 有孩子
                {// 建立长子结点
                    tExitQueueData.ptData->ptFirstChild=(T_ChildSiblingTreeNode *)malloc(sizeof(T_ChildSiblingTreeNode));
                    if(NULL==tExitQueueData.ptData->ptFirstChild)
                    {
                    }
                    else
                    {
                        tEnterQueueData.ptData=tExitQueueData.ptData->ptFirstChild;
                        tEnterQueueData.ptData->cData=acData[0];
                        for(i=1;i<iStringLen;i++)
                        {// 建立下一个兄弟结点
                            tEnterQueueData.ptData->ptFirstSibling=(T_ChildSiblingTreeNode *)malloc(sizeof(T_ChildSiblingTreeNode));
                            if(NULL==tEnterQueueData.ptData->ptFirstSibling)
                            {
                            }
                            else
                            {
                                EnterLinkQueue(&tLinkQueue,tEnterQueueData);// 入队上一个结点
                                tEnterQueueData.ptData=tEnterQueueData.ptData->ptFirstSibling;
                                tEnterQueueData.ptData->cData=acData[i];
                            }
                        }
                        tEnterQueueData.ptData->ptFirstSibling=NULL;
                        EnterLinkQueue(&tLinkQueue,tEnterQueueData);// 入队最后一个结点
                    }
                }
                else
                {
                    tExitQueueData.ptData->ptFirstChild=NULL;// 长子指针为空
                    //兄弟结点由上一个结点的孩子确定
                }
            }
        }
    }
}

/*****************************************************************************
-Fuction        : IsChildSiblingTreeEmpty
-Description    : IsChildSiblingTreeEmpty
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/25      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int IsChildSiblingTreeEmpty(T_ChildSiblingTreeNode *i_ptChildSiblingTree)
{
    int iRet=-1;
    if(NULL==i_ptChildSiblingTree)
    {
        iRet=0;
    }
    else
    {
        iRet=-1;
    }
    return iRet;
}

/*****************************************************************************
-Fuction        : GetChildSiblingTreeDepth
-Description    : GetChildSiblingTreeDepth
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/25      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int GetChildSiblingTreeDepth(T_ChildSiblingTreeNode *i_ptChildSiblingTree)
{
    int iDepth=0,iMaxDepth=0;
    T_ChildSiblingTreeNode *ptTreeNode=NULL;
    if(NULL==i_ptChildSiblingTree)
    {
        iMaxDepth=0;
    }
    else if(NULL==i_ptChildSiblingTree->ptFirstChild)
    {
        iMaxDepth=1;
    }
    else
    {
        for(ptTreeNode=i_ptChildSiblingTree->ptFirstChild;NULL!=ptTreeNode;ptTreeNode=ptTreeNode->ptFirstSibling)
        {
            iDepth=GetChildSiblingTreeDepth(ptTreeNode);
            if(iDepth>iMaxDepth)
            {
                iMaxDepth=iDepth;
            }
            else
            {
            }
        }
        iMaxDepth++;
    }
    return iMaxDepth;
}

/*****************************************************************************
-Fuction        : GetChildSiblingTreeNodeData
-Description    : GetChildSiblingTreeNodeData
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/25      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static char GetChildSiblingTreeNodeData(T_ChildSiblingTreeNode *i_ptChildSiblingTreeNode)
{
    return i_ptChildSiblingTreeNode->cData;
}

/*****************************************************************************
-Fuction        : GetChildSiblingTreeRootData
-Description    : GetChildSiblingTreeRootData
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/25      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static char GetChildSiblingTreeRootData(T_ChildSiblingTreeNode *i_ptChildSiblingTree)
{
    if(NULL==i_ptChildSiblingTree)
    {
        return NIL;
    }
    else
    {
        return GetChildSiblingTreeNodeData(i_ptChildSiblingTree);
    }
}

/*****************************************************************************
-Fuction        : GetChildSiblingTreeNodePoint
-Description    : GetChildSiblingTreeNodePoint
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/25      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static T_ChildSiblingTreeNode  *GetChildSiblingTreeNodePoint(T_ChildSiblingTreeNode *i_ptChildSiblingTree,char i_cData)
{
    T_LinkQueue tLinkQueue={0};
    T_ChildSiblingTreeNode *ptTreeNode=NULL;
    T_QueueDataElement tEnterQueueData={0};
    T_QueueDataElement tExitQueueData={0};

    if(NULL==i_ptChildSiblingTree)
    {
        ptTreeNode=NULL;
    }
    else
    {
        InitLinkQueue(&tLinkQueue);
        tEnterQueueData.ptData=i_ptChildSiblingTree;
        EnterLinkQueue(&tLinkQueue,tEnterQueueData);
        while(0!=IsLinkQueueEmpty(&tLinkQueue))
        {
            ExitLinkQueue(&tLinkQueue,&tExitQueueData);
            if(tExitQueueData.ptData->cData==i_cData)
            {
                ptTreeNode=tExitQueueData.ptData;
                break;
            }
            else
            {
                if(NULL==tExitQueueData.ptData->ptFirstChild)
                {
                }
                else
                {
                    tEnterQueueData.ptData=tExitQueueData.ptData->ptFirstChild;
                    EnterLinkQueue(&tLinkQueue,tEnterQueueData);
                }
                
                if(NULL==tExitQueueData.ptData->ptFirstSibling)
                {
                }
                else
                {
                    tEnterQueueData.ptData=tExitQueueData.ptData->ptFirstSibling;
                    EnterLinkQueue(&tLinkQueue,tEnterQueueData);
                }
            }
        }
    }
    return ptTreeNode;
}

/*****************************************************************************
-Fuction        : AssignToChildSiblingTreeNode
-Description    : AssignToChildSiblingTreeNode
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/25      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int AssignToChildSiblingTreeNode(T_ChildSiblingTreeNode *i_ptChildSiblingBiTree,char i_cCurData,char i_cNewData)
{
    int iRet=-1;
    T_ChildSiblingTreeNode *ptTreeNode=NULL;
    if(NULL==i_ptChildSiblingBiTree)
    {
        iRet=-1;
    }
    else
    {
        ptTreeNode=GetChildSiblingTreeNodePoint(i_ptChildSiblingBiTree,i_cCurData);
        if(NULL==ptTreeNode)
        {
            iRet=-1;
        }
        else
        {
            ptTreeNode->cData=i_cNewData;// 赋新值
            iRet=0;
        }
    }
    return iRet;
}

/*****************************************************************************
-Fuction        : GetChildSiblingTreeParentData
-Description    : GetChildSiblingTreeParentData
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/25      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static char GetChildSiblingTreeParentData(T_ChildSiblingTreeNode *i_ptChildSiblingTree,char i_cCurData)
{
    char cData=NIL;
    T_ChildSiblingTreeNode *ptParent=NULL;
    T_LinkQueue tLinkQueue={0};
    T_QueueDataElement tEnterQueueElement={0}; 
    T_QueueDataElement tExitQueueElement={0};
    if(NULL==i_ptChildSiblingTree)
    {
        cData=NIL;
    }
    else
    {
        if(i_ptChildSiblingTree->cData==i_cCurData)// 根结点值为i_cCurData
        {
            cData==NIL;
        }
        else
        {
            InitLinkQueue(&tLinkQueue);
            tEnterQueueElement.ptData=i_ptChildSiblingTree;
            EnterLinkQueue(&tLinkQueue,tEnterQueueElement);
            while(0!=IsLinkQueueEmpty(&tLinkQueue))
            {
                ExitLinkQueue(&tLinkQueue,&tExitQueueElement);
                if(NULL==tExitQueueElement.ptData->ptFirstChild)
                {
                    cData==NIL;
                }
                else
                {
                    if(i_cCurData==tExitQueueElement.ptData->ptFirstChild->cData)// 长子为i_cCurData
                    {
                        cData=tExitQueueElement.ptData->cData;// 返回双亲
                        break;
                    }
                    else
                    {
                        ptParent=tExitQueueElement.ptData;// 双亲指针赋给ptParent
                        tEnterQueueElement.ptData=tExitQueueElement.ptData->ptFirstChild;// tEnterQueueElement.ptData指向长子
                        EnterLinkQueue(&tLinkQueue,tEnterQueueElement);// 入队长子
                        while(NULL!=tEnterQueueElement.ptData->ptFirstSibling)//结点的孩子判断完了接着判断兄弟
                        {
                            tEnterQueueElement.ptData=tEnterQueueElement.ptData->ptFirstSibling;
                            if(GetChildSiblingTreeNodeData(tEnterQueueElement.ptData)==i_cCurData)//兄弟相等，即次子为对应要找的数据
                            {
                                cData=GetChildSiblingTreeNodeData(tExitQueueElement.ptData);//对应数据的双亲返回
                                break;
                            }
                            else//没找到,入队该兄弟结点
                            {
                                EnterLinkQueue(&tLinkQueue,tEnterQueueElement);
                            }
                        }            
                    }
                }
            }
        }
    }
    return cData;
}

/*****************************************************************************
-Fuction        : GetChildSiblingTreeLeftChildData
-Description    : GetChildSiblingTreeLeftChildData
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/25      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static char GetChildSiblingTreeLeftChildData(T_ChildSiblingTreeNode *i_ptChildSiblingTree,char i_cCurData)
{
    char cData=NIL;
    T_ChildSiblingTreeNode *ptTreeNode=NULL;
    ptTreeNode=GetChildSiblingTreeNodePoint(i_ptChildSiblingTree,i_cCurData);
    if(NULL!=ptTreeNode&&NULL!=ptTreeNode->ptFirstChild)// 找到结点 且结点 有长子
    {
        cData=ptTreeNode->ptFirstChild->cData;
    }
    else
    {
        cData=NIL;
    }
    return cData;
}

/*****************************************************************************
-Fuction        : GetChildSiblingTreeRightSiblingData
-Description    : GetChildSiblingTreeRightSiblingData
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/25      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static char GetChildSiblingTreeRightSiblingData(T_ChildSiblingTreeNode *i_ptChildSiblingTree,char i_cCurData)
{
    char cData=NIL;
    T_ChildSiblingTreeNode *ptTreeNode=NULL;
    ptTreeNode=GetChildSiblingTreeNodePoint(i_ptChildSiblingTree,i_cCurData);
    if(NULL!=ptTreeNode&&NULL!=ptTreeNode->ptFirstSibling)// 找到结点 且结点 有长子
    {
        cData=ptTreeNode->ptFirstSibling->cData;
    }
    else
    {
        cData=NIL;
    }
    return cData;
}

/*****************************************************************************
-Fuction        : InsertChildInChildSiblingTree
-Description    : 
// 初始条件：树i_ptChildSiblingTree存在，i_ptInsertNode指向i_ptChildSiblingTree中某个结点，
1≤i≤p所指结点的度+1，非空树i_ptInsertTree与i_ptChildSiblingTree不相交
// 操作结果：插入i_ptInsertTree为i_ptChildSiblingTree中i_ptInsertNode结点的第i棵子树

-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/25      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int InsertChildInChildSiblingTree(T_ChildSiblingTreeNode *i_ptChildSiblingTree,T_ChildSiblingTreeNode *i_ptInsertNode,int i,T_ChildSiblingTreeNode *i_ptInsertTree)
{
    int iRet=-1;
    int j=0;
    if(NULL==i_ptChildSiblingTree)
    {
        iRet=-1;
    }
    else// i_ptChildSiblingTree不空
    {
        if(1==i)// 插入i_ptInsertTree为i_ptInsertNode的长子
        {
            i_ptInsertTree->ptFirstSibling=i_ptInsertNode->ptFirstChild;//被覆盖的放在右子树
            i_ptInsertNode->ptFirstChild=i_ptInsertTree;
            iRet=0;
        }
        else// 找插入点
        {
            i_ptInsertNode=i_ptInsertNode->ptFirstChild;
            j=2;//到这里至少指向次子，第二个儿子，度为2
            while(NULL!=i_ptInsertNode&&j<i)//使用还需要i_ptInsertNode->ptFirstSibling表示次子
            {
                i_ptInsertNode=i_ptInsertNode->ptFirstSibling;//指向度为i-1的孩子
                j++;//使用还需要i_ptInsertNode->ptFirstSibling表示度为i的孩子
            }
            if(j==i)
            {
                i_ptInsertTree->ptFirstSibling=i_ptInsertNode->ptFirstSibling;
                i_ptInsertNode->ptFirstSibling=i_ptInsertTree;
                iRet=0;
            }
            else// 原有孩子数小于i-1
            {
                iRet=-1;
            }
        }
    }
    return iRet;
}

/*****************************************************************************
-Fuction        : DeleteChildInChildSiblingTree
-Description    : 
// 初始条件：树i_ptChildSiblingTree存在，i_ptDeleteNode指向i_ptChildSiblingTree中某个结点，
1≤i≤i_ptDeleteNode所指结点的度
// 操作结果：删除i_ptChildSiblingTree中i_ptDeleteNode所指结点的第i棵子树
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/25      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int DeleteChildInChildSiblingTree(T_ChildSiblingTreeNode *i_ptChildSiblingTree,T_ChildSiblingTreeNode *i_ptDeleteNode,int i)
{
    int iRet=-1;
    int j;
    T_ChildSiblingTreeNode *ptDeleteNode=NULL;
    if(NULL==i_ptChildSiblingTree)
    {
        iRet=-1;
    }
    else
    {
        if(1==i)// 删除长子
        {
            ptDeleteNode=i_ptDeleteNode->ptFirstChild;
            i_ptDeleteNode->ptFirstChild=ptDeleteNode->ptFirstSibling;// i_ptDeleteNode的原次子现是长子
            ptDeleteNode->ptFirstSibling=NULL;
            DestroyChildSiblingTree(ptDeleteNode);
            iRet=0;
        }
        else// 删除非长子
        {
            i_ptDeleteNode=i_ptDeleteNode->ptFirstChild;
            j=2;//到这里至少指向次子，第二个儿子，度为2
            while(NULL!=i_ptDeleteNode&&j<i)//使用还需要i_ptDeleteNode->ptFirstSibling表示次子
            {
                i_ptDeleteNode=i_ptDeleteNode->ptFirstSibling;//指向度为i-1的孩子
                j++;//使用还需要i_ptInsertNode->ptFirstSibling表示度为i的孩子
            }
            if(j==i)// 找到第i棵子树
            {
                ptDeleteNode=i_ptDeleteNode->ptFirstSibling;
                i_ptDeleteNode->ptFirstSibling=ptDeleteNode->ptFirstSibling;
                ptDeleteNode->ptFirstSibling=NULL;
                DestroyChildSiblingTree(ptDeleteNode);
                iRet=0;
            }
            else//原有孩子数小于i-1(j++导致，DestroyChildSiblingTree null也可以)
            {
                iRet=-1;
            }
        }
    }
    return iRet;
}

/*****************************************************************************
-Fuction        : PreOrderTraverseChildSiblingTree
-Description    : PreOrderTraverseChildSiblingTree
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/25      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void PreOrderTraverseChildSiblingTree(T_ChildSiblingTreeNode *i_ptChildSiblingTree)
{
    if(NULL==i_ptChildSiblingTree)
    {
    }
    else
    {
        printf("%c ",i_ptChildSiblingTree->cData);
        PreOrderTraverseChildSiblingTree(i_ptChildSiblingTree->ptFirstChild);
        PreOrderTraverseChildSiblingTree(i_ptChildSiblingTree->ptFirstSibling);
    }
}

/*****************************************************************************
-Fuction        : PostOrderTraverseChildSiblingTree
-Description    : 先把孩子遍历完最后再访问根
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/25      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void PostOrderTraverseChildSiblingTree(T_ChildSiblingTreeNode *i_ptChildSiblingTree)
{
    T_ChildSiblingTreeNode *ptTreeNode=NULL;
    if(NULL==i_ptChildSiblingTree)
    {
    }
    else
    {
        if(NULL==i_ptChildSiblingTree->ptFirstChild)
        {
        }
        else
        {
            PostOrderTraverseChildSiblingTree(i_ptChildSiblingTree->ptFirstChild);
            ptTreeNode=i_ptChildSiblingTree->ptFirstChild->ptFirstSibling;// 指向长子的下一个兄弟
            while(NULL!=ptTreeNode)
            {
                PostOrderTraverseChildSiblingTree(ptTreeNode);
                ptTreeNode=ptTreeNode->ptFirstSibling;
            }
        }//当退出循环时ptTreeNode为null
        printf("%c ",GetChildSiblingTreeNodeData(i_ptChildSiblingTree));//即这里不能使用ptTreeNode
    }
}

/*****************************************************************************
-Fuction        : LevelOrderTraverseChildSiblingTree
-Description    : 层序遍历孩子—兄弟二叉链表结构的树
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/05/25      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void LevelOrderTraverseChildSiblingTree(T_ChildSiblingTreeNode *i_ptChildSiblingTree)
{
    T_ChildSiblingTreeNode *ptTreeNode=NULL;
    T_LinkQueue tLinkQueue;
    T_QueueDataElement tEnterQueueElement;
    T_QueueDataElement tExitQueueElement;
    InitLinkQueue(&tLinkQueue);
    if(NULL==i_ptChildSiblingTree)
    {
    }
    else
    {
        tEnterQueueElement.ptData=i_ptChildSiblingTree;
        printf("%c ",tEnterQueueElement.ptData->cData);
        EnterLinkQueue(&tLinkQueue,tEnterQueueElement);
        while(0!=IsLinkQueueEmpty(&tLinkQueue))
        {
            ExitLinkQueue(&tLinkQueue,&tExitQueueElement);
            if(NULL==tExitQueueElement.ptData->ptFirstChild)
            {
            }
            else
            {
                tEnterQueueElement.ptData=tExitQueueElement.ptData->ptFirstChild;
                printf("%c ",tEnterQueueElement.ptData->cData);
                EnterLinkQueue(&tLinkQueue,tEnterQueueElement);// 入队长子结点的指针
                while(NULL!=tEnterQueueElement.ptData->ptFirstSibling)
                {
                    tEnterQueueElement.ptData=tEnterQueueElement.ptData->ptFirstSibling;
                    printf("%c ",tEnterQueueElement.ptData->cData);
                    EnterLinkQueue(&tLinkQueue,tEnterQueueElement);// 入队兄弟结点的指针
                }
            }
        }
    }
}

/*****************************************************************************
* Copyright (C) 2017-2018 Hanson Yu  All rights reserved.
------------------------------------------------------------------------------
* File Module        :     ChildSiblingTree.h
* Description        :     ChildSiblingTree operation center
* Created            :     2017.05.23.
* Author            :     Yu Weifeng
* Function List         :     
* Last Modified     :     
* History            :     
******************************************************************************/
#ifndef _CHILD_SIBLING_TREE_H
#define _CHILD_SIBLING_TREE_H


typedef struct ChildSiblingTreeNode
{
    char cData;
    struct ChildSiblingTreeNode *ptFirstChild;
    struct ChildSiblingTreeNode *ptFirstSibling;
}T_ChildSiblingTreeNode,*PT_ChildSiblingTreeNode;







#endif

5.图

1)邻接表表示的图

/*****************************************************************************
* Copyright (C) 2017-2018 Hanson Yu  All rights reserved.
------------------------------------------------------------------------------
* File Module        :     AdjacencyListGraph.c
* Description        :     AdjacencyListGraph operation center
* Created            :     2017.06.02.
* Author            :     Yu Weifeng
* Function List         :     
* Last Modified     :     
* History            :     
******************************************************************************/
#include"stdio.h"
#include"malloc.h"
#include"stdlib.h"
#include"string.h"
#include "LinkListClearOprNoHeadNode.c"


static int PutVertexNewData(T_AdjacencyListGraph *i_ptAdjacencyListGraph,T_VertexData *i_ptVertexData,T_VertexData *i_ptVertexNewData);

static void InitAdjacencyListGraph(T_AdjacencyListGraph *i_ptAdjacencyListGraph);
static void InsertVertex(T_AdjacencyListGraph *i_ptAdjacencyListGraph,T_VertexData *i_ptVertexData);
static int InsertArc(T_AdjacencyListGraph *i_ptAdjacencyListGraph,T_VertexData *i_ptVertexData,T_VertexData *i_ptAdjVertexData);
static int DeleteArc(T_AdjacencyListGraph *i_ptAdjacencyListGraph,T_VertexData *i_ptVertexData,T_VertexData *i_ptAdjVertexData);
static int DeleteVertex(T_AdjacencyListGraph *i_ptAdjacencyListGraph,T_VertexData *i_ptVertexData);

static void DisplayGraph(T_AdjacencyListGraph *i_ptAdjacencyListGraph);
static void DestroyGraph(T_AdjacencyListGraph *i_ptAdjacencyListGraph);
/*****************************************************************************
-Fuction        : main
-Description    : main
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/06/01      V1.0.0         Yu Weifeng       Created
******************************************************************************/
/*int main(int argc,char **argv)
{
    int i,j,k,n;
    T_AdjacencyListGraph tGraph;
    T_VertexData v1,v2;
    printf("请顺序选择有向图,有向网,无向图,无向网
");
    for(i=0;i<4;i++) // 验证4种情况
    {
        InitAdjacencyListGraph(&tGraph);
        DisplayGraph(&tGraph);
        printf("插入新顶点，请输入顶点的值: ");
        scanf("%s",v1.acData);
        InsertVertex(&tGraph,&v1);
        printf("插入与新顶点有关的弧或边，请输入弧或边数: ");
        scanf("%d",&n);
        for(k=0;k<n;k++)
        {
            printf("请输入另一顶点的值: ");
            scanf("%s",v2.acData);
            if(tGraph.iKind<=1) // 有向
            {
                printf("对于有向图或网，请输入另一顶点的方向(0:弧头1:弧尾): ");
                scanf("%d",&j);
                if(j)
                InsertArc(&tGraph,&v2,&v1);
                else
                InsertArc(&tGraph,&v1,&v2);
            }
            else // 无向
            {
                InsertArc(&tGraph,&v1,&v2);
            }
        }
        DisplayGraph(&tGraph);
        if(i==3)
        {
            printf("删除一条边或弧，请输入待删除边或弧的弧尾弧头：");
            scanf("%s%s",v1.acData,v2.acData);
            DeleteArc(&tGraph,&v1,&v2);
            printf("修改顶点的值，请输入原值新值: ");
            scanf("%s%s",v1.acData,v2.acData);
            PutVertexNewData(&tGraph,&v1,&v2);
        }
        printf("删除顶点及相关的弧或边，请输入顶点的值: ");
        scanf("%s",v1.acData);
        DeleteVertex(&tGraph,&v1);
        DisplayGraph(&tGraph);
        DestroyGraph(&tGraph);
    }
}*/

/*****************************************************************************
-Fuction        : LocateVertex
-Description    : 
// 操作结果：若G中存在顶点i_ptVertexData，则返回该顶点在图中位置
；否则返回-1
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/06/02      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int LocateVertex(T_AdjacencyListGraph *i_ptAdjacencyListGraph,T_VertexData *i_ptVertexData)
{
    int i;
    for(i=0;i<i_ptAdjacencyListGraph->iVexNum;i++)
    {
        if(0==strncmp(i_ptAdjacencyListGraph->atVertexList[i].tData.acData,i_ptVertexData->acData,MAX_NAME))
        {
            break;
        }
        else
        {
        }
    }
    if(i<i_ptAdjacencyListGraph->iVexNum)
    {
    }
    else
    {
        i=-1;
    }
    return i;
}

/*****************************************************************************
-Fuction        : InitAdjacencyListGraph
-Description    : 
// 采用邻接表存储结构，构造没有相关信息图或网G(用一个函数构造4种图)

-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/06/02      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void InitAdjacencyListGraph(T_AdjacencyListGraph *i_ptAdjacencyListGraph)
{
    int i,j,k,w; // w是权值
    T_VertexNode tVa,tVb; // 连接边或弧的2顶点
    T_LinkListElement tElement;
    printf("请输入图的类型(有向图:0,有向网:1,无向图:2,无向网:3): ");
    scanf("%d",&i_ptAdjacencyListGraph->iKind);
    printf("请输入图的顶点数,边数: ");
    scanf("%d,%d",&i_ptAdjacencyListGraph->iVexNum,&i_ptAdjacencyListGraph->iArcNum);
    printf("请输入%d个顶点的值(<%d个字符):
",i_ptAdjacencyListGraph->iVexNum,MAX_NAME);
    for(i=0;i<i_ptAdjacencyListGraph->iVexNum;++i) // 构造顶点向量
    {
        scanf("%s",i_ptAdjacencyListGraph->atVertexList[i].tData.acData);
        i_ptAdjacencyListGraph->atVertexList[i].ptFirstArcNode=NULL; // 初始化与该顶点有关的出弧链表
    }
    if(i_ptAdjacencyListGraph->iKind%2) // 网
    printf("请输入每条弧(边)的权值、弧尾和弧头(以空格作为间隔):
");
    else // 图
    printf("请输入每条弧(边)的弧尾和弧头(以空格作为间隔):
");
    for(k=0;k<i_ptAdjacencyListGraph->iArcNum;++k) // 构造相关弧链表
    {
        if(i_ptAdjacencyListGraph->iKind%2) // 网
        scanf("%d%s%s",&w,tVa.tData.acData,tVb.tData.acData);
        else // 图
        scanf("%s%s",tVa.tData.acData,tVb.tData.acData);
        i=LocateVertex(i_ptAdjacencyListGraph,&tVa.tData); // 弧尾
        j=LocateVertex(i_ptAdjacencyListGraph,&tVb.tData); // 弧头
        tElement.pcInfo=NULL; // 给待插表结点e赋值，图无权
        tElement.iAdjvex=j; // 弧头
        if(i_ptAdjacencyListGraph->iKind%2) // 网
        {
            tElement.pcInfo=(T_InfoType *)malloc(sizeof(T_InfoType)); // 动态生成存放权值的空间
            tElement.pcInfo->iWeight=w;
        }
        else{
        }
        InsertNodeToLinkList(&i_ptAdjacencyListGraph->atVertexList[i].ptFirstArcNode,1,&tElement); // 插在第i个元素(出弧)的表头
        if(i_ptAdjacencyListGraph->iKind>=2) // 无向图或网，产生第2个表结点，并插在第j个元素(入弧)的表头
        {//无向
            tElement.iAdjvex=i; // e.info不变，不必再赋值
            InsertNodeToLinkList(&i_ptAdjacencyListGraph->atVertexList[j].ptFirstArcNode,1,&tElement); // 插在第j个元素的表头
        }
        else
        {
        }
    }
}

/*****************************************************************************
-Fuction        : CreateAdjacencyListGraphFromFile
-Description    :
// 采用邻接表存储结构，由文件构造没有相关信息图或网G(用一个函数构造4种图)
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/06/02      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void CreateAdjacencyListGraphFromFile(T_AdjacencyListGraph *i_ptAdjacencyListGraph)
{
    int i,j,k,w; // w是权值
    T_VertexNode tVa,tVb; // 连接边或弧的2顶点
    T_LinkListElement tElement;
    char strFileName[30]={0};
    FILE *fileGraphList;
    printf("请输入数据文件名(f7-1.txt或f7-2.txt)：");
    scanf("%s",strFileName);
    printf("请输入图的类型(有向图:0,有向网:1,无向图:2,无向网:3): ");
    scanf("%d",&i_ptAdjacencyListGraph->iKind);
    fileGraphList=fopen(strFileName,"r"); // 以读的方式打开数据文件，并以fileGraphList表示
    fscanf(fileGraphList,"%d",&i_ptAdjacencyListGraph->iVexNum);
    fscanf(fileGraphList,"%d",&i_ptAdjacencyListGraph->iArcNum);
    
    for(i=0;i<i_ptAdjacencyListGraph->iVexNum;++i) // 构造顶点向量
    {
        fscanf(fileGraphList,"%s",i_ptAdjacencyListGraph->atVertexList[i].tData.acData);
        i_ptAdjacencyListGraph->atVertexList[i].ptFirstArcNode=NULL; // 初始化与该顶点有关的出弧链表
    }
    for(k=0;k<i_ptAdjacencyListGraph->iArcNum;++k) // 构造相关弧链表
    {
        if(i_ptAdjacencyListGraph->iKind%2) // 网
        fscanf(fileGraphList,"%d%s%s",&w,tVa.tData.acData,tVb.tData.acData);
        else // 图
        fscanf(fileGraphList,"%s%s",tVa.tData.acData,tVb.tData.acData);
        i=LocateVertex(i_ptAdjacencyListGraph,&tVa.tData); // 弧尾
        j=LocateVertex(i_ptAdjacencyListGraph,&tVb.tData); // 弧头
        tElement.pcInfo=NULL; // 给待插表结点e赋值，图无权
        tElement.iAdjvex=j; // 弧头
        if(i_ptAdjacencyListGraph->iKind%2) // 网
        {
            tElement.pcInfo=(T_InfoType *)malloc(sizeof(T_InfoType)); // 动态生成存放权值的空间
            tElement.pcInfo->iWeight=w;
        }
        else{
        }
        InsertNodeToLinkList(&i_ptAdjacencyListGraph->atVertexList[i].ptFirstArcNode,1,&tElement); // 插在第i个元素(出弧)的表头
        if(i_ptAdjacencyListGraph->iKind>=2) // 无向图或网，产生第2个表结点，并插在第j个元素(入弧)的表头
        {//无向
            tElement.iAdjvex=i; // e.info不变，不必再赋值
            InsertNodeToLinkList(&i_ptAdjacencyListGraph->atVertexList[j].ptFirstArcNode,1,&tElement); // 插在第j个元素的表头
        }
        else
        {
        }
    }
    fclose(fileGraphList); // 关闭数据文件
}


/*****************************************************************************
-Fuction        : DestroyGraph
-Description    : 
// 初始条件：图G存在。操作结果：销毁图G
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/06/02      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void DestroyGraph(T_AdjacencyListGraph *i_ptAdjacencyListGraph)
{
    int i;
    T_LinkListElement tElement;
    for(i=0;i<i_ptAdjacencyListGraph->iVexNum;i++)
    {
        if(i_ptAdjacencyListGraph->iKind%2) // 网
        {
            while(i_ptAdjacencyListGraph->atVertexList[i].ptFirstArcNode!=NULL)
            {
                DeleteNodeFromLinkList(&i_ptAdjacencyListGraph->atVertexList[i].ptFirstArcNode,1,&tElement); // 删除链表的第1个结点，并将值赋给e
                if(tElement.iAdjvex>i) // 每个顶点序号>i(保证访问一次即保证动态生成的权值空间只释放1次)
                free(tElement.pcInfo);
            }

        }
        else
        {
            DestroyLinkList(i_ptAdjacencyListGraph->atVertexList[i].ptFirstArcNode); // 销毁弧或边链表，在bo2-8.cpp中
        }
    }
    i_ptAdjacencyListGraph->iVexNum=0; // 顶点数为0
    i_ptAdjacencyListGraph->iArcNum=0; // 边或弧数为0
}


/*****************************************************************************
-Fuction        : GetVertexData
-Description    : 
// 初始条件：图G存在，v是G中某个顶点的序号。
操作结果：返回v的值
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/06/02      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int GetVertexData(T_AdjacencyListGraph *i_ptAdjacencyListGraph,int i_ptVertexNum,T_VertexData *o_ptVertexData)
{
    int iRet=-1;
    if(i_ptVertexNum<0||i_ptVertexNum>=i_ptAdjacencyListGraph->iVexNum)
    {
        iRet=-1;
        printf("GetVertexData err
");
    }
    else
    {
        memcpy(o_ptVertexData,&i_ptAdjacencyListGraph->atVertexList[i_ptVertexNum].tData,sizeof(T_VertexData));
        iRet=0;
    }

    return iRet;
}


/*****************************************************************************
-Fuction        : PutVertexNewData
-Description    : 
// 初始条件：图G存在，v是G中某个顶点。
操作结果：对v赋新值value
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/06/02      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int PutVertexNewData(T_AdjacencyListGraph *i_ptAdjacencyListGraph,T_VertexData *i_ptVertexData,T_VertexData *i_ptVertexNewData)
{
    int iRet=-1;
    int iPos=-1;
    iPos=LocateVertex(i_ptAdjacencyListGraph,i_ptVertexData);
    if(iPos>-1) // v是G的顶点
    {
        memcpy(&i_ptAdjacencyListGraph->atVertexList[iPos].tData,i_ptVertexNewData,sizeof(T_VertexData));
        iRet=0;
    }
    else
    {
        iRet=-1;
        printf("PutVertexNewData err
");
    }

    return iRet;
}



/*****************************************************************************
-Fuction        : GetFirstAdjacencyVertex
-Description    : 
// 初始条件：图G存在，v是G中某个顶点
// 操作结果：返回v的第一个邻接顶点的序号。若顶点在G中没有邻接顶点，则返回-1
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/06/02      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int GetFirstAdjacencyVertex(T_AdjacencyListGraph *i_ptAdjacencyListGraph,T_VertexData *i_ptVertexData)
{
    int iNum=-1;
    T_ArcNode*ptArcNode=NULL;
    iNum=LocateVertex(i_ptAdjacencyListGraph,i_ptVertexData);
    if(-1==iNum)
    {    
    }
    else
    {
        ptArcNode=i_ptAdjacencyListGraph->atVertexList[iNum].ptFirstArcNode;
        if(NULL==ptArcNode)
        {
            iNum=-1;
        }
        else
        {
            iNum=ptArcNode->tData.iAdjvex;
        }
    }
    return iNum;
}


/*****************************************************************************
-Fuction        : EqualVertex
-Description    : 
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/06/02      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int EqualVertex(T_LinkListElement *i_ptElement1,T_LinkListElement *i_ptElement2)
{
    int iRet=-1;
    if(i_ptElement1->iAdjvex!=i_ptElement2->iAdjvex)
    {
        iRet=-1;
    }
    else
    {
        iRet=0;
    }

    return iRet;
}



/*****************************************************************************
-Fuction        : GetNextAdjacencyVertex
-Description    : 
// 初始条件：图G存在，v(i_ptVertexData)是G中某个顶点，w(i_ptAdjVertexData)是v的邻接顶点
// 操作结果：返回v的(相对于w的)下一个邻接顶点的序号。若w是v的最后一个邻接点，则返回-1
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/06/02      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int GetNextAdjacencyVertex(T_AdjacencyListGraph *i_ptAdjacencyListGraph,T_VertexData *i_ptVertexData,T_VertexData *i_ptAdjVertexData)
{
    int iNum;
    int iAdjNextVertexNum=-1;
    T_LinkList *ptLinkListNode=NULL;
    T_LinkList *ptLinkListPreNode=NULL;
    T_LinkListElement tElement={0};
    iNum=LocateVertex(i_ptAdjacencyListGraph,i_ptVertexData);// iNum为顶点v在图G中的序号
    tElement.iAdjvex=LocateVertex(i_ptAdjacencyListGraph,i_ptAdjVertexData);// tElement.adjvex为顶点w在图G中的序号
    ptLinkListNode=GetLinkListNodePoint(i_ptAdjacencyListGraph->atVertexList[iNum].ptFirstArcNode,&tElement,EqualVertex,&ptLinkListPreNode);
    if(NULL==ptLinkListNode||NULL==ptLinkListNode->ptNext)// ptLinkListNode指向顶点v的链表中邻接顶点为w的结点
    {// 没找到w或w是最后一个邻接点
        iAdjNextVertexNum=-1;
    }
    else
    {// 返回v的(相对于w的)下一个邻接顶点的序号
        iAdjNextVertexNum=ptLinkListNode->ptNext->tData.iAdjvex;
    }
    return iAdjNextVertexNum;

}



/*****************************************************************************
-Fuction        : InsertVertex
-Description    : 
// 初始条件：图G存在，v和图中顶点有相同特征
// 操作结果：在图G中增添新顶点v(不增添与顶点相关的弧，留待InsertArc()去做)
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/06/02      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void InsertVertex(T_AdjacencyListGraph *i_ptAdjacencyListGraph,T_VertexData *i_ptVertexData)
{
    memcpy(&i_ptAdjacencyListGraph->atVertexList[i_ptAdjacencyListGraph->iVexNum].tData, i_ptVertexData,sizeof(T_VertexData));// 构造新顶点向量
    i_ptAdjacencyListGraph->atVertexList[i_ptAdjacencyListGraph->iVexNum].ptFirstArcNode=NULL;
    i_ptAdjacencyListGraph->iVexNum++;// 图G的顶点数加1

}

/*****************************************************************************
-Fuction        : DeleteVertex
-Description    : 
// 初始条件：图G存在，v是G中某个顶点。操作结果：删除G中顶点v及其相关的弧
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/06/02      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int DeleteVertex(T_AdjacencyListGraph *i_ptAdjacencyListGraph,T_VertexData *i_ptVertexData)
{
    int iRet=-1;
    int i,j,k;    
    T_LinkList *ptLinkListNode=NULL;
    T_LinkList *ptLinkListPreNode=NULL;
    T_LinkListElement tElement={0};
    j=LocateVertex(i_ptAdjacencyListGraph,i_ptVertexData);
    if(j<0)
    {
        iRet=-1;
        printf("CannotFindVertex:%dr
",j);
    }
    else
    {
        i=GetLinkListLength(i_ptAdjacencyListGraph->atVertexList[j].ptFirstArcNode);// 以v为出度的弧或边数
        i_ptAdjacencyListGraph->iArcNum-=i;// 边或弧数-i
        if(i_ptAdjacencyListGraph->iKind%2)//// 网
        {
            while(i_ptAdjacencyListGraph->atVertexList[j].ptFirstArcNode)// 对应的弧或边链表不空
            {
                DeleteNodeFromLinkList(&i_ptAdjacencyListGraph->atVertexList[j].ptFirstArcNode,1,&tElement);// 删除链表的第1个结点，并将值赋给e
                free(tElement.pcInfo);// 释放动态生成的权值空间
            }
        }
        else// 图
        {
            DestroyLinkList(i_ptAdjacencyListGraph->atVertexList[j].ptFirstArcNode);// 销毁弧或边链表
        }
        i_ptAdjacencyListGraph->iVexNum--;// 顶点数减1(j从0开始，所以前面减一)
        for(i=j;i<i_ptAdjacencyListGraph->iVexNum;i++)// 顶点v后面的顶点前移
        {
            i_ptAdjacencyListGraph->atVertexList[i]=i_ptAdjacencyListGraph->atVertexList[i+1];
        }
        for(i=0;i<i_ptAdjacencyListGraph->iVexNum;i++)
        {// 删除以v为入度的弧或边且必要时修改表结点的顶点位置值
            tElement.iAdjvex=j;
            ptLinkListNode=GetLinkListNodePoint(i_ptAdjacencyListGraph->atVertexList[i].ptFirstArcNode,&tElement,EqualVertex,&ptLinkListPreNode);
            if(NULL==ptLinkListNode)// 顶点i的邻接表上有v为入度的结点
            {
            }
            else// 顶点i的邻接表上有v为入度的结点
            {
                if(NULL==ptLinkListPreNode)// p指向首元结点
                {
                    i_ptAdjacencyListGraph->atVertexList[i].ptFirstArcNode=ptLinkListNode->ptNext;// 头指针指向下一结点
                }
                else// p1指向p所指结点的前驱
                {
                    ptLinkListPreNode->ptNext=ptLinkListNode->ptNext;// 从链表中删除p所指结点
                }
                if(i_ptAdjacencyListGraph->iKind<2)// 有向
                {
                    i_ptAdjacencyListGraph->iArcNum--;// 边或弧数-1
                    if(i_ptAdjacencyListGraph->iKind==1)// 有向网
                    {
                        free(ptLinkListNode->tData.pcInfo);// 释放动态生成的权值空间
                    }
                    else
                    {
                    }
                }
                else
                {
                }
                free(ptLinkListNode);    
            }
            for(k=j+1;k<=i_ptAdjacencyListGraph->iVexNum;k++)
            {// 对于adjvex域>j的结点，其序号-1(弧指针中指向顶点序号(数组下标)删除后要减一)
                tElement.iAdjvex=k;
                ptLinkListNode=GetLinkListNodePoint(i_ptAdjacencyListGraph->atVertexList[i].ptFirstArcNode,&tElement,EqualVertex,&ptLinkListPreNode);
                if(NULL==ptLinkListNode)
                {
                }
                else
                {
                    ptLinkListNode->tData.iAdjvex--;// 序号-1(因为前移)
                }
            }
        }
        iRet=0;
    }
    return iRet;
}


/*****************************************************************************
-Fuction        : InsertArc
-Description    : 
// 初始条件：图G存在，v(i_ptVertexData)和w(i_ptAdjVertexData)是G中两个顶点
// 操作结果：在G中增添弧<v,w>，若G是无向的，则还增添对称弧<w,v>
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/06/02      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int InsertArc(T_AdjacencyListGraph *i_ptAdjacencyListGraph,T_VertexData *i_ptVertexData,T_VertexData *i_ptAdjVertexData)
{
    int i,j;
    int iRet=-1;
    T_LinkListElement tElement={0};
    i=LocateVertex(i_ptAdjacencyListGraph,i_ptVertexData);// 弧尾或边的序号
    j=LocateVertex(i_ptAdjacencyListGraph,i_ptAdjVertexData);// 弧头或边的序号
    if(i<0||j<0)
    {
        iRet=-1;
    }
    else
    {
        i_ptAdjacencyListGraph->iArcNum++;
        tElement.iAdjvex=j;
        tElement.pcInfo=NULL;
        if(i_ptAdjacencyListGraph->iKind%2)//// 网
        {
            tElement.pcInfo=(T_InfoType *)malloc(sizeof(T_InfoType));
            printf("请输入弧(边)%s→%s的权值: ",i_ptVertexData->acData,i_ptAdjVertexData->acData);
            scanf("%d",&tElement.pcInfo->iWeight);
        }
        else
        {
        }
        InsertNodeToLinkList(&i_ptAdjacencyListGraph->atVertexList[i].ptFirstArcNode,1,&tElement);// 将tElement插在弧尾的表头
        if(i_ptAdjacencyListGraph->iKind>=2) // 无向，生成另一个表结点
        {
            tElement.iAdjvex=i; // e.info不变
            InsertNodeToLinkList(&i_ptAdjacencyListGraph->atVertexList[j].ptFirstArcNode,1,&tElement);// 将e插在弧头的表头
        }
        else
        {
        }
        iRet=0;
    }
    return iRet;
}


/*****************************************************************************
-Fuction        : DeleteArc
-Description    : 
// 初始条件：图G存在，v和w是G中两个顶点
// 操作结果：在G中删除弧<v,w>，若G是无向的，则还删除对称弧<w,v>
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/06/02      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int DeleteArc(T_AdjacencyListGraph *i_ptAdjacencyListGraph,T_VertexData *i_ptVertexData,T_VertexData *i_ptAdjVertexData)
{
    int i,j;
    int iRet=-1;
    T_LinkListElement tElement={0};
    i=LocateVertex(i_ptAdjacencyListGraph,i_ptVertexData);// i是顶点v(弧尾)的序号
    j=LocateVertex(i_ptAdjacencyListGraph,i_ptAdjVertexData);// j是顶点w(弧头)的序号
    if(i<0||j<0)// 没找到待删除的弧
    {
        iRet=-1;
    }
    else
    {
        tElement.iAdjvex=j;
        iRet=DeleteElementFromLinkList(i_ptAdjacencyListGraph->atVertexList[i].ptFirstArcNode,&tElement,EqualVertex);
        if(0!=iRet)
        {
        }
        else// 删除成功
        {
            i_ptAdjacencyListGraph->iArcNum--;// 弧或边数减1
            if(i_ptAdjacencyListGraph->iKind%2)//// 网
            {
                free(tElement.pcInfo);
            }
            else{
            }
            if(i_ptAdjacencyListGraph->iKind>=2) // 无向，删除对称弧<w,v>
            {
                tElement.iAdjvex=i;
                iRet=DeleteElementFromLinkList(i_ptAdjacencyListGraph->atVertexList[j].ptFirstArcNode,&tElement,EqualVertex);
            }
            else
            {
            }
        }
    }
    return iRet;
}


/*****************************************************************************
-Fuction        : DisplayGraph
-Description    : 
// 输出图的邻接矩阵G
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/06/02      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void DisplayGraph(T_AdjacencyListGraph *i_ptAdjacencyListGraph)
{
    int i;
    T_ArcNode *ptAcrNode=NULL;
    switch(i_ptAdjacencyListGraph->iKind)
    {
        case DG: 
            printf("有向图
");
        break;
        case DN: 
            printf("有向网
");
        break;
        case UDG: 
            printf("无向图
");
        break;
        case UDN: 
            printf("无向网
");
    }
    printf("%d个顶点：
",i_ptAdjacencyListGraph->iVexNum);
    for(i=0;i<i_ptAdjacencyListGraph->iVexNum;++i)
    printf("%s ",i_ptAdjacencyListGraph->atVertexList[i].tData.acData);
    printf("
%d条弧(边):
",i_ptAdjacencyListGraph->iArcNum);
    for(i=0;i<i_ptAdjacencyListGraph->iVexNum;i++)
    {
        ptAcrNode=i_ptAdjacencyListGraph->atVertexList[i].ptFirstArcNode;
        while(NULL!=ptAcrNode)
        {
            if(i_ptAdjacencyListGraph->iKind<=1||i<ptAcrNode->tData.iAdjvex) // 有向或无向两次中的一次
            {
                printf("%s-->%s ",i_ptAdjacencyListGraph->atVertexList[i].tData.acData,i_ptAdjacencyListGraph->atVertexList[ptAcrNode->tData.iAdjvex].tData.acData);
                if(i_ptAdjacencyListGraph->iKind%2) // 网
                printf(":%d ",ptAcrNode->tData.pcInfo->iWeight);
            }
            ptAcrNode=ptAcrNode->ptNext;
        }
        printf("
");
    }
}

/*****************************************************************************
* Copyright (C) 2017-2018 Hanson Yu  All rights reserved.
------------------------------------------------------------------------------
* File Module        :     AdjacencyListGraph.h
* Description        :     AdjacencyListGraph operation center
* Created            :     2017.05.23.
* Author            :     Yu Weifeng
* Function List         :     
* Last Modified     :     
* History            :     
******************************************************************************/
#ifndef _ADJACENCY_LIST_GRAPH_H
#define _ADJACENCY_LIST_GRAPH_H

#define MAX_NAME                5
#define MAX_VERTEX_NUM        20
typedef struct InfoType
{
    int iWeight;//权值
}T_InfoType,*PT_InfoType;//最简单的弧的相关信息类型(只有权值)

typedef struct VertexData
{
    char acData[MAX_NAME];
}T_VertexData,*PT_VertexData;
enum GraphKind{DG,DN,UDG,UDN}; // {有向图,有向网,无向图,无向网}

typedef struct LinkListElement
{
    int iAdjvex;// 该弧所指向的顶点的位置,邻接表数组中的位置
    T_InfoType *pcInfo;// 网的权值指针
}T_LinkListElement,*PT_LinkListElement;

typedef struct ArcNode 
{
    T_LinkListElement tData;// 除指针以外的部分都属于T_ListElement
    struct ArcNode *ptNext;// 指向下一条弧的指针
}T_ArcNode,*PT_ArcNode;// 弧链表结点

typedef struct VertexNode
{
    T_VertexData tData;// 顶点信息
    T_ArcNode *ptFirstArcNode;// 第一个表结点的地址，指向第一条依附该顶点的弧的指针
}T_VertexNode,*PT_VertexNode;// 顶点结点

typedef struct AdjacencyListGraph
{
    T_VertexNode atVertexList[MAX_VERTEX_NUM];//邻接表包含所有顶点和弧的信息
    int iVexNum;// 图的当前顶点数和弧数
    int iArcNum;
    int iKind;// 图的种类标志
}T_AdjacencyListGraph,*PT_AdjacencyListGraph;




#endif

8
14
a
b
c
d
e
f
g
h
a b
a c
a e
a f
a g
a h
b d
b e
b h
c g
c h
d h
e f
f g

2)图的遍历

/*****************************************************************************
* Copyright (C) 2017-2018 Hanson Yu  All rights reserved.
------------------------------------------------------------------------------
* File Module        :     TraverseGraph.c
* Description        :     TraverseGraph operation center
* Created            :     2017.06.12.
* Author            :     Yu Weifeng
* Function List         :     
* Last Modified     :     
* History            :     
******************************************************************************/
#include"stdio.h"
#include"malloc.h"
#include"stdlib.h"
#include"string.h"
#include "LinkQueue.c"
#include "AdjacencyListGraph.c"

static void DFSTraverse(T_AdjacencyListGraph *i_ptAdjacencyListGraph);
static void BFSTraverse(T_AdjacencyListGraph *i_ptAdjacencyListGraph);

#define FALSE    0
#define TRUE         1

static char g_acVisitedFlag[MAX_VERTEX_NUM]={0};

/*****************************************************************************
-Fuction        : main
-Description    : main
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/06/12      V1.0.0         Yu Weifeng       Created
******************************************************************************/
int main(int argc,char **argv)
{
    T_AdjacencyListGraph tGraph;
    CreateAdjacencyListGraphFromFile(&tGraph); // 利用数据文件创建无向图
    DisplayGraph(&tGraph);// 输出无向图
    printf("深度优先搜索的结果:
");
    DFSTraverse(&tGraph);
    printf("广度优先搜索的结果:
");
    BFSTraverse(&tGraph);
    DestroyGraph(&tGraph); // 销毁图g

    return 0;
}

/*****************************************************************************
-Fuction        : DFS
-Description    : // 从第v(i_iPos)个顶点出发递归地深度优先遍历图
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/06/12      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void DFS(T_AdjacencyListGraph *i_ptAdjacencyListGraph,int i_iVertexPos)
{
    int iAdjacencyVertexPos=0;
    g_acVisitedFlag[i_iVertexPos]=TRUE;// 设置访问标志为TRUE(已访问)
    printf("%s ",i_ptAdjacencyListGraph->atVertexList[i_iVertexPos].tData.acData);// 访问第v个顶点
    for(iAdjacencyVertexPos=GetFirstAdjacencyVertex(i_ptAdjacencyListGraph,&i_ptAdjacencyListGraph->atVertexList[i_iVertexPos].tData);
          iAdjacencyVertexPos>=0;
          iAdjacencyVertexPos=GetNextAdjacencyVertex(i_ptAdjacencyListGraph,&i_ptAdjacencyListGraph->atVertexList[i_iVertexPos].tData,&i_ptAdjacencyListGraph->atVertexList[iAdjacencyVertexPos].tData))
    {
        if(TRUE==g_acVisitedFlag[iAdjacencyVertexPos])
        {
        }
        else
        {
            DFS(i_ptAdjacencyListGraph,iAdjacencyVertexPos);// 对v的尚未访问的邻接点w(iAdjacencyVertexPos)递归调用DFS
        }
    }
}

/*****************************************************************************
-Fuction        : DFSTraverse
-Description    : // 对图G作深度优先遍历。
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/06/12      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void DFSTraverse(T_AdjacencyListGraph *i_ptAdjacencyListGraph)
{
    int i;
    for(i=0;i<i_ptAdjacencyListGraph->iVexNum;i++)
    {
        g_acVisitedFlag[i]=FALSE;// 访问标志数组初始化
    }
    for(i=0;i<i_ptAdjacencyListGraph->iVexNum;i++)
    {
        if(TRUE==g_acVisitedFlag[i])
        {
        }
        else
        {
            DFS(i_ptAdjacencyListGraph,i);// 对尚未访问的顶点调用DFS
        }
    }
    printf("
");
}

/*****************************************************************************
-Fuction        : BFSTraverse
-Description    : //按广度优先非递归遍历图G。使用辅助队列Q和访问标志数组visited
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/06/12      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void BFSTraverse(T_AdjacencyListGraph *i_ptAdjacencyListGraph)
{
    int v,u,w;
    T_LinkQueue tLinkQueue={0};
    T_QueueDataElement tEnterElement={0};    
    T_QueueDataElement tExitElement={0};
    for(v=0;v<i_ptAdjacencyListGraph->iVexNum;v++)
    {
        g_acVisitedFlag[v]=FALSE;// 访问标志数组初始化
    }
    InitLinkQueue(&tLinkQueue);
    for(v=0;v<i_ptAdjacencyListGraph->iVexNum;v++)// 如果是连通图，只v=0就遍历全图
    {
        if(TRUE==g_acVisitedFlag[v])
        {
        }
        else// v尚未访问
        {
            g_acVisitedFlag[v]=TRUE;
            printf("%s ",i_ptAdjacencyListGraph->atVertexList[v].tData.acData);
            tEnterElement.iData=v;
            EnterLinkQueue(&tLinkQueue,tEnterElement);// v入队列
            while(0!=IsLinkQueueEmpty(&tLinkQueue))// 队列不空
            {
                ExitLinkQueue(&tLinkQueue,&tExitElement);// 出队用于访问其各个邻接点    
                u=tExitElement.iData;
                for(w=GetFirstAdjacencyVertex(i_ptAdjacencyListGraph,&i_ptAdjacencyListGraph->atVertexList[u].tData);
                      w>=0;
                      w=GetNextAdjacencyVertex(i_ptAdjacencyListGraph,&i_ptAdjacencyListGraph->atVertexList[u].tData,&i_ptAdjacencyListGraph->atVertexList[w].tData))
                {
                      if(TRUE==g_acVisitedFlag[w])
                      {
                      }
                      else// w为u的尚未访问的邻接顶点
                      {
                          g_acVisitedFlag[w]=TRUE;
                          printf("%s ",i_ptAdjacencyListGraph->atVertexList[w].tData.acData);
                          tEnterElement.iData=w;
                          EnterLinkQueue(&tLinkQueue,tEnterElement);// w入队,当本层邻接点访问完后，由此可按顺序访问下一层邻接点
                      }          
                }
            }
        }
    }
    printf("
");
}

二、算法

1.查找

1)顺序查找

/*****************************************************************************
* Copyright (C) 2017-2018 Hanson Yu  All rights reserved.
------------------------------------------------------------------------------
* File Module        :     SequenceSearch.c
* Description        :     SequenceSearch operation center
* Created            :     2017.06.14.
* Author            :     Yu Weifeng
* Function List         :     
* Last Modified     :     
* History            :     
******************************************************************************/
#include"stdio.h"
#include"malloc.h"
#include"stdlib.h"
#include"string.h"

#define ELEMENT_NUM    3

#define Key dwNumber    // 定义关键字为准考证号
typedef unsigned int KeyType;// 设关键字域为整型

typedef struct SeqTableElement
{
    unsigned int dwNumber;
    char strName[9]; // 姓名(4个汉字加1个串结束标志)
}T_SeqTableElement,*PT_SeqTableElement;


typedef struct SeqTable
{
    T_SeqTableElement *ptElement;
    int iLength;
}T_SeqTable,*PT_SeqTable;

static void CreateSeqTable(T_SeqTableElement i_atElement[],int i_iNum,T_SeqTable *o_ptSeqTable);
static int SequenceSearch(T_SeqTable *i_ptSeqTable,KeyType i_Key);
static void TraverseSeqTable(T_SeqTable *i_ptSeqTable);
static void DestroySeqTable(T_SeqTable *i_ptSeqTable);

/*****************************************************************************
-Fuction        : main
-Description    : main
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/06/14      V1.0.0         Yu Weifeng       Created
******************************************************************************/
int main(int argc,char **argv)
{
    int i;
    KeyType    KeyElement=0;
    T_SeqTableElement atElement[ELEMENT_NUM]={{123456,"LiMing"},{123467,"XiaoMing"},{123477,"LiHua"}};
    T_SeqTable tSeqTable={0};
    CreateSeqTable(atElement,ELEMENT_NUM,&tSeqTable);
    TraverseSeqTable(&tSeqTable);
    printf("请输入待查找人的考号: ");
    scanf("%d",&KeyElement);
    i=SequenceSearch(&tSeqTable,KeyElement); // 顺序查找
    if(i)
    printf("%8d%8s
",tSeqTable.ptElement[i].dwNumber,tSeqTable.ptElement[i].strName);
    else
    printf("没找到
");
    DestroySeqTable(&tSeqTable);

    return 0;
}



/*****************************************************************************
-Fuction        : CreateSeqTable
-Description    : 
// 操作结果：由含n个数据元素的数组r构造静态顺序查找表ST

-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/06/14      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void CreateSeqTable(T_SeqTableElement i_atElement[],int i_iNum,T_SeqTable *o_ptSeqTable)
{
    int i;
    //与malloc的区别,calloc在动态分配完内存后，自动初始化该内存空间为零，而malloc不初始化，里边数据是随机的垃圾数据。
    o_ptSeqTable->ptElement=(T_SeqTableElement *)calloc(i_iNum+1,sizeof(T_SeqTableElement));// 动态生成n+1个数据元素空间(0号单元不用)
    if(NULL==o_ptSeqTable->ptElement)
    {
        printf("CreareSeqTable err,calloc fail
");
    }
    else
    {
        for(i=1;i<=i_iNum;i++)
        {
            memcpy(&o_ptSeqTable->ptElement[i],&i_atElement[i-1],sizeof(T_SeqTableElement));
        }
        o_ptSeqTable->iLength=i_iNum;
    }
}

/*****************************************************************************
-Fuction        : SequenceSearch
-Description    : 
// 在顺序表ST中顺序查找其关键字等于key的数据元素。若找到，则返回
// 该元素在表中的位置；否则返回0。
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/06/14      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int SequenceSearch(T_SeqTable *i_ptSeqTable,KeyType i_Key)
{
    int i=0;
    i_ptSeqTable->ptElement[0].Key=i_Key;// 哨兵
    for(i=i_ptSeqTable->iLength;i_Key!=i_ptSeqTable->ptElement[i].Key;i--);// 从后往前找
    return i;// 找不到时，i为0
}

/*****************************************************************************
-Fuction        : TraverseSeqTable
-Description    : TraverseSeqTable
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/06/14      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void TraverseSeqTable(T_SeqTable *i_ptSeqTable)
{
    int i=0;
    for(i=1;i<=i_ptSeqTable->iLength;i++)
    {
        printf("%8d%8s
",i_ptSeqTable->ptElement[i].dwNumber,i_ptSeqTable->ptElement[i].strName);
    }
}

/*****************************************************************************
-Fuction        : DestroySeqTable
-Description    : DestroySeqTable
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/06/14      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void DestroySeqTable(T_SeqTable *i_ptSeqTable)
{
    free(i_ptSeqTable->ptElement);
    i_ptSeqTable->ptElement=NULL;
    i_ptSeqTable->iLength=0;
}

2)折半查找

/*****************************************************************************
* Copyright (C) 2017-2018 Hanson Yu  All rights reserved.
------------------------------------------------------------------------------
* File Module        :     BiSearch.c
* Description        :     BiSearch operation center
* Created            :     2017.06.14.
* Author            :     Yu Weifeng
* Function List         :     
* Last Modified     :     
* History            :     
******************************************************************************/
#include"stdio.h"
#include"malloc.h"
#include"stdlib.h"
#include"string.h"

#define ELEMENT_NUM    11

typedef  int KeyType;// 设关键字域为整型

typedef struct SeqTableElement
{
    KeyType key;    // 仅有关键字域
}T_SeqTableElement,*PT_SeqTableElement;

typedef struct SeqTable
{
    T_SeqTableElement *ptElement;
    int iLength;
}T_SeqTable,*PT_SeqTable;

static void CreateOrderSeqTable(T_SeqTableElement i_atElement[],int i_iNum,T_SeqTable *o_ptSeqTable);
static void TraverseOrderSeqTable(T_SeqTable *i_ptSeqTable);
static int BiSearch(T_SeqTable *i_ptSeqTable,KeyType i_Key);
static void DestroyOrderSeqTable(T_SeqTable *i_ptSeqTable);
/*****************************************************************************
-Fuction        : main
-Description    : main
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/06/14      V1.0.0         Yu Weifeng       Created
******************************************************************************/
int main(int argc,char **argv)
{
    int i;
    KeyType    KeyElement=0;
    T_SeqTableElement atElement[ELEMENT_NUM]={5,13,19,21,37,56,64,75,80,88,92};
    T_SeqTable tSeqTable={0};
    CreateOrderSeqTable(atElement,ELEMENT_NUM,&tSeqTable);
    TraverseOrderSeqTable(&tSeqTable);
    printf("请输入待查找值的关键字: ");
    scanf("%d",&KeyElement);
    i=BiSearch(&tSeqTable,KeyElement); // 折半查找有序表
    if(i)
    printf("%d 是第%d个记录的关键字
",tSeqTable.ptElement[i].key,i);
    else
    printf("没找到
");
    DestroyOrderSeqTable(&tSeqTable);

    return 0;
}



/*****************************************************************************
-Fuction        : CreateSeqTable
-Description    : 
// 操作结果：由含n个数据元素的数组r构造静态顺序查找表ST

-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/06/14      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void CreateOrderSeqTable(T_SeqTableElement i_atElement[],int i_iNum,T_SeqTable *o_ptSeqTable)
{
    int i;
    //与malloc的区别,calloc在动态分配完内存后，自动初始化该内存空间为零，而malloc不初始化，里边数据是随机的垃圾数据。
    o_ptSeqTable->ptElement=(T_SeqTableElement *)calloc(i_iNum+1,sizeof(T_SeqTableElement));// 动态生成n+1个数据元素空间(0号单元不用)
    if(NULL==o_ptSeqTable->ptElement)
    {
        printf("CreareSeqTable err,calloc fail
");
    }
    else
    {
        for(i=1;i<=i_iNum;i++)
        {//数组第1个位置即序号0的位置不存放,因为位置从1开始,同时方便查找返回值处理
            memcpy(&o_ptSeqTable->ptElement[i],&i_atElement[i-1],sizeof(T_SeqTableElement));
        }
        //memcpy(o_ptSeqTable->ptElement,i_atElement,sizeof(i_atElement));//传入的是地址这样拷贝不行
        o_ptSeqTable->iLength=i_iNum;
    }
}

/*****************************************************************************
-Fuction        : BiSearch
-Description    : 
// 在有序表ST中折半查找其关键字等于key的数据元素。若找到，则返回
// 该元素在表中的位置；否则返回0。
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/06/14      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int BiSearch(T_SeqTable *i_ptOrderSeqTable,KeyType i_Key)
{
    int iPos=0;
    int iLow,iHigh,iMid;
    iLow=1;
    iHigh=i_ptOrderSeqTable->iLength;
    while(iLow<=iHigh)
    {
        iMid=(iLow+iHigh)/2;
        if(i_Key==i_ptOrderSeqTable->ptElement[iMid].key)
        {
            iPos=iMid;
            break;
        }
        else if(i_Key<i_ptOrderSeqTable->ptElement[iMid].key)
        {
            iHigh=iMid-1;
        }
        else
        {
            iLow=iMid+1;
        }
    }
    return iPos;
}

/*****************************************************************************
-Fuction        : TraverseOrderSeqTable
-Description    : TraverseOrderSeqTable
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/06/14      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void TraverseOrderSeqTable(T_SeqTable *i_ptSeqTable)
{
    int i=0;
    for(i=1;i<=i_ptSeqTable->iLength;i++)
    {
        printf("%d ",i_ptSeqTable->ptElement[i].key);
    }
    printf("
");
}

/*****************************************************************************
-Fuction        : DestroyOrderSeqTable
-Description    : DestroyOrderSeqTable
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/06/14      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void DestroyOrderSeqTable(T_SeqTable *i_ptSeqTable)
{
    free(i_ptSeqTable->ptElement);
    i_ptSeqTable->ptElement=NULL;
    i_ptSeqTable->iLength=0;
}

3)哈希表的查找

2.排序

1)插入排序

I、直接插入排序

/*****************************************************************************
* Copyright (C) 2017-2018 Hanson Yu  All rights reserved.
------------------------------------------------------------------------------
* File Module        :     InsertSort.c
* Description        :     InsertSort operation center
* Created            :     2017.06.15.
* Author            :     Yu Weifeng
* Function List         :     
* Last Modified     :     
* History            :     
******************************************************************************/
#include"stdio.h"
#include"malloc.h"
#include"stdlib.h"
#include"string.h"


#define RECORD_SEQ_LIST_MAX_LEN        20
#define RECORD_NUMBER                8

typedef int KeyType;

typedef struct RecordType
{
    KeyType Key;
    int OtherInfo;
}T_RecordType,*PT_RecordType;

typedef struct RecordSeqList
{
    T_RecordType atRecord[RECORD_SEQ_LIST_MAX_LEN+1];// r[0]闲置或用作哨兵单元
    int iLength;
}T_RecordSeqList,*PT_RecordSeqList;

static void TraverseRecordSeqList(T_RecordSeqList *i_ptRecordSeqList);
static void InsertSort(T_RecordSeqList *i_ptRecordSeqList);

/*****************************************************************************
-Fuction        : main
-Description    : main
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/06/15      V1.0.0         Yu Weifeng       Created
******************************************************************************/
int main(int argc,char **argv)
{
    T_RecordType atRecord[RECORD_NUMBER]={{49,1},{38,2},{65,3},{97,4},{76,5},{13,6},{27,7},{49,8}};
    T_RecordSeqList tSeqList1, tSeqList2, tSeqList3;
    int i;
    for(i=0;i<RECORD_NUMBER;i++) // 给l1.r赋值
        tSeqList1.atRecord[i+1]=atRecord[i];
    tSeqList1.iLength=RECORD_NUMBER;
    tSeqList3=tSeqList2=tSeqList1; // 复制顺序表l2、l3与l1相同
    printf("排序前:
");
    TraverseRecordSeqList(&tSeqList1);
    InsertSort(&tSeqList1);
    printf("直接插入排序后:
");
    TraverseRecordSeqList(&tSeqList1);

    return 0;
}

/*****************************************************************************
-Fuction        : InsertSort
-Description    : // 对顺序表L作直接插入排序
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/06/15      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void InsertSort(T_RecordSeqList *i_ptRecordSeqList)
{
    int i,j;
    for(i=2;i<=i_ptRecordSeqList->iLength;i++)
    {
        if(i_ptRecordSeqList->atRecord[i].Key<i_ptRecordSeqList->atRecord[i-1].Key)// "<",需将L.r[i]插入有序子表
        {
            memcpy(&i_ptRecordSeqList->atRecord[0],&i_ptRecordSeqList->atRecord[i],sizeof(T_RecordType));// 复制为哨兵
            for(j=i-1;(i_ptRecordSeqList->atRecord[0].Key<i_ptRecordSeqList->atRecord[j].Key);j--)
            {// 记录后移
                memcpy(&i_ptRecordSeqList->atRecord[j+1],&i_ptRecordSeqList->atRecord[j],sizeof(T_RecordType));// 记录后移
            }
            memcpy(&i_ptRecordSeqList->atRecord[j+1],&i_ptRecordSeqList->atRecord[0],sizeof(T_RecordType));// 插入到正确位置
        }
        else
        {
        }
    }
}

/*****************************************************************************
-Fuction        : TraverseRecordSeqList
-Description    : TraverseRecordSeqList
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/06/15      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void TraverseRecordSeqList(T_RecordSeqList *i_ptRecordSeqList)
{
    int i;
    for(i=1;i<=i_ptRecordSeqList->iLength;i++)
    {
        printf("(%d,%d)",i_ptRecordSeqList->atRecord[i].Key,i_ptRecordSeqList->atRecord[i].OtherInfo);
    }
    printf("
");
}

II、折半插入排序

/*****************************************************************************
* Copyright (C) 2017-2018 Hanson Yu  All rights reserved.
------------------------------------------------------------------------------
* File Module        :     BiInsertSort.c
* Description        :     BiInsertSort operation center
* Created            :     2017.06.16.
* Author            :     Yu Weifeng
* Function List         :     
* Last Modified     :     
* History            :     
******************************************************************************/
#include"stdio.h"
#include"malloc.h"
#include"stdlib.h"
#include"string.h"




/*****************************************************************************
-Fuction        : main
-Description    : main
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/06/15      V1.0.0         Yu Weifeng       Created
******************************************************************************/
int main(int argc,char **argv)
{
    T_RecordType atRecord[RECORD_NUMBER]={{49,1},{38,2},{65,3},{97,4},{76,5},{13,6},{27,7},{49,8}};
    T_RecordSeqList tSeqList1, tSeqList2, tSeqList3;
    int i;
    for(i=0;i<RECORD_NUMBER;i++) // 给l1.r赋值
        tSeqList1.atRecord[i+1]=atRecord[i];
    tSeqList1.iLength=RECORD_NUMBER;
    tSeqList3=tSeqList2=tSeqList1; // 复制顺序表l2、l3与l1相同
    printf("排序前:
");
    TraverseRecordSeqList(&tSeqList1);
    MergeSort(&tSeqList1);
    printf("折半插入排序后:
");
    TraverseRecordSeqList(&tSeqList1);

    return 0;
}

III、希尔排序

2)交换排序

I、冒泡排序

/*****************************************************************************
* Copyright (C) 2017-2018 Hanson Yu  All rights reserved.
------------------------------------------------------------------------------
* File Module        :     BubbleSort.java
* Description        :     BubbleSort operation center
* Created            :     2017.06.16.
* Author            :     Yu Weifeng
* Function List         :     
* Last Modified     :     
* History            :     
******************************************************************************/




import java.util.Arrays; 


/*****************************************************************************
-Class            : BubbleSort
-Description    : main
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/06/19      V1.0.0         Yu Weifeng       Created
******************************************************************************/
public class BubbleSort
{
    public static final int ARRAY_LEN=9;
    BubbleSortClass pBuddleSort;
    /*****************************************************************************
    -Fuction        : main
    -Description    : main
    -Input            : 
    -Output         : 
    -Return         : 
    * Modify Date      Version         Author           Modification
    * -----------------------------------------------
    * 2017/06/19      V1.0.0         Yu Weifeng       Created
    ******************************************************************************/
    public static void main(String args[]){
        int aiSortBuf[] = {3,4,1,2,6,7,8,9,5};//constant Init must be in define
        BubbleSortClass mBuddleSort = new BubbleSortClass(aiSortBuf,ARRAY_LEN);
        System.out.println("oneCmpOneSort");
        mBuddleSort.oneCmpOneSort();
        mBuddleSort.printInfo();
        System.out.println("oneCmpAllSort");
        mBuddleSort.oneCmpAllSort();
        mBuddleSort.printInfo();
        System.out.println("apiSort");
        mBuddleSort.apiSort();
        mBuddleSort.printInfo();
    }
}

/*****************************************************************************
-Class            : BubbleSortClass
-Description    : oneCmpOneSort
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/06/19      V1.0.0         Yu Weifeng       Created
******************************************************************************/
 class BubbleSortClass
 {
     private int[] piSortBuf;
    private int iLen;
    /*****************************************************************************
    -Fuction        : BubbleSortClass
    -Description    : BubbleSortClass
    -Input            : 
    -Output         : 
    * Modify Date      Version         Author           Modification
    * -----------------------------------------------
    * 2017/06/19      V1.0.0         Yu Weifeng       Created
    ******************************************************************************/
    public BubbleSortClass(int[] i_piBuf,int i_iLen)
    {
        int i;
        //aiSortBuf=Arrays.copyOf(i_piBuf,i_iLen);// Or use this to copy
        piSortBuf=new int[i_iLen];
        for(i=0;i<i_iLen;i++){
            piSortBuf[i]=i_piBuf[i];
        }
        iLen=i_iLen;
    }
    /*****************************************************************************
    -Fuction        : oneCmpOneSort
    -Description    : oneCmpOneSort
    -Input            : 
    -Output         : 
    -Return         : 
    * Modify Date      Version         Author           Modification
    * -----------------------------------------------
    * 2017/06/19      V1.0.0         Yu Weifeng       Created
    ******************************************************************************/
    public void oneCmpOneSort()
    {
        int i,j;
        int iBufSwap;
        for(i=0;i<iLen-1;i++){//all trips
            for(j=0;j<iLen-i-1;j++){//cmp times a trip
                if(piSortBuf[j]>piSortBuf[j+1]){
                    iBufSwap=piSortBuf[j+1];
                    piSortBuf[j+1]=piSortBuf[j];
                    piSortBuf[j]=iBufSwap;
                }
                else{
                }
            }
        }
    }
    /*****************************************************************************
    -Fuction        : oneCmpAllSort
    -Description    : oneCmpAllSort
    -Input            : 
    -Output         : 
    * Modify Date      Version         Author           Modification
    * -----------------------------------------------
    * 2017/06/19      V1.0.0         Yu Weifeng       Created
    ******************************************************************************/
    public void oneCmpAllSort()
    {
        int i,j;
        int iBufSwap;
        for(i=0;i<iLen-1;i++){//all trips
            for(j=0;j<iLen-i-1;j++){//cmp times a trip
                if(piSortBuf[i]>piSortBuf[j+i+1]){
                    iBufSwap=piSortBuf[j+i+1];
                    piSortBuf[j+i+1]=piSortBuf[i];
                    piSortBuf[i]=iBufSwap;
                }
                else{
                }
            }
        }
    }
    /*****************************************************************************
    -Fuction        : oneCmpAllSort
    -Description    : oneCmpAllSort
    -Input            : 
    -Output         : 
    * Modify Date      Version         Author           Modification
    * -----------------------------------------------
    * 2017/06/19      V1.0.0         Yu Weifeng       Created
    ******************************************************************************/
    public void apiSort()
    {
        Arrays.sort(piSortBuf);
    }
    /*****************************************************************************
    -Fuction        : oneCmpAllSort
    -Description    : oneCmpAllSort
    -Input            : 
    -Output         : 
    * Modify Date      Version         Author           Modification
    * -----------------------------------------------
    * 2017/06/19      V1.0.0         Yu Weifeng       Created
    ******************************************************************************/
    public void printInfo()
    {
        int i;
        for(i=0;i<iLen;i++){
            System.out.println(piSortBuf[i]);
        }
        //System.out.println(Arrays.toString(aiSortBuf));//Or use this to print
    }
}
    

II、快速排序

3)选择排序

/*****************************************************************************
* Copyright (C) 2017-2018 Hanson Yu  All rights reserved.
------------------------------------------------------------------------------
* File Module        :     SelectSort.c
* Description        :     SelectSort operation center
* Created            :     2017.06.15.
* Author            :     Yu Weifeng
* Function List         :     
* Last Modified     :     
* History            :     
******************************************************************************/
#include"stdio.h"
#include"malloc.h"
#include"stdlib.h"
#include"string.h"


#define RECORD_SEQ_LIST_MAX_LEN        20
#define RECORD_NUMBER                8

typedef int KeyType;

typedef struct RecordType
{
    KeyType Key;
    int OtherInfo;
}T_RecordType,*PT_RecordType;

typedef struct RecordSeqList
{
    T_RecordType atRecord[RECORD_SEQ_LIST_MAX_LEN+1];// r[0]闲置或用作哨兵单元
    int iLength;
}T_RecordSeqList,*PT_RecordSeqList;

static int SelectMinKey(T_RecordSeqList *i_ptRecordSeqList,int i_iPos);

static void TraverseRecordSeqList(T_RecordSeqList *i_ptRecordSeqList);
static void SelectSort(T_RecordSeqList *i_ptRecordSeqList);


/*****************************************************************************
-Fuction        : main
-Description    : main
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/06/15      V1.0.0         Yu Weifeng       Created
******************************************************************************/
int main(int argc,char **argv)
{
    T_RecordType atRecord[RECORD_NUMBER]={{49,1},{38,2},{65,3},{97,4},{76,5},{13,6},{27,7},{49,8}};
    T_RecordSeqList tSeqList1, tSeqList2, tSeqList3;
    int i;
    for(i=0;i<RECORD_NUMBER;i++) // 给l1.r赋值
        tSeqList1.atRecord[i+1]=atRecord[i];
    tSeqList1.iLength=RECORD_NUMBER;
    tSeqList3=tSeqList2=tSeqList1; // 复制顺序表l2、l3与l1相同
    printf("排序前:
");
    TraverseRecordSeqList(&tSeqList1);
    SelectSort(&tSeqList1);
    printf("简单选择排序后:
");
    TraverseRecordSeqList(&tSeqList1);

    return 0;
}

/*****************************************************************************
-Fuction        : SelectSort
-Description    : // 对顺序表L作简单选择排序
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/06/15      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void SelectSort(T_RecordSeqList *i_ptRecordSeqList)
{
    int i,j;
    T_RecordType tRecord={0};
    for(i=1;i<i_ptRecordSeqList->iLength;i++)
    {// 选择第i小的记录，并交换到位(选择第i小的放第i位)
        j=SelectMinKey(i_ptRecordSeqList,i);// 在L.r[i..L.length]中选择key最小的记录
        if(i!=j)
        {// 与第i个记录交换
            tRecord=i_ptRecordSeqList->atRecord[i];
            i_ptRecordSeqList->atRecord[i]=i_ptRecordSeqList->atRecord[j];
            i_ptRecordSeqList->atRecord[j]=tRecord;
        }
        else
        {
        }
    }
}

/*****************************************************************************
-Fuction        : SelectMinKey
-Description    : // 返回在L.r[i..L.length]中key最小的记录的序号
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/06/15      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static int SelectMinKey(T_RecordSeqList *i_ptRecordSeqList,int i_iPos)
{
    int i,j;
    KeyType tMinKey={0};
    j=i_iPos;// 设第i_iPos个为最小
    tMinKey=i_ptRecordSeqList->atRecord[i_iPos].Key;
    for(i=i_iPos+1;i<=i_ptRecordSeqList->iLength;i++)
    {
        if(i_ptRecordSeqList->atRecord[i].Key<tMinKey)// 找到更小的
        {
            j=i;
            tMinKey=i_ptRecordSeqList->atRecord[i].Key;
        }
        else
        {
        }
    }
    return j;
}

/*****************************************************************************
-Fuction        : TraverseRecordSeqList
-Description    : TraverseRecordSeqList
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/06/15      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void TraverseRecordSeqList(T_RecordSeqList *i_ptRecordSeqList)
{
    int i;
    for(i=1;i<=i_ptRecordSeqList->iLength;i++)
    {
        printf("(%d,%d)",i_ptRecordSeqList->atRecord[i].Key,i_ptRecordSeqList->atRecord[i].OtherInfo);
    }
    printf("
");
}

4)归并排序

/*****************************************************************************
* Copyright (C) 2017-2018 Hanson Yu  All rights reserved.
------------------------------------------------------------------------------
* File Module        :     MergeSort.c
* Description        :     MergeSort operation center
* Created            :     2017.06.15.
* Author            :     Yu Weifeng
* Function List         :     
* Last Modified     :     
* History            :     
******************************************************************************/
#include"stdio.h"
#include"malloc.h"
#include"stdlib.h"
#include"string.h"



#define SEQ_LIST_RECORD_MAX_LEN        20
#define RECORD_NUMBER                8

typedef int KeyType;

typedef struct RecordType
{
    KeyType Key;
    int OtherInfo;
}T_RecordType,*PT_RecordType;

typedef struct RecordSeqList
{
    T_RecordType atRecord[SEQ_LIST_RECORD_MAX_LEN+1];// r[0]闲置或用作哨兵单元
    int iLength;
}T_RecordSeqList,*PT_RecordSeqList;
static void Merge(T_RecordType i_atSrcRecord[],T_RecordType o_atDstRecord[],int i_iLow,int i_iMid,int i_iHigh);
static void MSort(T_RecordType i_atSrcRecord[],T_RecordType o_atDstRecord[],int i_iLow, int i_iHigh);



static void MergeSort(T_RecordSeqList *i_ptRecordSeqList);
static void TraverseRecordSeqList(T_RecordSeqList *i_ptRecordSeqList);

/*****************************************************************************
-Fuction        : main
-Description    : main
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/06/15      V1.0.0         Yu Weifeng       Created
******************************************************************************/
int main(int argc,char **argv)
{
    T_RecordType atRecord[RECORD_NUMBER]={{49,1},{38,2},{65,3},{97,4},{76,5},{13,6},{27,7},{49,8}};
    T_RecordSeqList tSeqList1, tSeqList2, tSeqList3;
    int i;
    for(i=0;i<RECORD_NUMBER;i++) // 给l1.r赋值
        tSeqList1.atRecord[i+1]=atRecord[i];
    tSeqList1.iLength=RECORD_NUMBER;
    tSeqList3=tSeqList2=tSeqList1; // 复制顺序表l2、l3与l1相同
    printf("排序前:
");
    TraverseRecordSeqList(&tSeqList1);
    MergeSort(&tSeqList1);
    printf("归并排序后:
");
    TraverseRecordSeqList(&tSeqList1);

    return 0;
}

/*****************************************************************************
-Fuction        : MergeSort
-Description    : 对顺序表L作归并排序
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/06/15      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void MergeSort(T_RecordSeqList *i_ptRecordSeqList)
{
    MSort(i_ptRecordSeqList->atRecord,i_ptRecordSeqList->atRecord,1,i_ptRecordSeqList->iLength);//0不放元素所以传1(从1开始
}

/*****************************************************************************
-Fuction        : MSort
-Description    : // 将i_atSrcRecord[s(i_iLow)..t(i_iHigh)]归并排序为o_atDstRecord[s..t]。
整个序列分为左右两半且要都是有序的,然后再归并
左半部分又分为两半且要都是有序的,然后再归并
右半部分又分为两半且要都是有序的,然后再归并(分割的子问题有和父问题是一样的处理考虑用递归)
(递归中先前半部分(左边)变为有序,再后半部分(右边)变为有序)
直到左右两半都只有一个元素即有序了再向上归并,
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/06/15      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void MSort(T_RecordType i_atSrcRecord[],T_RecordType o_atDstRecord[],int i_iLow, int i_iHigh)
{
    int iMid;
    T_RecordType atRecord[SEQ_LIST_RECORD_MAX_LEN+1]={0};
    if(i_iLow==i_iHigh)
    {
        o_atDstRecord[i_iLow]=i_atSrcRecord[i_iLow];
    }
    else//atRecord通过递归左右两边各自变为有序部分并不断增大
    {//最后归并左右两半部分为有序(递归中先前半部分(左边)变为有序,再后半部分(右边)变为有序)
        iMid=(i_iLow+i_iHigh)/2; // 将i_atSrcRecord[s..t]平分为i_atSrcRecord[s..m]和i_atSrcRecord[m+1..t]
        MSort(i_atSrcRecord,atRecord,i_iLow,iMid); // 递归地将i_atSrcRecord[s..m]归并为有序的atRecord[s..m]
        MSort(i_atSrcRecord,atRecord,iMid+1,i_iHigh); // 递归地将i_atSrcRecord[m+1..t]归并为有序的atRecord[m+1..t]
        Merge(atRecord,o_atDstRecord,i_iLow,iMid,i_iHigh); // 将atRecord[s..m]和atRecord[m+1..t]归并到o_atDstRecord[s..t]
    }
}

/*****************************************************************************
-Fuction        : Merge
-Description    : 
// 将有序的i_atSrcRecord[i_iLow..i_iMid]和i_atSrcRecord[i_iMid+1..i_iHigh]归并为有序的TR[i..n]
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/06/15      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void Merge(T_RecordType i_atSrcRecord[],T_RecordType o_atDstRecord[],int i_iLow,int i_iMid,int i_iHigh)
{
    int iRight;
    int i,j;
    for(iRight=i_iMid+1,i=i_iLow;i_iLow<=i_iMid&&iRight<=i_iHigh;++i) // 将SR中记录由小到大地并入TR
    {
        if (i_atSrcRecord[i_iLow].Key<i_atSrcRecord[iRight].Key)//两边取小的部分保存到o_atDstRecord
        {
            o_atDstRecord[i]=i_atSrcRecord[i_iLow++];//左边更小保存起来，同时左边的指针i_iLow后移进行再次比较
        }
        else
        {
            o_atDstRecord[i]=i_atSrcRecord[iRight++];;//右边更小保存起来，同时右边的指针i后移进行再次比较
        }
    }
    
    if(i_iLow<=i_iMid)//左边还有剩的，即剩的部分都比右边的大
    {
        for(j=0;j<=i_iMid-i_iLow;j++)
        {
            o_atDstRecord[i+j]=i_atSrcRecord[i_iLow+j]; // 将剩余的i_atSrcRecord[i_iLow..i_iMid]复制到o_atDstRecord
        }
    }
    if(iRight<=i_iHigh)//右边还有剩的，即剩的部分都比左边的大
    {
        for(j=0;j<=i_iHigh-iRight;j++)
        {
            o_atDstRecord[i+j]=i_atSrcRecord[iRight+j]; // 将剩余的i_atSrcRecord[iRight..i_iHigh]复制到o_atDstRecord
        }
    }
}

/*****************************************************************************
-Fuction        : TraverseRecordSeqList
-Description    : TraverseRecordSeqList
-Input            : 
-Output         : 
-Return         : 
* Modify Date      Version         Author           Modification
* -----------------------------------------------
* 2017/06/15      V1.0.0         Yu Weifeng       Created
******************************************************************************/
static void TraverseRecordSeqList(T_RecordSeqList *i_ptRecordSeqList)
{
    int i;
    for(i=1;i<=i_ptRecordSeqList->iLength;i++)
    {
        printf("(%d,%d)",i_ptRecordSeqList->atRecord[i].Key,i_ptRecordSeqList->atRecord[i].OtherInfo);
    }
    printf("
");
}

5)基数排序

详细源码可访问：https://github.com/fengweiyu/DataStructAndAlgorithm
或git clone https://github.com/fengweiyu/DataStructAndAlgorithm.git