线性表实现

1.顺序表：

仅由一个结构体组成，定义及实现如下所示：

struct order_list {
    elementtype data[maxsize];//定义一个数组，够长
    int last;//最后一个元素的位置
}
typedef struct order_list* list;//指向该结构体的指针

//初始化
list initial(){
    list L=(list)malloc(sizeof(struct order_list));
    L->last=-1;//表示空
    return L;
}

//查找元素x的下标
int find(list L,elementtype x){
    list p=L;
    int position=0;
    while(p->last>=position && p->data[position]!=x)
        position++;
    if (p->data[position]==x)
        return position;//找到，返回坐标
    else 
        return null;//未找到
}

//在位置p前插入元素x
bool insert(list L,elementtype x,int p){
    if (L->last+1==maxsize)
        return false;//没有位置可插入
    
    if (p<0 || p>L->last+1)
        return false；//坐标不合法
    
    for (int i=L->last;i>=p;i--)
        L->data[i+1]=L->data[i];//将坐标为p开始到最后一个元素，往后挪一位
    L->data[p]=x;//插入x
    L->last++;
    return true;//插入成功
}

//删除坐标为p处的元素x
bool delete(list L,int p){ 
    if (p<0 || p>L->last)
        return false；//坐标不合法
    
 	for (int i=p;i<L->last;i++)
        L->data[i]=L->data[i+1];//将从坐标为p+1到last向前挪一位
    L->last--;
    return true;
}

综上可知：

1. 顺序表是定长的，一旦定义，无法改变长度；
2. 做删除，插入操作时，需要大量移位工作，效率低；

2.链式表：

1. 查找元素x的时间复杂度与顺序表相同—$O(N)$;

2. 做删除，插入操作时，效率高，时间复杂度为$O(1)$，顺序表则为$O(N)$;

   但在以下操作中，需要判断在哪个位置删除和插入，故为$O(N)$；

链式表由不限数个结构体和一个头指针组成，因而长度可变，不受限，其定义及实现如下所示：

typedef struct chain_list* ptr;
struct chain_list{
    elementtype data;
    ptr next;
}

//初始化
ptr initial(){
    ptr head=(ptr)malloc(sizeof(struct chain_list));
    head->data=-1;
    head->next=null;
    return head;
}

//查找元素x
ptr find(ptr head,elementtype x){
    ptr p=head;
    while(p!=null && p->data!=x)
        p=p->next;
    return p;//当未找到时，p==null，返回null；找到则返回位置ptr p
}

//在位置p前插入元素x
bool insert(ptr head,ptr p,elementtype x){
    for (ptr t=head; t!=null&&t->next!=p; t=t->next) ;//判断p是否存在
    if (t==null&&p!=head)
        return false;//p不在该表中
    else{//找到了
        ptr new_ptr=(ptr)malloc(sizeof(struct chain_list));
      	new_ptr->data=x;
        new_ptr->next=p;
        t->next=new_ptr;
   		return true;
    }
    //以上不能在第一个节点前添加，故增加如下判断：
    if (p==head){
        ptr new_ptr=(ptr)malloc(sizeof(struct chain_list));
        new_ptr->data=x;
        new_ptr->next=head;
        head=new_ptr;
        return true;
    }
}

//删除位置为p处的节点
bool delete(ptr head,ptr p){
    for (ptr t=head; t!=null&&t->next!=p; t=t->next) ;//判断p是否存在
    if (t==null&&p!=head)
        return false;//p不在该表中
    else{//找到了 
       	t->next=p->next;
       	free(p);
    	return true;
    }
     //以上不能删除第一个节点，故增加如下判断：
    if (p==head){
        head=head->next;
        free(p);
        return true;
    }
}