本节继续介绍线性表的另外一种链式表示——静态链表。(前面介绍的链表称为 动态链表 )。

逻辑结构上相邻的数据元素,存储在指定的一块内存空间中,数据元素只允许在这块内存空间中随机存放,这样的存储结构生成的链表称为静态链表。

静态链表和动态链表的区别:静态链表限制了数据元素存放的位置范围;动态链表是整个内存空间。
图1 静态链表的存储结构

静态链表的构建方法

静态链表使用数组这一数据类型预先申请足够大的内存空间。

由于各数据元素在数组申请的内存空间内随机存放,为了体现逻辑上的相邻,为每一个数据元素配备一个具有指针作用的整形变量,用于记录下一元素在数组中的位置。

在数组申请的存储空间中,各数据元素虽随机存储,每一个元素都记录着下一元素在数组中的位置,通过前一个元素,可以找到下一个元素,构成了一条链表,这条被局限在特定内存空间的链表就是静态链表。

静态链表中结点的构成

静态链表中每个结点既有自己的数据部分,还需要存储下一个结点的位置,所以静态链表的存储实现使用的是结构体数组,包含两部分: 数据域 和 游标(存放的是下一个结点在数组中的位置下标)。

实现代码:

typedef struct 
{
  int data;//数据域
  int cur;//游标
}component;

例如:使用静态链表存储(1,2,3,4,5),创建数组a[7]:

图2 静态链表

图2 中,链表头指针指向 a[0] ,表示为第一个结点,数据域存放的是 1,通过游标确定,下一个结点的位置在 a[3] ,数据域存放的是 2 ,依次类推。若游标为 0,表示此结点为链表的最后一个结点。

静态链表的空间重复利用

由于静态链表提前申请了有限的内存空间,在使用的过程中,极有可能会出现申请的内存空间不足,需要使用之前被遗弃的内存空间。

被遗弃的意思是:之前已经使用,但是后期对该结点做了摘除操作,该内存空间中存放的是已经不用的垃圾数据。

所以,在整个过程中,需要自己动手把两者区分开,也就是需要自己实现 malloc 和 free 两个函数的作用。

解决的办法是:提前将所有未被使用的结点链成一个备用链表。需要对链表做插入操作时,从备用链表上摘下一个结点使用;删除链表中的结点时,删除的同时链接到备用链表上,以备下次使用。


图3 备用链表和数据链表

图3 分析:

第一步:备用链表:(0,1)(1,2)(2,3)(3,4)(4,5)(5,6)(6,0)
              数据链表中还没有数据

第二步:向数据链表中插入一个数据,将备用链表上的(1,2)摘下下,提供给数据元素使用,备用链表的(0,1)游标直接变成2就可以了:
              备用链表:(0,2)(2,3)(3,4)(4,5)(5,6)(6,0)
              数据链表:(1,0)

第三步:继续向数据链表中插入一个数据,备用链表把(2,3)摘下来,备用链表中的(0,1)直接变成3就可以了:
              备用链表:(0,3)(3,4)(4,5)(5,6)(6,0)
              数据链表:(1,2)(2,0)

以此类推。以上为插入结点的过程,在删除结点的反方向操作过程中,只需要将被删除结点从数据链表上摘除,并添加到备用链表中即可(也就是只改变相关结点的游标的值)。

创建并初始化链表

建立静态链表 S,存储线性表(a,b,c,d):
创建结构体数组,例如名为 array,存储空间足够大;
先将 array 数组中的分量全部链接到备用链表上;(使用 reserveArr 函数实现)
从备用链表上申请一个分量作为链表 S 的头结点,每次从备用链表上申请分量链接到 S 链表中,依次类推;
( mallocArr 函数用于每次向备用链表申请一个结点的空间,initArr 函数用于初始化静态链表)
当存储到最后一个结点时,游标设置为 0。  

代码实现:

