线性表的基本操作

使用C语言实现线性表

线性表是最常用且最简单的一种数据结构。一个线性表是n个数据元素的有限序列，序列中的每个数据元素，可以是一个数字，可以是一个字符，也可以是复杂的结构体或对象。例如：1,2,3,4,5是一个线性表，A,B,C,D...Z是一个线性表，一列列车的车厢1，车厢2...车厢n是一个线性表。

线性表的机内表示法(又称存储结构)有2种，一种是顺序存储结构，另一种是链式存储结构。

顺序存储结构，顾名思义就是按顺序来存储的一种存储结构，比如线性表(1,2,3,4,5)，共计5个元素，
每个int型的数据元素假设占用4个存储单元，假设第1个元素数字1的存储地址是1000，则第2个元素数字2的存储地址是1004，第3个元素数字3的存储地址是1008，依此类推，第n个数据元素的存储地址是LOC(an) = LOC(a1)+(n-1)k.(k表示每个数据元素占用的存储单元的长度)
显而易见，这种存储结构，相邻元素在物理位置上也相邻。
通常，我们把采用这种存储结构的线性表称为“顺序表”。

链式存储结构，它不要求相邻的元素在物理位置上也相邻，所以它可用一组处在任意位置的存储单元来存储线性表的数据元素。既然这样，那应该怎样表示数据元素之间的逻辑关系呢？
为了表示数据元素之间的逻辑关系，对于数据元素a1来说，除了存储其自身的信息之外，还需要存储一个指示其直接后继的信息，所以我们引入指针的概念：称存储数据元素信息的域称为数据域，而存储直接后继地址信息的域称为指针域。
我们形象地称这种即包含自身数据信息，又包含其直接后继地址信息的数据元素为“结点”。
显而易见，这种存储结构，相邻元素在物理位置上不一定相邻，他们之间用指针来表示逻辑关系。
通常，我们把采用这种存储结构的线性表称为“线性链表”。

有了基本的概念之后，我们就可以使用编程语言进行描述，使用C、C++、C#、Java等都可以，这篇文章我使用C语言描述。

一、顺序表

为了描述顺序表，我们首先要声明一个结构，如下：

1 2 3 4 5 6 7 8

#define LIST_INIT_SIZE 100 //线性表存储空间的初始分配量 #define LISTINCREMENT 10   //线性表存储空间的分配增量(当存储空间不够时要用到) typedef  int  ElemType;       //数据元素的类型，假设是int型的 typedef  struct {      ElemType *elem;        //存储空间的基地址      int  length;       //当前线性表的长度      int  listsize;     //当前分配的存储容量 }SqList;

定义好线性表后，就可以对它进行操作了，常见的线性表的基本操作有：创建线性表、查找元素、插入元素、删除元素、清空、归并等。

线性表的基本操作在顺序表中的实现：
1.创建线性表

1 2 3 4 5 6 7 8 9 10 11 12

