数据结构之顺序表

 

1，什么是线性结构？

线性结构是一个有序数据元素的集合。

2，线性结构中都包含什么内容？

常用的线性结构有：线性表，栈，队列，双队列，数组，串。

3，什么是顺序表？顺序表的分类？

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组 上完成数据的增删查改

顺序表一般可以分为：
1. 静态顺序表：使用定长数组存储。 2. 动态顺序表：使用动态开辟的数组存储。
 

4. 完成动态顺序表的以下操作

// 动态的顺序表 
typedef int DataType; 
typedef struct SeqList 
{ 
DataType* _array; 
int _capacity; // 顺序表的总大小 
int _size; // 顺序表中有效元素的个数 
}SeqList, *PSeq; 

//typedef struct SeqList SeqList; 
//typedef struct SeqList* PSeqList; 

// 顺序表的初始化 
void SeqListInit(PSeq ps, int capacity); 
{
 ps->_array = (DataType*)malloc(sizeof(DataTyple)*capacity);
   if(NULL == ps->_array)
 {
   assert(0);
   return;
 }
  ps->_capacity = capacity;
  ps->_size = 0;
}

// 在顺序表的尾部插入值为data的元素 
void SeqListPushBack(PSeq ps, DataType data); 
{
#if 0
  assert(ps);
  ps->_array[ps->_size] = data;
  ps->_size++;
#endif
 SeqListInsert(ps,ps->_size,data);
 
}
// 删除顺序表最后一个元素 
void SeqListPopBack(PSeq ps); 
{
#if 0
assert(ps);
if (SeqListEmpty(ps))
  return;

  ps->_size--;
#endif

	SeqListErase(ps, ps->_size - 1);
}
// 在顺序表的头部插入值为data的元素 
void SeqListPushFront(PSeq ps, DataType data); 
{
 #if 0;
  assert(ps);
//将顺序表中所有元素统一向后搬移一个位置
 for(int i = ps->_size-1; i >= 0; i--)
{
 ps->_array[i+1] = ps->_array[i];
}
  //插入元素
 ps->_array[0] = data;
 ps->_size++;
#endif
  SeqListInsert(ps, 0, data);
 }
// 删除顺序表头部的元素 
void SeqListPopFront(PSeq ps); 
{
#if 0
  if(SeqListEmpty(ps))
  return;
  for(int i = 1; i < ps->_size; ++i )
  ps->_array[i-1] = ps->_array[i];
  ps->_size--;
#endif
  SeqListerase(ps,0);
}

// 在顺序表pos位置插入值为data的元素 
void SeqListInsert(PSeq ps, int pos, DataType data); 
{
assert(0);
if(pos<0||pos>ps->_size)
  return;
 CheckCapacity(ps);
 for(int i=ps->_size-1;i>=pos;i--)
 ps->_array[i+1] = ps->_array[i];
 ps->_array[pos] =data;
 ps->_size++;
}
// 删除顺序表中pos位置上的元素 
void SeqListErase(PSeq ps, int pos);
{
 assert(0);
 if(pos<0||pos>=ps->_size)
         return;
 for(int i=pos+1;i< ps->_size;++i)
  ps->_array[i-1] = ps->_array[i];
  ps->_size--;
} 

// 在顺序表中查找值为data的元素，找到返回该元素在顺序表中的下标，否则返回-1 
int SeqListFind(PSeq ps, DataType data); 
{
assert(0);
for(int i=0; i<ps->_size;i++)
{
 if(ps->_array[i] == data;)
  return i;
}
  return -1;
}
// 检测顺序表是否为空，如果为空返回非0值，非空返回0 
int SeqListEmpty(PSeq ps); 
{
assert (ps);
 return 0 == ps->_size;
}

// 返回顺序表中有效元素的个数 
int SeqListSize(PSeq ps);
{
 assert(ps);
 return ps->_size;
} 

// 返回顺序表的容量大小 
int SeqListCapacity(PSeq ps); 
{
 assert(ps);
 return ps ->_capacity;
}
// 将顺序表中的元素清空 
void SeqListClear(PSeq ps); 
{
    assert(ps);
  ps->——size = 0;
}

// 删除顺序表中第一个值为data的元素 
void SeqListRemove(PSeq ps, DataType data); 
{  
SeqListErase(ps, SeqListFind(ps,data));
}

// 销毁顺序表 
void SeqListDestroy(PSeq ps); 
{
 if(ps->_array)
{
 free(ps->_array);
 ps->_array = NULL;
 ps->_capacity = 0;
 ps->_size = 0；
}
}
// 顺序表的扩容 
void CheckCapacity(PSeq ps); 
{
 assert(ps);
 if(ps->——size == ps->_capacity)
{
 // 顺序表中已经没有空间了
 int newCapacity = ps->_capacity *2;
 int * pTemp = (DataType*)malloc(newCapacity*sizeof(DataType))
 if(NULL == pTemp)
{
 assert(0);
 return;
}
 for(int i=0; i < ps->_size; ++i)
 pTemp[i] = ps ->_array[i];
free(ps->_array);  //释放旧空间
ps->_array = pTemp;
ps->_capacity = newCapacity;
}
}

.h

#pragma once

typedef int SDataType;

// 链表的节点
typedef struct SListNode
{
	SDataType _data;
	struct  SListNode* _pNext;
}Node, *PNode;

// Node n; n._data = 10;  (&n)->_data = 200
// Node* p = &n;   p->_data = 100;  (*p)._data = 200;

typedef struct SList
{
	PNode _pHead;   // 指向链表中的第一个节点
}SList, *PSList;


void SListInit(SList* s);
void SListPushBack(SList* s, SDataType data);
void SListPopBack(SList* s);
void SListPushFront(SList* s, SDataType data);
void SListPopFront(SList* s);
void SListInsert(PNode pos, SDataType data);
void SListErase(SList* s, PNode pos);
PNode SListFind(SList* s, SDataType data);
int SListSize(SList* s);
int SListEmpty(SList* s);
void SListRemove(SList* s, SDataType data);
void SListRemoveAll(SList* s, SDataType data);



void TestSList();