线性表的定义与操作---链式表

/*线性表的定义与操作---链式表*/

/*定义状态标记*/
#define OK 1
#define ERROR 0
typedef int Status;/*定义程序返回状态值*/
typedef int ElemType;/*定义元素类型*/

/*定义一个表结点*/
typedef struct LNODE{

    ElemType Data; /*数据域*/
    struct LNODE *Next; /*指针域*/
}Node,*List;


/* 初始化顺序线性表 */
/*创建一个带有头结点的空链表*/
Status InitList(List *L)
{
    *L = (List)malloc(sizeof(Node)); /* 产生头结点,并使L指向此头结点 */
    if(!(*L)) /* 存储分配失败 */
    {
        return ERROR;
    }
    (*L)->next=NULL; /* 指针域为空 */

    return OK;
}


/*求表长 */
int ListLength(List L){

    int j = 0;
    List Ptr = L->Next;/*Ptr指向表的第一个数据结点*/
    while(Ptr){

        Ptr = Ptr->Next;
        ++j;
    }
    return j;
}

/*查找：
1.按序号查找  用e返回L中第i个数据元素的值 */
Status GetElem(ElemType *e,List L,int i){

    int j=1;/*j为计数器*/
    List p = L;/*定义一个p指向链表头结点*/
    p = p->Next; /*p指向链表第一个数据结点 */
    while(p!=NULL && j<i){/*循环*/

        p = p->Next;
        j++;
    }
    if(!p || j>i)/*第i个结点不存在*/
        return ERROR;
    *e = p->Data;/*取第i个结点中数据*/
    return OK;
}

/*查找：
2.按数据元素查找,并返回该结点*/
List GetElem(ElemType e,List L){

    List p = L;
    p = p->Next;/*p指向链表的第一个数据结点*/
    while(p!=NULL && p->Data!=e)
        p = p->Next;
    if(p == NULL)
        return ERROR;
    else
        return p;
}


/*单链表第i个数据插入结点的算法思路：
*1.声明一结点p指向链表第一个结点，初始化j从1开始；
*2.当j < i时，就遍历链表，让p的指针向后移动，不断指向下一结点，j累加1;
*3.若到链表末尾p为空，则说明第i个元素不存在；
*4.否则査找成功，在系统中生成一个空结点s;
*5.将数据元素e賦值给s->data;
*6.单链表的插入标准语句s->next=p->next;   p->next=s;
*7.返回成功。
*/
/*带头结点的插入：
*初始条件：L已经存在，且1=<i=<ListLength(L)
*操作结果：在L中第i个结点位置之前插入新的数据元素e,L的长度加1,并返回插入后的链表*/
Status ListInsert(ElemType e,int i,List *L){

    List p,q;
    int j = 1;
    p = *L;/*指向链表的头结点*/
    if(i == 1){/*新结点插入在表头*/

        q = (List)malloc(sizeof(Node));
        q->Data = e;  /*申请填装新结点*/
        q->Next = p->Next;
        p->Next = q;/*在第一个数据结点前插入新结点*/
        (*L) = p;/*将新链表p返回给L*/
        return OK;
    }
    else{/*新结点不插入在表头*/

        p = (*L)->Next;/*p指向第一个数据结点*/
        while(p!=NULL && j<i-1){/*查找第i-1个结点*/
            p = p->Next;
            ++j;
        }
        if(p==NULL || j>i-1)/*第i-1个结点不存在，不能插入*/
            return ERROR;
        q = (List)malloc(sizeof(Node));
        q->Data = e; /*申请填装新结点*/
        q->Next = p->Next;
        p->Next = q;/*新结点插入在第i-1个结点的后面*/
        return OK;
    }
}

/*带头结点的删除：
删除L中的第i个结点，并用e返回其值，L的长度减1*/
/**********************************
*单链表删除第i个数据结点的算法思路：

*声明一结点p指向链表第一个结点，初始化j从1开始;
*当j < i时，就遍历链表，让p的指针向后移动，不断指向下一个结点，j累加 1；
*若到链表末尾p为空，则说明第i个元素不存在；
*否则査找成功，将欲删除的结点p->next賦值给q;
*单链表的删除标准语句p->next=q->next;
*将q结点中的数据赋值给e,作为返回；
*释放q结点；
*返回成功。
**********************************/
Status ListDelete(List *L,int i){

    List p,q;
    int j = 1;
    if(i == 1)/*若要删除的是表的第一个数据结点 */
    {
        p = *L;
        q = p->Next;/*q指向表L的第一个数据结点*/
        p->Next = q->Next;
        free(q);
        return OK;
    }
    else{
        p = (*L)->Next;/*p指向第一个数据结点*/
        while(p!=NULL && j<i-1){ /*查找第i-1个结点*/

            p = p->Next;
            ++j;
        }
        if(p == NULL || j>i-1)/*判断第i-1个结点是否存在*/
            return ERROR;
        q = p->Next;/*q指向第i个结点*/
        if(q == NULL) /*判断第i个结点是否存在*/
            return ERROR;
        p->Next = q->Next;/*从链表中删除 */
        free(q);/*释放被删除的结点*/
        return OK;
    }
}