数据结构笔记1 线性表及其实现（顺序存储结构和链式存储结构）

最新推荐文章于 2022-08-02 19:21:19 发布

Lora青蛙

最新推荐文章于 2022-08-02 19:21:19 发布

阅读量781

点赞数 2

分类专栏：数据结构文章标签：数据结构链表指针

本文链接：https://blog.csdn.net/LoraRae/article/details/107786178

版权

数据结构专栏收录该内容

12 篇文章 9 订阅

订阅专栏

文章目录

线性表基本概念

线性表(Linear List)：由同类型数据元素构成有限序列的线性结构
表中元素个数称为线性表的长度
线性表没有元素时，称为空表
表起始位置称表头，表结束位置称表尾
（线性表可以是有序的，也可以是无序的。序列不是指的特定的顺序的排列，根据数据元素插入顺序保存，也叫序列。所以，序列不等于有序。）

线性表基本操作主要有：
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。

线性表的顺序存储实现

利用数组的连续存储空间顺序存放线性表的各元素
在这里插入图片描述

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

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

主要操作的实现（初始化、查找、插入、删除）

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

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

2、查找

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)。

3、插入（第 i (1≤i≤n+1)个位置上插入一个值为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]; /*将 ai～ an倒序向后移动*/
 PtrL->Data[i-1] = X; /*新元素插入*/
 PtrL->Last++; /*Last仍指向最后元素*/
 return; 
}

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

问：如果把后移数组元素的循环

   for ( j = PtrL->Last; j >= i-1; j-- )
       PtrL->Data[j+1]=PtrL->Data[j];

改为

   for ( j = i-1; j <= PtrL->Last; j++ )
       PtrL->Data[j+1]=PtrL->Data[j];

那会是什么后果？
答：分量Data[i-1]到Data[Ptrl->Last+1]都是同一个值，即移之前Data[i-1]的值。

4、删除（删除表的第 i (1≤i≤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 struct LNode *List;
struct LNode{ 
 ElementType Data; 
 List Next;
}; 
struct Lnode L;
List PtrL;

主要操作的实现（求表长、查找、插入、删除）

1、求表长

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

时间性能为 O(n)。

2、查找
（1）按序号查找：FindKth;
（找第K个元素）

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; 
 /* 否则返回空 */
}

（2）按值查找：Find
（已知X，查X在表的哪个位置）

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

平均时间性能为 O(n)。

3、插入（在第 i-1(1≤i≤n+1)个结点后插入一个值为X的新结点)
（1）先构造一个新结点，用s指向；
（2）再找到链表的第 i-1个结点，用p指向；
（3）然后修改指针，插入结点 ( p之后插入新结点是 s)
在这里插入图片描述
让s指向下一个结点，p的next赋给s的next
让p的结点指向s，就是s赋给p的next
通过以上两个赋值语句就可以修改两个指针方向，就可以插入结点了

问：如果语句执行顺序为：(1) p->Next=s; (2) s->Next=p->Next;那么后果是什么？
答：s->Next指向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 ); /* 查找第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;
 } }

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

4、删除（删除链表的第 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指向第1个结点*/
 if (PtrL!=NULL) PtrL = PtrL->Next; /*从链表中删除*/
 else return NULL;
 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)。

源代码汇总

（来自MOOC浙大数据结构）

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;   
}

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 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;
    }
}