线性表

继续听课

线性表：同类型数据元素构成有序序列的线性结构，表中元素个数称为线性表的长度，线性表没有元素时，称为空表。表起始位置称表头，表结束位置称表尾。

操作集：某线性表L属于List类型，整数i表示元素所在的位置即位序，元素X为ElementType，
线性表基本操作主要有：
1、List MakeEmpty()：初始化一个空线性表L；
2、ElementType FindKth( int K, List L )：根据位序K，返回相应元素 ；
3、int Find( ElementType X, List L )：在线性表L中查找X的第一次出现位置；
4、void Insert( ElementType X, int i, List L)：在位序i前插入一个新元素X；
5、void Delete( int i, List L )：删除指定位序i的元素；
6、int Length( List L )：返回线性表L的长度n。

(1)线性表的顺序储存实现

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

typedef struct LNode *List; //线性表结构指针
struct LNode{ 
ElementType Data[MAXSIZE]; 
int Last;  //last表示线性表的最后一个元素的位置
} ; 
struct LNode L;
List PtrL;

访问下标为 i 的元素：L.Data[i] 或 PtrL->Data[i]
线性表的长度：L.Last+1 或 PtrL->Last+1
···初始化：

List MakeEmpty( ) { 
List PtrL;
PtrL = (List )malloc( sizeof(struct LNode) ); //申请结构
PtrL->Last = -1; //last=0表示表里有一个元素放在第一个位置
return PtrL;
}

···查找

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; /* 找到后返回的是存储位置 */

查找成功的平均比较次数为(n +1)/2，平均时间性能为O(n)。

··插入：第 i (1≤i≤n+1)个位置上插入一个值为X的新元素，n+1表示线性表的最后

从后往前挪

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]; /*将 ai～ an倒序向后移动*/
PtrL->Data[i-1] = X; /*新元素插入*/
PtrL->Last++; /*，因为多了一个元素，让Last仍指向最后元素*/
return; 
} 

平均移动次数为 n /2，平均时间性能为 O(n)

···删除：

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]; /*将 ai+1～ an顺序向前移动*/
PtrL->Last--; /*Last仍指向最后元素*/
return; 
}

平均移动次数为(n-1)/2,平均时间性能为O(n)

typedef int Position;
typedef struct LNode *List;
struct LNode {
    ElementType Data[MAXSIZE];    
    Position Last;
}; 
/* 初始化 */
    List MakeEmpty(){
     List L;     
     L = (List)malloc(sizeof(struct LNode));    
     L->Last = -1;     
     return L;
     }
/* 查找 */
     #define ERROR -1 
     Position Find( List L, ElementType X ){   
      Position i = 0;     
      while( i <= L->Last && L->Data[i]!= X )        i++;    
      if ( i > L->Last )  return ERROR; /* 如果没找到，返回错误信息 */    
      else  return i;  /* 找到后返回的是存储位置 */}
/* 插入 */
/*注意:在插入位置参数P上与课程视频有所不同，课程视频中i是序列位序（从1开始），这里P是存储下标位置（从0开始），两者差1*/
    bool Insert( List L, ElementType X, Position P ) { /* 在L的指定位置P前插入一个新元素X */    
    Position i;     
    if ( L->Last == MAXSIZE-1) {        /* 表空间已满，不能插入 */        
    printf("表满");         
    return false;     
    }      
    if ( P<0 || P>L->Last+1 ) { /* 检查插入位置的合法性 */        
    printf("位置不合法");        
    return false;     
    }     
    for( i=L->Last; i>=P; i-- )        L->Data[i+1] = L->Data[i]; /* 将位置P及以后的元素顺序向后移动 */    
    L->Data[P] = X;  /* 新元素插入 */    
    L->Last++;       /* Last仍指向最后元素 */    
    return true; 
    }  
/* 删除 */
/*注意:在删除位置参数P上与课程视频有所不同，课程视频中i是序列位序（从1开始），这里P是存储下标位置（从0开始），两者差1*/
  bool Delete( List L, Position P ){ /* 从L中删除指定位置P的元素 */    
  Position i;     
  if( P<0 || P>L->Last ) { /* 检查空表及删除位置的合法性 */        
  printf("位置%d不存在元素", P );         
  return false;     
  }    
  for( i=P+1; i<=L->Last; i++ )        
  L->Data[i-1] = L->Data[i]; /* 将位置P+1及以后的元素顺序向前移动 */    
  L->Last--; /* Last仍指向最后元素 */    
  return true;   
  }

(2)线性表的链式存储实现

typedef struct LNode *List;
struct LNode{ 
ElementType Data; 
List Next;
}; 
struct Lnode L;
List PtrL;

···求表长：
通过遍历链表的方式 O(n)

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

···查找：平均时间性能为O(n)

按序号查找：FindKth;

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

按值查找：Find;

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的新结点
平均查找次数为 n /2，平均时间性能为 O(n)