//创建备用链表
void reserveArr(component *array)
{
  for (int i=; i<maxSize; i++)
  {
    array[i].cur = i+;//将每个数组分量链接到一起
  }
  array[maxSize - ].cur = ;//链表最后一个结点的游标值为0
}
//提取分配空间
int mallocArr(component * array)
{
  //若备用链表非空,则返回分配的结点下标,否则返回0(当分配最后一个结点时,该结点的游标值为0)
  int i = array[].cur;
  if (array[].cur)
  {
    array[].cur = array[i].cur;
  }
  return i;
}
//初始化静态链表
int initArr(component *array)
{
  reserveArr(array);  //链接备用链表
  //从备用链表中拿出一个分量作为链表头结点,返回的是这个分量的下标
  int body = mallocArr(array);
  //声明一个变量,把它当指针使,指向链表的最后的一个结点,因为链表为空,所以和头结点重合
  int tempBody = body;
  for (int i=; i<; i++)
  {
    int j = mallocArr(array); //从备用链表中拿出空闲的分量
    array[tempBody].cur = j;     //将申请的空线分量链接在链表的最后一个结点后面
    array[j].data = 'a' + i - ; //给新申请的分量的数据域初始化
    tempBody = j;            //将指向链表最后一个结点的指针后移
  }
  array[tempBody].cur = ;       //新的链表最后一个结点的指针设置为0
  return body;
}

程序最终效果图:

注:array[0]用作备用链表的头结点,array[1]用作存放数据的链表的头结点,所以array[0]和array[6]为备用链表上的结点。

静态链表中查找数据

一般情况下,访问静态链表只能通过头结点(头结点在数组中的位置下标是知道的),所以查找数据通过遍历链表的方式实现。

实现代码:

//在以body作为头结点的链表中查找数据域为elem的结点在数组中的位置
int selectElem(component * array, int body, char elem)
{
  int tempBody = body;
  //当游标值为0时,表示链表结束
  while (array[tempBody].cur != )
  {
    if (array[tempBody].data == elem)
    {
      return tempBody;
    }
    tempBody = array[tempBody].cur;
  }
  return -;//返回-1,表示在链表中没有找到该元素
}

静态链表中更改数据

更改链表中某结点的数据,只需要通过查找算法找到要更改结点的位置,然后直接更改该结点的数据域即可。

实现代码:

//在以body作为头结点的链表中将数据域为oldElem的结点,数据域改为newElem
void amendElem(component * array, int body, char oldElem, char newElem)
{
  int add=selectElem(array, body, oldElem);
  if (add == -)
  {
    printf("无更改元素");
    return;
  }
  array[add].data = newElem;
}

静态链表中插入结点

继续上边的例子,插入一个结点,例如该结点的数据域为 e,插入到第 3 的位置:

  1. 首先从备用链表中申请空间存储数据元素 e;
  2. 由于要将 e 结点插入到第 3 的位置上,所以要找到 b 结点,将 b 结点的游标赋值给 e 结点;
  3. 最后将 e 结点所在位置的下标给 b 结点的游标;

实现代码(在理解静态链表的存储结构的基础上):

//向链表中插入数据,body表示链表的头结点在数组中的位置,add表示插入元素的位置,a表示要插入的数据
void insertArr(component *array, int body, int add, char a)
{
  int tempBody = body;  //tempBody做遍历结构体数组使用
  //找到要插入位置的上一个结点在数组中的位置
  for (int i=; i<add; i++)
  {
    tempBody = array[tempBody].cur;
  }
  int insert = mallocArr(array);  //申请空间,准备插入
  array[insert].cur = array[tempBody].cur;  //首先要插入结点的游标等于要插入位置的上一个结点的游标
  array[insert].data = a;
  array[tempBody].cur = insert;  //然后让上一结点的游标等于插入结点所在数组中的位置的下标
}

代码运行效果:

静态链表做删除操作

静态链表中删除结点,要实现两步操作:从链表上摘下结点后,将该结点链接到备用链表上,以备下次使用。

注:被摘除结点中的数据不需要手动删除,待下次使用时,会被新的数据域将旧数据覆盖点。

