线性结构-线性表

线性表

由同类型数据元素构成有序序列的线性结构

• 表中元素个数称为线性表的长度
• 线性表没有元素时，称为空表
• 表起始位置称表头，表结束位置称表尾

线性表的抽象数据类型描述

• 线性表是n个元素构成的有序序列

线性表基本操作

• List MakeEmpty() 初始化一个空线性表L

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

• ElemType_FindKth(int K,List L) 根据位序K，返回相应元素
• int Find(ElementType X,List L) 在线性表L中查找X的第一次出现位置

int Find(ElementType X,List PtrL){
      int i=0;
      while(i<=PtrL->Last && PtrL->Data[i]=X)
            i++;
      if(i>PtrL->Last) return -1  //如果没有找到 返回-1
      else return i;              //找到后返回存储位置
}

• void insert(ElementType X,int i,List L) 在位序前插入一个新元素X

void insert(ElementType X,int i,List Ptrl){
      int j;
      if(PtrL->Last==MAXSIZE-1){  //表空间已满 不能插入
            printf("表满");
            return;
      }
      if(i<1||i>PtrL->Last+2){   //检查插入位置的合法性
            printf("位置不合法");
            return;
      }
      for(j=PtrL->Last;j>=i-1;j)
            PtrL->Data[j+1]=PtrL->Data[j]; //将a[i]-a[n]倒序向后移动
      PtrL->Data[i-1]=X;                   //新元素插入
      PtrL->Last++;                        //Last仍指向最后的元素
      return;

• void Delete(int i,List L) 删除指定位序i的元素

void Delete(int i,List Ptrl){
      int j;
      if(i<1||i>Ptrl->Last+1){
            printf("不存在第%d个元素",i);
            return;
      }
      for(j=i;j<=PtrL->Last;j++)
            PtrL->Data[j-1]=PtrL->Data[j];
      PtrL->Last--;
      return;

• int Length(List L) 返回线性表L的长度n

增删改查

线性表的顺序存储结构

1. 利用数组的连续存储空间顺序存放线性表的各元素

typedef struct LNode*list;
struct LNode{
      ElementType Data[MaxSize];
      int Last;
};
struct LNode L;
List PtrL;

线性表的链式存储实现

主要操作的实现

求表长

int Length(List Ptrl0{  //遍历整个链表
      List p=PtrL;      //p指向表的第一个结点
      int j=0;
      while(p){
            p=p->Next;
            j++;        //当前怕p指向的是第j个结点
      }
      return j;          //时间复杂度O(n)
}

查找

1. 按序号查找

List FindKth(int K,List PtrL0{
      List p=PtrL;
      int i=1;
      while(p!=Null && i<K){
            p=p->Next;
            i++;
      }
      if(i==K)return p;//找到第K个 返回指针
      esle return Null;
}

2. 按值查找

List Find(ElementType X,List PtrL){
      List p=PtrL;
      while(p!=Null && p->Data !=X)
            p=p->Next;
      return p;
}

插入(在第i-1(1<=i<=n+1)个结点后插入一个值为X的新结点)

1. 先构造一个新结点，用s指向；
2. 再找i到链表的第i-1个结点，用p指向；
3. 然后修改指针，插入结点(p之后插入新结点是s）

List Insert(ElementType X,int i,List PtrL){
      List p,s;
      if(i==1){
            s=(List)malloc(sizeof(struct LNode));
            s->Data=X;
            s->Next=PtrL;
            return s;
      }
      p=FindKth(i-1,PtrL);
      if(p==Null){
            printf("参数错");
            return Null;
      }
      else{
            s=(List)malloc(sizeof(struct LNode));
            s->Data=X;
            s->Next=p->Next;
            p->Next=s;
            return PtrL;
      }
}

删除(删除链表的第i(1<=i<=n)个位置上的结点）

1. 先找到链表的第i-1个结点，用p指向；
2. 再用指针s指向要被删除的结点(p的下一个结点);
3. 然后修改指针，删除s所指结点;
4. 释放s所指结点的空间

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