（1）先构造一个新结点，用s指向；
（2）再找到链表的第 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; /*返回新表头指针s*/
}
p = FindKth( i-1, PtrL ); /* 查找第i-1个结点 */
if ( p == NULL ) { /* 第i-1个不存在，不能插入 */
printf(＂参数i错＂);
return NULL; 
}else {
s = (List)malloc(sizeof(struct LNode)); /*申请、填装结点*/
s->Data = X; 
s->Next = p->Next; /*新结点插入在第i-1个结点的后面*/
p->Next = s; 
return PtrL; 
} 

···删除：删除链表的第 i (1≤i≤n)个位置上的结点
不能随意改变步骤：
（1）先找到链表的第 i-1个结点，用p指向；
（2）再用指针s指向要被删除的结点（p的下一个结点）;
（3）然后修改指针，删除s所指结点：让p指针指向s指向的后面结点，即p->Next = s->Next;
（4）最后释放s所指结点的空间。

List Delete( int i, List PtrL )
{ 
List p, s;
if ( i == 1 ) { /* 若要删除的是表的第一个结点 */
s = PtrL; /*s指向第1个结点*/
if (PtrL!=NULL) PtrL = PtrL->Next; /*从链表中删除*/
else return NULL;  //ptrl本身就是空的，删除不成功返回空
free(s); /*释放被删除结点 */
return PtrL; 
}
p = FindKth( i-1, PtrL ); /*查找第i-1个结点，即要删除结点的前一个结点*/
if ( p == NULL ) { 
printf(“第%d个结点不存在”, i-1); return NULL; 
} else if ( p->Next == NULL ){ 
printf(“第%d个结点不存在”, i); return NULL; 
} else {
s = p->Next; /*s指向第i个结点*/
p->Next = s->Next; /*从链表中删除*/
free(s); /*释放被删除结点 */
return PtrL; 
} 

平均查找次数为 n /2，平均时间性能为 O(n)

typedef struct LNode *PtrToLNode;struct LNode {
    ElementType Data;    
    PtrToLNode Next;
};
typedef PtrToLNode Position;
typedef PtrToLNode List; 
/* 查找 */
#define ERROR NULL Position Find( List L, ElementType X ){
    Position p = L; /* p指向L的第1个结点 */     
    while ( p && p->Data!=X )        
    p = p->Next;     
/* 下列语句可以用 return p; 替换 */    
if ( p )        
return p;    
else        
return ERROR;
} 
/* 带头结点的插入 */
/*注意:在插入位置参数P上与课程视频有所不同，课程视频中i是序列位序（从1开始），这里P是链表结点指针，在P之前插入新结点 */
bool Insert( List L, ElementType X, Position P ){ 
/* 这里默认L有头结点 */    
Position tmp, pre;     
/* 查找P的前一个结点 */            
for ( pre=L; pre&&pre->Next!=P; pre=pre->Next ) ;                
if ( pre==NULL ) { /* P所指的结点不在L中 */      
  printf("插入位置参数错误\n");        
  return false;    
  }    
  else { /* 找到了P的前一个结点pre */        
  /* 在P前插入新结点 */        
  tmp = (Position)malloc(sizeof(struct LNode)); /* 申请、填装结点 */        
  tmp->Data = X;         
  tmp->Next = P;        
  pre->Next = tmp;        
  return true;    }
  } 
/* 带头结点的删除 */
/*注意:在删除位置参数P上与课程视频有所不同，课程视频中i是序列位序（从1开始），这里P是拟删除结点指针 */
bool Delete( List L, Position P ){ 
/* 这里默认L有头结点 */    
Position tmp, pre;     
/* 查找P的前一个结点 */            
for ( pre=L; pre&&pre->Next!=P; pre=pre->Next ) ;                
if ( pre==NULL || P==NULL) { /* P所指的结点不在L中 */     
   printf("删除位置参数错误\n");        
   return false;    
   }    
else { /* 找到了P的前一个结点pre */      
  /* 将P位置的结点删除 */        
  pre->Next = P->Next;        
  free(P);        
  return true;    }
}

推广：广义表
对于线性表而言， n个元素都是基本的单元素； 
广义表中，这些元素不仅可以是单元素也可以是另一个广义表。

typedef struct GNode *GList;
struct GNode{
int Tag; /*标志域：0表示结点是单元素，1表示结点是广义表 */
union { /*子表指针域Sublist与单元素数据域Data复用，即共用存储空间*/
ElementType Data;
GList SubList; 
} URegion;
GList Next; /* 指向后继结点 */
};

多重链表：链表中的节点可能同时隶属于多个链
多重链表中结点的指针域会有多个，如前面例子包含了Next和SubList两个指针域；
但包含两个指针域的链表并不一定是多重链表，比如双向链表不是多重链表。 
多重链表有广泛的用途：基本上如树、图这样相对复杂的数据结构都可以采用多重链表方式实现存储。


term类型结点有两个指针，一个指向同一行且设计成一个循环链表，一个指向同一列且设计成一个循环链表，形成了十字结构，所以叫做十字列表。
head作为行链表和列链表的头结点
而图中A指向的结点是整个矩阵的入口，表示4行5列7个非零项，通过7旁边的指针，可以找到所有行的头结点，所有列的头结点

啦啦啦啦