例如,在(a,b,c,d,e)链表中,删除数据域为 ‘a’ 的结点:

实现代码:

//删除结点函数,a 表示被删除结点中数据域存放的数据
void deletArr(component *array, int body, char a)
{
  int tempBody = body;
  //找到被删除结点的位置
  while (array[tempBody].data != a)
  {
    tempBody = array[tempBody].cur;
    //当tempBody为0时,表示链表遍历结束,说明链表中没有存储该数据的结点
    if (tempBody == )
    {
      printf("链表中没有此数据");
      return;
    }
  }
  //运行到此,证明有该结点
  int del = tempBody;
  tempBody = body;
  //找到该结点的上一个结点,做删除操作
  while (array[tempBody].cur != del)
  {
    tempBody = array[tempBody].cur;
  }
  //将被删除结点的游标直接给被删除结点的上一个结点
  array[tempBody].cur = array[del].cur;
  freeArr(array, del);
}

在该函数中,调用了一个freeArr函数,它的作用是回收被删除结点所占用的空间,将此空间链接到备用链表中,以备下次分配使用。(自己实现的free函数)

freeArr函数实现代码:

void freeArr(component *array, int k)
{
  array[k].cur = array[].cur;
  array[].cur = k;
}
 
删除数据域为 ’a’ 结点的运行效果图:

完整实现代码

#include <stdio.h>
#define maxSize 7 typedef struct
{
  char data;
  int cur;
}component;
//将结构体数组中所有分量链接到备用链表中
void reserveArr(component *array);
//初始化静态链表
int initArr(component *array);
//向链表中插入数据,body表示链表的头结点在数组中的位置,add表示插入元素的位置,a表示要插入的数据
void insertArr(component * array,int body,int add,char a);
//删除链表中含有字符a的结点
void deletArr(component * array,int body,char a);
//查找存储有字符elem的结点在数组的位置
int selectElem(component * array,int body,char elem);
//将链表中的字符oldElem改为newElem
void amendElem(component * array,int body,char oldElem,char newElem);
//输出函数
void displayArr(component * array,int body);
//自己需要实现的malloc和free函数
int mallocArr(component * array);
void freeArr(component * array,int k);
int main()
{
  component array[maxSize];
  int body = initArr(array);
  printf("静态链表为:\n");
  displayArr(array, body);
  printf("在第3的位置上插入结点‘e’:\n");
  insertArr(array, body, ,'e');
  displayArr(array, body);
  printf("删除数据域为‘a’的结点:\n");
  deletArr(array, body, 'a');
  displayArr(array, body);
  printf("查找数据域为‘e’的结点的位置:\n");
  int selectAdd = selectElem(array, body, 'e');
  printf("%d\n", selectAdd);
  printf("将结点数据域为‘e’改为‘h’:\n");
  amendElem(array, body, 'e', 'h');
  displayArr(array, body);
  return ;
}
//创建备用链表
void reserveArr(component *array)
{
  for (int i=; i<maxSize; i++)
  {
    array[i].cur = i + ;//将每个数组分量链接到一起
  }
  array[maxSize - ].cur = ;//链表最后一个结点的游标值为0
}
//提取分配空间
int mallocArr(component * array)
{
  //若备用链表非空,则返回分配的结点下标,否则返回0(当分配最后一个结点时,该结点的游标值为0)
  int i = array[].cur;
  if (array[].cur)
  {
    array[].cur = array[i].cur;
  }
  return i;
}
//初始化静态链表
int initArr(component *array)
{
  reserveArr(array);
  int body = mallocArr(array);
  //声明一个变量,把它当指针使,指向链表的最后的一个结点,因为链表为空,所以和头结点重合
  int tempBody = body;
  for (int i=; i<; i++)
  {
    int j = mallocArr(array);//从备用链表中拿出空闲的分量
    array[tempBody].cur = j;//将申请的空线分量链接在链表的最后一个结点后面
    array[j].data = 'a' + i - ;//给新申请的分量的数据域初始化
    tempBody = j;//将指向链表最后一个结点的指针后移
  }
  array[tempBody].cur = ;//新的链表最后一个结点的指针设置为0
  return body;
}
void insertArr(component *array, int body, int add, char a)
{
  int tempBody = body;
  for (int i=; i<add; i++)
  {
    tempBody = array[tempBody].cur;
  }
  int insert = mallocArr(array);
  array[insert].cur = array[tempBody].cur;
  array[insert].data = a;
  array[tempBody].cur = insert;
}
void deletArr(component *array, int body, char a)
{
  int tempBody = body;
  //找到被删除结点的位置
  while (array[tempBody].data != a)
  {
    tempBody = array[tempBody].cur;
    //当tempBody为0时,表示链表遍历结束,说明链表中没有存储该数据的结点
    if (tempBody == )
    {
      printf("链表中没有此数据");
      return;
    }
  }
  //运行到此,证明有该结点
  int del = tempBody;
  tempBody = body;
  //找到该结点的上一个结点,做删除操作
  while (array[tempBody].cur != del)
  {
    tempBody = array[tempBody].cur;
  }
  //将被删除结点的游标直接给被删除结点的上一个结点
  array[tempBody].cur = array[del].cur;
  freeArr(array, del);
}
int selectElem(component * array, int body, char elem)
{
  int tempBody = body;
  //当游标值为0时,表示链表结束
  while (array[tempBody].cur != )
  {
    if (array[tempBody].data == elem)
    {
      return tempBody;
    }
    tempBody = array[tempBody].cur;
  }
  return -;//返回-1,表示在链表中没有找到该元素
}
void amendElem(component *array, int body, char oldElem, char newElem)
{
  int add = selectElem(array, body, oldElem);
  if (add == -)
  {
    printf("无更改元素");
    return;
  }
  array[add].data = newElem;
} void displayArr(component *array, int body)
{
  int tempBody = body;  //tempBody准备做遍历使用
  while (array[tempBody].cur)
  {
    printf("%c,%d ", array[tempBody].data, array[tempBody].cur);
    tempBody = array[tempBody].cur;
  }
  printf("%c,%d\n", array[tempBody].data, array[tempBody].cur);
}
void freeArr(component *array, int k)
{
  array[k].cur = array[].cur;
  array[].cur = k;
}
输出结果:
静态链表为:
, a, b, c, d,
在第3的位置上插入结点‘e’:
, a, b, e, c, d,
删除数据域为‘a’的结点:
, b, e,
查找数据域为‘e’的结点的位置: 将结点数据域为‘e’改为‘h’:
, b, h, c, d,

