线性表 | 数组实现 & 链表实现 | C语言

一、数组实现

（1）初始化（建立空的顺序表）

typedef int Position;
typedef struct LNode *List;
struct LNode {
	ElementType Data[MAXSIZE];
	Position Last;
};

List MakeEmpty()
{
    List PtrL;
    PtrL = (List)malloc(sizeof(struct LNode));
    PtrL->Last = -1;
    return PtrL;
}

(2)查找

#define ERROR -1

Position Find(ElementType X, List PtrL)
{
    Position i = 0;
    while ( i <= PtrL->Last && PtrL->Data[i] != X )
        i++;
    if ( i > PtrL->Last ) return ERROR;  // 如果没找到，返回错误信息
    else return i;                    // 找到后返回的是存储位置
}

(3)插入

bool Insert(ElementType X, Position i, List PrtL)
{
	// i是序列位序（从1开始），而不是存储下标位置（从0开始）
    Position j;
    if ( PtrL->Last == MAXSIZE-1 ) {  
    	// 表空间已满，不能插入
        printf("表满");
        return false;
    }
    if ( i < 1 || i > PtrL->Last+2 ) {
    	// 检查插入位置的合法性
        printf("位置不合法");
        return false;
    }
    for ( j = PrtL->Last; j >= i-1; j-- ) {
    	// 将位置i及以后的元素顺序向后移动
        PrtL->Data[j+1] = PtrL->Data[j];  
    }
    PtrL->Data[i-1] = X;              // 新元素插入
    PtrL->Last++;                     // Last仍指向最后元素
    return ture;
}

(4) 删除

bool Delete(Position i, List PtrL)
{
	// i是序列位序（从1开始），而不是存储下标位置（从0开始）
    Position j;
    if ( i < 1 || i > PtrL->Last+1 ) {
   		// 检查空表及删除位置的合法性
        printf("不存在第%d个元素", i);   
        return false;
    }
    for ( j = i; j <= PtrL->Last; j++) {
    	// 将位置i及以后的元素顺序向前移动
        PtrL->Data[j-1] = PtrL->Data[j];  
    }
    PtrL->Last--;                         // Last仍指向最后元素
    return true;
}

二、链表实现

(1) 求表长

int Length ( List PtrL )
{
    List p = PtrL;      // p指向表的第一个结点
    int j = 0;
    while ( p ) {		// 遍历每个结点
        p = p->Next;
        j++;            // 当前p指向的是第j个结点
    }
    return j;
}

（2）查找

a. 按序号查找

#define ERROR NULL
typedef int Position

List FindKth(Position K, List PtrL)
{
    List p = PtrL;
    int i = 1;
    while ( p != NULL && i < K ) {  // 遍历前K-1个结点
        p = p->Next;
        i++;
    }
    if ( i == K ) 
    	return p;      // 找到第K个，返回指针
    else 
    	return ERROR;  // 否则返回NULL
}

b. 按值查找

List Find(ElementType X, List PtrL)
{
    List p = PtrL;
    while ( p != NULL && p->Data != X) // 遍历查找每个结点的值
        p = p->Next;
    return p;
}

（3）插入

List Insert(ElementType X, Position i, List PtrL)
{
    List pre, tmp;
    if ( i == 1 ) {                                     // 新结点插入在表头
        tmp = (List)malloc(sizeof(struct LNode));       // 申请、填装结点
        tmp->Data = X;
        tmp->Next = PtrL;
        return tmp;                                     // 返回新表头指针
    }
    pre = FindKth( i-1, PtrL);                          // 查找第i-1个结点
    if ( pre == NULL ) {                                // 第i-1个不存在，则不能插入
        printf("插入位置参数错误");
        return NULL;
    }
    else {
    	// 在i前插入新结点
        tmp = (List)malloc(sizeof(struct LNode));       // 申请、填装结点
        tmp->Data = X;
        tmp->Next = pre->Next;                          // 新结点插入在第i-1个结点的后面
        pre->Next = tmp;
        return PtrL;
    }
}

（4）删除

List Delete(Position i, List PtrL)
{
    List pre, tmp;
    if ( i == 1 ) {                                   // 若要删除的是表的第一个结点
        tmp = PtrL;                                   // tmp指向第1个结点
        if ( PtrL != NULL ) {                         // 从链表中删除
            PtrL = PtrL->Next;
        }
        else 
        	return NULL;
        free(tmp);                                      // 释放被删除结点
        return PtrL;
    }
    pre = FindKth(i-1, PtrL);                           // 查找第i-1个结点
    if ( pre == NULL ) {
        printf("第%d个结点不存在", i-1);
        return NULL;
    } 
    else if ( pre->Next == NULL ) {
        printf("第%d个结点不存在", i);
        return NULL;
    } else {
        tmp = pre->Next;                                  // s指向第i个结点
        pre->Next = tmp->Next;                            // 从链表中删除
        free(tmp);                                      // 释放被删除结点
        return PtrL;
    }
}