刚调试完就忘了原理… 😱，把代码贴出来以后查看，短时间不想看第二遍了😐。代码结构如下：
- 正式版：C#实现的静态链表，更偏向于C#语法特性、面向对象，代码比较完善。
- 翻译版：用C#语言翻译了《大话数据结构》的C代码实现，仅供参考。
- 原版：《大话数据结构》的原版C代码实现，仅供参考。
设计思想：让数组的元素都是由data、cur两个数据域组成，数组的每个下标都对应一个data和一个cur。数据域data存放数据元素（要处理的数据），游标cur相当于单链表中的next 指针存放该元素的后继在数组中的下标。
正式版
静态链表C#实现：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace DataStructure
{
public class StaticLinkList<T>
{
/// <summary>
/// 线性表的静态链表存储结构
/// </summary>
/// <typeparam name="T"></typeparam>
class StaticLinkListNode<T>
{
public T data;
public int cur { get; set; }
}
/// <summary>
/// 自定义异常
/// </summary>
class MyException : Exception
{
public MyException(string message) : base(message)
{
}
}
int maxSize;
public int MaxSize { get { return maxSize; } }
StaticLinkListNode<T>[] space;
/// <summary>
/// 访问索引，索引从0开始
/// </summary>
/// <param name="i"></param>
/// <returns></returns>
public T this[int i]
{
get
{
int k= GetIndex(i);
return space[k].data;
}
set
{
int k = GetIndex(i);
space[k].data=value;
}
}
public StaticLinkList(int maxSize)
{
//增加两个长度
//数组第一个元素的cur用来存放备用链表第一个结点的下标
//数组最后一个元素的cur用来存放第一个插入元素的下标，相当于头结点
this.maxSize = maxSize + 2;
InitList();
}
/// <summary>
/// 将一维数组space中各分量链成一个备用链表，space[0].cur为头指针，"0"表示空指针
/// </summary>
void InitList()
{
space = new StaticLinkListNode<T>[maxSize];
int i;
for (i = 0; i < maxSize; i++)
{
space[i] = new StaticLinkListNode<T>();
//存放该元素的后继在数组中的下标
space[i].cur = i + 1;
}
//目前静态链表为空，最后一个元素的Cursor为0
space[maxSize - 1].cur = 0;
}
/// <summary>
/// 若备用空间链表非空，则返回分配的结点下标，否则返回0
/// </summary>
/// <param name="space"></param>
int Malloc_SLL()
{
//当前数组第一个元素的Cursor存的值，就是要返回的第一个备用空闲的下标
int i = space[0].cur;
if (space[0].cur != 0)
{
//由于要拿出一个分量来使用了,所以我们就得把它的下一个分量用来做备用
space[0].cur = space[i].cur;
}
return i;
}
/// <summary>
/// 将下标为k的空闲结点回收到备用链表
/// </summary>
/// <param name="space"></param>
/// <param name="k"></param>
void Free_SSL(int k)
{
//把第一个元素的cur值赋给要删除的分量cur
space[k].cur = space[0].cur;
//把要删除的分量下标赋值给第一个元素的cur
space[0].cur = k;
}
/// <summary>
/// 根据静态链表索引获取存储数组的索引
/// </summary>
/// <param name="i"></param>
int GetIndex(int i)
{
if (ListLength() == 0)
throw new MyException("静态链表为空，无可访问索引");
if (i < 0 || i > ListLength() - 1)
throw new MyException(i + "超出静态链表索引范围0-" + (space.Length - 1));
//获取头结点的数组索引
int k = maxSize - 1;
for (int j = 0; j < i + 1; j++)
{
k = space[k].cur;
}
return k;
}
/// <summary>
/// 初始条件：静态链表已存在。操作结果：返回L中数据元素个数
/// </summary>
/// <returns></returns>
public int ListLength()
{
int j = 0;
int i = space[maxSize - 1].cur;
while (i != 0)
{
i = space[i].cur;
j++;
}
return j;
}
/// <summary>
/// 在从0开始的指定索引处插入新的数据元素e，原数据元素后移
/// </summary>
/// <param name="i"></param>
/// <param name="e"></param>
/// <returns></returns>
public void ListInsert(int i, T e)
{
if (ListLength() == 0)
throw new MyException("静态链表为空，无可访问索引");
if (i < 0 || i > ListLength() - 1)
throw new MyException(i + "超出静态链表索引范围0-" + (space.Length - 1));
//获得空闲分量的下标
int j = Malloc_SLL();
if (j != 0)
{
//将数据赋值给此分量的data
space[j].data = e;
int m = maxSize - 1; ;
//获取索引i元素之前的存储位置
for (int k = 0; k < i; k++)
m = space[m].cur;
space[j].cur = space[m].cur;
//把新元素的下标赋值给第i个元素之前元素的cur
space[m].cur = j;
}
else throw new MyException("备用空间链表为空");
}
/// <summary>
/// 删除在L中索引为i的数据元素
/// </summary>
/// <param name="i"></param>
/// <returns></returns>
public void ListDelete(int i)
{
int j, k;
if (ListLength() == 0)
throw new MyException("静态链表为空，无可访问索引");
if (i < 0 || i > ListLength() - 1)
throw new MyException(i + "超出静态链表索引范围0-" + (space.Length - 1));
k = maxSize - 1;
for (j = 0; j < i; j++)
k = space[k].cur;
j = space[k].cur;
space[k].cur = space[j].cur;
Free_SSL(j);
}
/// <summary>
/// 在链表尾部添加一个元素
/// </summary>
/// <param name="value"></param>
public void Append(T value)
{
int pos = Malloc_SLL(); //获取第一个可用节点位置
//如果节点可用
if (pos > 0)
{
//遍历已用链表，挂载新节点
int k = space[maxSize - 1].cur;
while (space[k].cur != 0)
{
k = space[k].cur;
}
space[k].cur = pos;
space[pos].cur = 0;
space[pos].data = value;
}
}
}
}
测试：
using DataStructure;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Test_StaticLinkList
{
class Program
{
static void Main(string[] args)
{
StaticLinkList<string> list = new StaticLinkList<string>(100);
Console.WriteLine("list存储的元素个数" + list.ListLength());
Console.WriteLine("list末尾位置添加3个元素......");
list.Append("索引0：第一个点");
list.Append("索引1：第二个点");
list.Append("索引2：第三个点");
ForeachList(list);
list.ListDelete(1);
Console.WriteLine("删除list索引1处的元素");
ForeachList(list);
list[0]= list[0]+"更改文字";
Console.WriteLine("更改list索引0处的元素");
ForeachList(list);
list.ListInsert(1, "索引1：第二个点");
Console.WriteLine("list索引1处插入元素");
ForeachList(list);
Console.ReadLine();
}
static void ForeachList(StaticLinkList<string> list)
{
Console.WriteLine();
Console.WriteLine("list存储的元素个数" + list.ListLength());
Console.WriteLine("list遍历元素:");
for (int i = 0; i < list.ListLength(); i++)
{
Console.WriteLine(list[i]);
}
Console.WriteLine();
}
}
}
翻译版
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace DataStructure
{
public class StaticLinkList<T>
{
/// <summary>
/// 线性表的静态链表存储结构
/// </summary>
/// <typeparam name="T"></typeparam>
class StaticLinkListNode<T>
{
public T data;
public int cur { get; set; }
}
/// <summary>
/// 自定义异常
/// </summary>
class MyException : Exception
{
public MyException(string message) : base(message)
{
}
}
int maxSize;
public int MaxSize { get { return maxSize; } }
StaticLinkListNode<T>[] space;
/// <summary>
/// 访问索引
/// </summary>
/// <param name="i"></param>
/// <returns></returns>
public T this[int i]
{
get
{
int j, k;
if (i < 1 || i > ListLength())
throw new MyException(i + "超出静态链表已存储元素的个数范围1-" + space.Length);
k = maxSize - 1;
for (j = 1; j <= i - 1; j++)
k = space[k].cur;
j = space[k].cur;
return space[j].data;
}
set
{
ListInsert(i+1, value);
}
}
public StaticLinkList(int maxSize)
{
this.maxSize = maxSize;
InitList();
}
/// <summary>
/// 将一维数组space中各分量链成一个备用链表，space[0].cur为头指针，"0"表示空指针
/// </summary>
void InitList()
{
space = new StaticLinkListNode<T>[maxSize];
int i;
for (i = 0; i < maxSize; i++)
{
space[i] = new StaticLinkListNode<T>();
//存放该元素的后继在数组中的下标
space[i].cur = i + 1;
}
//目前静态链表为空，最后一个元素的Cursor为0
space[maxSize - 1].cur = 0;
}
/// <summary>
/// 若备用空间链表非空，则返回分配的结点下标，否则返回0
/// </summary>
/// <param name="space"></param>
int Malloc_SLL()
{
//当前数组第一个元素的Cursor存的值，就是要返回的第一个备用空闲的下标
int i = space[0].cur;
if (space[0].cur != 0)
{
//由于要拿出一个分量来使用了,所以我们就得把它的下一个分量用来做备用
space[0].cur = space[i].cur;
}
return i;
}
/// <summary>
/// 将下标为k的空闲结点回收到备用链表
/// </summary>
/// <param name="space"></param>
/// <param name="k"></param>
void Free_SSL(int k)
{
//把第一个元素的cur值赋给要删除的分量cur
space[k].cur= space[0].cur;
//把要删除的分量下标赋值给第一个元素的cur
space[0].cur = k;
}
/// <summary>
/// 初始条件：静态链表已存在。操作结果：返回L中数据元素个数
/// </summary>
/// <returns></returns>
public int ListLength()
{
int j = 0;
int i = space[maxSize - 1].cur;
while (i!=0)
{
i = space[i].cur;
j++;
}
return j;
}
/// <summary>
/// 在第i个元素之前插入新的数据元素e
/// </summary>
/// <param name="i"></param>
/// <param name="e"></param>
/// <returns></returns>
public void ListInsert(int i, T e)
{
int j, k, l;
//注意k首先是最后一个元素的下标
k = maxSize - 1;
if (i < 1 || i >space.Length + 1)
{
throw new MyException(i + "超出静态链表元素存储范围1-" + (space.Length + 1));
}
//获得空闲分量的下标
j = Malloc_SLL();
if (j!=0)
{
//将数据赋值给此分量的data
space[j].data= e;
//找到第i个元素之前的位置
for (l = 1; l <= i - 1; l++)
k = space[k].cur;
//把第i个元素之前的cur赋值给新元素的cur
space[j].cur = space[k].cur;
//把新元素的下标赋值给第i个元素之前元素的cur
space[k].cur = j;
}else
throw new MyException("备用空间链表为空");
}
/// <summary>
/// 删除在L中第i个数据元素
/// </summary>
/// <param name="i"></param>
/// <returns></returns>
public void ListDelete(int i)
{
int j, k;
if (i < 1 || i > ListLength())
throw new MyException(i + "超出静态链表已存储元素的个数范围1-" + (space.Length + 1));
k = maxSize - 1;
for (j = 1; j <= i - 1; j++)
k = space[k].cur;
j = space[k].cur;
space[k].cur = space[j].cur;
Free_SSL(j);
}
}
}
原版
#include "string.h"
#include "ctype.h"
#include "stdio.h"
#include "stdlib.h"
#include "io.h"
#include "math.h"
#include "time.h"
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 1000 /* 存储空间初始分配量 */
typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef char ElemType; /* ElemType类型根据实际情况而定，这里假设为char */
Status visit(ElemType c)
{
printf("%c ",c);
return OK;
}
/* 线性表的静态链表存储结构 */
typedef struct
{
ElemType data;
int cur; /* 游标(Cursor) ，为0时表示无指向 */
} Component,StaticLinkList[MAXSIZE];
/* 将一维数组space中各分量链成一个备用链表，space[0].cur为头指针，"0"表示空指针 */
Status InitList(StaticLinkList space)
{
int i;
for (i=0; i<MAXSIZE-1; i++)
space[i].cur = i+1;
space[MAXSIZE-1].cur = 0; /* 目前静态链表为空，最后一个元素的cur为0 */
return OK;
}
/* 若备用空间链表非空，则返回分配的结点下标，否则返回0 */
int Malloc_SSL(StaticLinkList space)
{
int i = space[0].cur; /* 当前数组第一个元素的cur存的值 */
/* 就是要返回的第一个备用空闲的下标 */
if (space[0]. cur)
space[0]. cur = space[i].cur; /* 由于要拿出一个分量来使用了， */
/* 所以我们就得把它的下一个 */
/* 分量用来做备用 */
return i;
}
/* 将下标为k的空闲结点回收到备用链表 */
void Free_SSL(StaticLinkList space, int k)
{
space[k].cur = space[0].cur; /* 把第一个元素的cur值赋给要删除的分量cur */
space[0].cur = k; /* 把要删除的分量下标赋值给第一个元素的cur */
}
/* 初始条件：静态链表L已存在。操作结果：返回L中数据元素个数 */
int ListLength(StaticLinkList L)
{
int j=0;
int i=L[MAXSIZE-1].cur;
while(i)
{
i=L[i].cur;
j++;
}
return j;
}
/* 在L中第i个元素之前插入新的数据元素e */
Status ListInsert(StaticLinkList L, int i, ElemType e)
{
int j, k, l;
k = MAXSIZE - 1; /* 注意k首先是最后一个元素的下标 */
if (i < 1 || i > ListLength(L) + 1)
return ERROR;
j = Malloc_SSL(L); /* 获得空闲分量的下标 */
if (j)
{
L[j].data = e; /* 将数据赋值给此分量的data */
for(l = 1; l <= i - 1; l++) /* 找到第i个元素之前的位置 */
k = L[k].cur;
L[j].cur = L[k].cur; /* 把第i个元素之前的cur赋值给新元素的cur */
L[k].cur = j; /* 把新元素的下标赋值给第i个元素之前元素的ur */
return OK;
}
return ERROR;
}
/* 删除在L中第i个数据元素 */
Status ListDelete(StaticLinkList L, int i)
{
int j, k;
if (i < 1 || i > ListLength(L))
return ERROR;
k = MAXSIZE - 1;
for (j = 1; j <= i - 1; j++)
k = L[k].cur;
j = L[k].cur;
L[k].cur = L[j].cur;
Free_SSL(L, j);
return OK;
}
Status ListTraverse(StaticLinkList L)
{
int j=0;
int i=L[MAXSIZE-1].cur;
while(i)
{
visit(L[i].data);
i=L[i].cur;
j++;
}
return j;
printf("\n");
return OK;
}
int main()
{
StaticLinkList L;
Status i;
i=InitList(L);
printf("初始化L后：L.length=%d\n",ListLength(L));
i=ListInsert(L,1,'F');
i=ListInsert(L,1,'E');
i=ListInsert(L,1,'D');
i=ListInsert(L,1,'B');
i=ListInsert(L,1,'A');
printf("\n在L的表头依次插入FEDBA后：\nL.data=");
ListTraverse(L);
i=ListInsert(L,3,'C');
printf("\n在L的“B”与“D”之间插入“C”后：\nL.data=");
ListTraverse(L);
i=ListDelete(L,1);
printf("\n在L的删除“A”后：\nL.data=");
ListTraverse(L);
printf("\n");
return 0;
}
3815
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