总结

静态链表综合了顺序表和动态链表的优点:使用数组存储数据元素,便于做查找遍历操作;同时,在数组中借鉴了动态链表的特点,在链表中插入或者删除结点时只需更改相关结点的游标,不需要移动大量元素。

数据结构6: 静态链表及C语言实现的更多相关文章

  1. 【数据结构】之链表(Java语言描述)

    以前写过一篇帖子,记录了链表在C语言中的描述代码.C语言中没有链表的直接实现,因此,我们需要自己编写代码实现.请参考[我的这篇文章]. Java中默认为我们提供了链表的API—— LinkedList ...

  2. 数据结构入门之链表(C语言实现)

    这篇文章主要是根据<数据结构与算法分析--C语言描述>一书的链表章节内容所写,该书作者给出了链表ADT的一些方法,但是并没有给出所有方法的实现.在学习的过程中将练习的代码记录在文章中,并添 ...

  3. 【数据结构】之链表(C语言描述)

    链表是线性表的一种,是一种物理存储单元上非连续的存储结构,链表中的数据元素之间是通过指针链接实现的. 链表由一系列节点组成,节点可以在运行时动态的生成. 链表中国的每个节点分为两部分:一部分是存储数据 ...

  4. 指针与数据结构算法_链表(C语言)

    一.变量: 声明一个变量系统是没有给这个变量分配内存空间的: 例: int j;//编译的时候是没有分配内存空间的 ;//计算机在编译的时候就会给这个i分配4个字节的内存空间 二.malloc动态分配 ...

  5. 静态链表 C++版

    笔记静态链表的实现 #include "stdafx.h" #include<iostream> using namespace std; #define MAXSIZ ...

  6. 静态链表C语言数据结构

    静态链表就是将数组实现单链表: int Malloc_SLL(StaticLinkList space) { int i = space[0].cur;//取得第一个头节点的下标 if( space[ ...

  7. 数据结构 - 动态单链表的实行(C语言)

    动态单链表的实现 1 单链表存储结构代码描述 若链表没有头结点,则头指针是指向第一个结点的指针. 若链表有头结点,则头指针是指向头结点的指针. 空链表的示意图: 带有头结点的单链表: 不带头结点的单链 ...

  8. 使用C语言描述静态链表和动态链表

    静态链表和动态链表是线性表链式存储结构的两种不同的表示方式. 静态链表的初始长度一般是固定的,在做插入和删除操作时不需要移动元素,仅需修改指针,故仍具有链式存储结构的主要优点. 动态链表是相对于静态链 ...

  9. 【Java】 大话数据结构(3) 线性表之静态链表

    本文根据<大话数据结构>一书,实现了Java版的静态链表. 用数组描述的链表,称为静态链表. 数组元素由两个数据域data和cur组成:data存放数据元素:cur相当于单链表中的next ...

随机推荐

  1. Solaris10镜像情况下如何修复boot archive

    在某些情况下(比如:异常宕机)solaris10的boot archive可能会损坏,导致solaris无法启动,此时需要手工修复boot archive. 本文通过模拟boot archive损坏, ...

  2. 【Android 多媒体应用】使用 TTS

    import java.util.Locale; import android.app.Activity; import android.os.Bundle; import android.speec ...

  3. apache server和tomcat集群配置三:水平集群下的tomcat集群配置

    在jsp文件中加入以下代码,用来测试是否共享session: SessionID: <%= session.getId() %> 之前尝试在linux中,但是因为模拟环境是虚拟机,虚拟机只 ...

  4. @SuppressWarnings("unused")注解的作用

    JDK5.0后的新特性,你在使用IDE如eclipse的时候,当你定义了一个变量如int a=0;但是你后面根本就没有使用到这个变量,这一行的前面会有一个黄色的警告标志,你将鼠标移动到上面会提示“这个 ...

  5. sql基本查询语句练习

    student(S#,Sname,Sage,Ssex) 学生表       S#:学号: Sname:学生姓名:Sage:学生年龄:Ssex:学生性别 Course(C#,Cname,T#) 课程表 ...

  6. elasticsearch配置文件里的一些坑 [Failed to load settings from [elasticsearch.yml]]

    这里整理几个空格引起的问题. 版本是elasticsearch-2.3.0 或者elasticsearch-rtf-master Exception in thread "main" ...

  7. ROS探索总结(二)——ROS总体框架

    个人分类: ROS 所属专栏: ROS探索总结   一.  总体结构        根据ROS系统代码的维护者和分布来标示,主要有两大部分:      (1)main:核心部分,主要由Willow G ...

  8. ROS Learning-021 learning_tf-05(编程) now() 和 Time(0) 的区别 (Python版)

    ROS Indigo learning_tf-05 now() 和 Time(0)的区别 (Python版) - waitForTransform() 函数 我使用的虚拟机软件:VMware Work ...

  9. PCL—关键点检测(iss&Trajkovic)低层次点云处理

    博客转载自:http://www.cnblogs.com/ironstark/p/5069311.html 关键点检测往往需要和特征提取联合在一起,关键点检测的一个重要性质就是旋转不变性,也就是说,物 ...

  10. 一道java笔试题目:Vector和ArrayList的区别

    Vector和ArrayList的区别 线性表,链表,哈希表是常用的数据结构,在进行Java开发时,JDK已经为我们提供了一系列相应的类来实现基本的数据结构这些类均在java.util包中本文试图通过 ...