int  InitList(SqList &L) {      L.elem = (ElemType *) malloc (LIST_INIT_SIZE *  sizeof (ElemType)); //开辟一个存储空间，并把这块存储空间的基地址赋值给elem      if  (!L.elem)      {          return  -1;  //空间分配失败      }            L.length = 0;  //当前长度      L.listsize = LIST_INIT_SIZE;  //当前分配量      return  0; }

2.查找元素(按值查找)
线性表的按值查找是指在线性表中查找与给定值x相等的数据元素。完成该操作最简单的方法是从第一个元素a1开始依次和x比较，若相等，则返回该元素的下标。
若查遍整个表都没有找到与x相等的元素，则返回-1。
时间复杂度：算法的基本操作(比较x与L中第i<1,n>个元素)与元素x在表中的位置有关，也与表长有关。当a1=x时，比较1次成功，当an=x时，比较n次成功，平均比较次数为n+1/2，时间复杂度为O(n)。

1 2 3 4 5 6 7 8 9 10 11 12

int  LocateElem(SqList L, ElemType x) {      int  pos = -1;      for  ( int  i = 0; i < L.length; i++)      {          if  (L.elem[i] == x)          {              pos = i;          }      }      return  pos; }

3.插入元素
时间复杂度O(L.length)即O(n)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

int  ListInsert(SqList &L,  int  i, ElemType e) {      //判断插入位置的合法性      if  (i<1 || i>L.length+1)  return  -1;      //判断存储空间是否够用      if  (L.length >= L.listsize)      {          ElemType *newbase = (ElemType *) realloc (L.elem, (L.listsize + LISTINCREMENT)* sizeof (ElemType));          if  (!newbase)  return  -1; //存储空间分配失败          L.elem = newbase; //新基址          L.listsize += LISTINCREMENT; //增加存储容量      }      //插入操作      ElemType *q, *p;  //定义2个指针变量      q = &(L.elem[i-1]);  //q为插入位置(注意形参i是序号，序号是从从1开始的，而下标是从0开始的，因此这里转成下标后是i-1)      for  (p = &(L.elem[L.length - 1]); p >= q; --p)  //从ai到an-1依次后移，注意后移操作要从后往前进行      {          *(p + 1) = *p;      }      *q = e;      ++L.length; //表长加1      return  0; }

4.删除元素
时间复杂度O(L.length)即O(n)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

int  ListDelete(SqList &L,  int  i, ElemType &e) {      //判断删除位置的合法性      if  (i<1 || i>L.length)  return  -1;      //删除操作      ElemType *q, *p; //定义2个指针变量      p = &(L.elem[i - 1]); //p为被删除元素的位置(注意形参i是序号，序号是从从1开始的，而下标是从0开始的，因此这里转成下标后是i-1)      e = *p;  //被删除的元素赋值给e(可能用不到，也可能用到，所以保存给e吧)      q = L.elem + L.length - 1; //q指向表尾最后一个元素(q是最后一个元素的地址)      for  (++p; p <= q; ++p)  //从p的下一个元素开始依次前移      {          *(p - 1) = *p;      }            --L.length; //表长减1      return  0; }

测试代码如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

int  main() {      SqList list;      InitList(list);        int  n = 10;            //添加10个数字给线性表list      for  ( int  i = 0; i < 10; i++)      {          ListInsert(list, i+1, i+1);      }      //删除第5个      ElemType e;      ListDelete(list, 5, e);      printf ( "删除的元素是：%d\n" , e);        //在第2个位置插入一个元素-1      ListInsert(list, 2, -1);            //输出线性表      for  ( int  i = 0; i < 10; i++)      {          printf ( "%d " , list.elem[i]);      }      //输出结果是：1 -1 2 3 4 6 7 8 9 10        system ( "pause" ); }

二、线性链表

为了描述线性链表，我们首先要声明一个结构，如下：

1 2 3 4

typedef  struct  LNode{      ElemType data;  //数据域      struct  LNode *next; //指针域 }LNode;

定义好线性链表后，就可以对它进行操作了，常见的线性链表的基本操作有：查找、插入、删除、清空等。
线性表的基本操作在线性链表中的实现：
1.1创建链表(头插法) 时间复杂度O(n)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

LNode * CreateListHead( int  n) {      LNode *L;      L = (LNode *) malloc ( sizeof (LNode));      L->next = NULL;      LNode *p; //p为新结点，指向最后一个元素      for  ( int  i = n; i > 0; --i)      {          p = (LNode *) malloc ( sizeof (LNode)); //为新结点开辟空间          scanf ( "%d" ,&p->data);          p->next = L->next;          L->next = p;      }      return  L; }

1.2创建链表(尾插法)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

LNode * CreateListTail() {      LNode *L;      L = (LNode *) malloc ( sizeof (LNode));      L->next = NULL; //空表      LNode *s, *r = L; //r是尾指针 s是新结点      int  x;      scanf ( "%d" , &x);      int  flag = 0; //结束标记      while  (x != flag)      {          s = (LNode *) malloc ( sizeof (LNode));          s->data = x;          r->next = s;          r = s;          scanf ( "%d" , &x);      }      r->next = NULL; //最后一个元素next域指向NULL      return  L; }

2.查找元素(取第i个元素)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

int  GetElem(LNode L,  int  i, ElemType &e) {      LNode *head,*p; //head是头指针，p为查找下标      head = &L;      p = head; //p的初值指向第1个元素      int  j = 0;      while  (p !=NULL && j<i)      {          p = p->next;          j++;      }      if  (p == NULL || j>i)  return  -1;  //第i个元素不存在      e = p->data;      return  0; }

3.插入元素
在链表中插入结点，只需要修改指针。
若要在第i个结点之前插入元素，则首先需要找到第i-1个结点，然后修改第i-1个结点的指针。
时间复杂度O(n)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

int  ListInsert(LNode *L,  int  i, ElemType e) {      LNode *p; //设p为第i-1个结点      //首先要找到第i-1个结点      int  j = 0;      p = L;      while  (p != NULL && j < i-1)      {          p = p->next;          j++;      }      //申请一个新结点      LNode *s = (LNode *) malloc ( sizeof (LNode));      s->data = e;        s->next = p->next;  //s的直接后继指向p原来的直接后继      p->next = s;  //p的直接后继指向s        return  0; }

4.删除元素
若要删除第i个结点，则只需要修改第i-1个结点的指针指向第i+1个即可
时间复杂度O(L.length)即O(n)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

int  ListDelete(LNode *L,  int  i, ElemType &e) {      LNode *p,*q; //设p为第i-1个结点 q标示删除位置      //首先要找到第i-1个结点      int  j = 0;      p = L; //p为L的基地址      while  (p != NULL && j < i-1)      {          p = p->next;          j++;      }      q = p->next;      p->next = q->next; //p的next域指向p->next->next        e = q->data;      return  0; }

测试代码如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

int  main() {      LNode *L;      L = CreateListTail(); //创建一个线性链表，输入0结束      ListInsert(L, 1, 100); //在第1个位置插入100      ElemType e; //待删除的元素      ListDelete(L, 3, e); //删除第3个元素      LNode *p;      p = L;            printf ( "输出线性链表：\n" );      while  (p->next != NULL)      {          p = p->next;          printf ( "%d " , p->data);      }        system ( "pause" ); }