数据结构：线性表-顺序

#线性表的基本概念：

##线性表的定义: 线性表是n个数据特性相同的元素的组成有限序列，

##线性表的操作：创建，销毁，清空，元素插入，元素删除，获取某位置的元素，长度。

除了第一个元素a1外，每一个元素有且只有一个直接前驱元素，除最后一个元素an外，每一个元素有且只有一个直接后继元素。数据元素之间的关系是一对一的关系。

#ifndef _MY_LIST_H
#define _MY_LIST_H

typedef void List;
typedef void ListNode;

//create list
List* list_Create();

//
void List_Destroy(List *list);

//
void List_Clear(List* list);

//
int List_length(List* list);

//
int List_Insert(List* list, ListNode* node, int pos);

//
ListNode* List_Get(List* list, int pos);

//
ListNode* List_Delete(List* list, int pos);

#endif

#线性表的顺序存储结构:

##基本概念

概念：用一组地址连续的存储单元依次存储线性表的数据元素，这种存储结构的线性表称为顺序表。

特点：逻辑上相邻的数据元素，物理次序也是相邻的。

##设计与实现

创建：

typedef void SeqList;
typedef void SeqListNode;

//结构体中套指针，数组的大小有用户确定
typedef struct _tag_SeqList
{
   int length;
   int capacity;
   unsigned int *node;
}TSeqList;

SeqList* SeqList_Create(int capacity)
{
   TSeqList *tmp = NULL:
   tmp = (TSeqList *)malloc(sizeof(TSeqList));
   if(tmp == NULL)
   {
      return NULL;
   }
   memset(tmp, 0, sizeof(TSeqList));

   tmp->node = (unsigned int *)malloc((sizeof(unsigned int *))*capacity);
   if(tmp->node = NULL)
   {
    return NULL;
   }
   tmp->capacity = capacity;
   tmp->length = 0;
   return tmp;     
}

销毁：

void SeqList_Destroy(SeqList *list)
{
  TSeqList *tList = NULL:
  if(list == NULL)
    return ;
  tList = (TSeqList *)list;
  if(tList->node != NULL)
  {
     free(tList->node);
  }
  free(tList);
}

清空：

void SeqList_Clear(SeqList* list);
{
   TSeqList *tList = NULL:
   if(list == NULL)
      return;
   tList = (TSeqList *)list;
   tList->length = 0;    
}

插入：

//插入：元素移动， 在位置上插入。
int SeqList_Insert(SeqList* list, SeqListNode* node, int pos)
{
   TSeqList *tList = NULL:
   if(list == NULL || node == NULL || pos < 0)
   {
      return -1;
   }
   tList = (TSeqList *)list;

   // 判断是否存满了
   if(tList->length >= tList->capacity)
      return -2;

   // 容错修正， 链表容量是20， 长度为6， 用户想在10的位置插入
   if(pos >= tList->length)
       pos = tList->length;

   for(int i = list->length ; i > pos ; i--)
   {
       tList->node[i] = tList->node[i-1];
    }
    tList->node[pos] = (unsigned int)node;
    tList->length++;
    return 0;
}

删除指定位置：


SeqListNode* SeqList_Delete(SeqList* list, int pos)
{
   TSeqList *tList = NULL:
   SeqListNode *ret = NULL;
   if(list == NULL || pos < 0)
   {
      return NULL;
   }
   tList = (TSeqList *)list;
   
   ret = (SeqListNode *)tList->node[pos];

   for(int i=pos+1; i<tList->length; i++)
   {
      tList->node[i-1] = tList->node[i];
   }
   tList->length--;

 return ret;
}

长度：

//
int SeqList_length(SeqList* list)
{
   TSeqList *tList = NULL:
   if(list == NULL)
      return -1;
   tList = (TSeqList *)list;
   return tList->capacity;   
}

获取指定位置

//
SeqListNode* SeqList_Get(SeqList* list, int pos)
{
   TSeqList *tList = NULL:
   SeqListNode *ret = NULL;
   if(list == NULL || pos < 0)
   {
      return NULL;
   }
   tList = (TSeqList *)list;
   
   ret = (SeqListNode *)tList->node[pos];
 
   return ret;
}

##优缺点

无需为线性表中的逻辑关系添加额外的空间，可以快速的获取表中合法位置元素

插入和删除操作需要移动大量的元素，当线性表长度变化较大时，难以确定存储空间的容量。

数据结构：线性表-顺序

#线性表的基本概念：

#线性表的顺序存储结构:

猜你喜欢