数据结构：动态顺序表，顺序表与单链表的比较

SepListD.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef int DataType;
typedef struct SeqListD
{
DataType* _pData;//数据块指针
int _size;//有效数据个数
int _capacity;//动态容量
}SeqListD,*PSeqListD;

size_t它是一种“整型”类型，里面保存的是一个整数，就像int, long那样。这种整数用来记录一个大小(size)。size_t的全称应该是size type，就是说“一种用来记录大小的数据类型”。
通常我们用sizeof(XXX)操作，这个操作所得到的结果就是size_t类型。
因为size_t类型的数据其实是保存了一个整数

test.h

#include"SeqListD.h"
//顺序表的初始化
void SeqListDInit(PSeqListD pSeq,int capacity)
{
    pSeq->_pData = (DataType*)malloc(capacity * sizeof(DataType));
	if (pSeq->_pData == NULL)
    {
        printf("空间申请失败\n");
        return;
    }
	pSeq->_capacity = capacity;
    pSeq->_size = 0;
}

//动态增容
void CheckCapacity(PSeqListD pSeq)
{
   assert(pSeq);
   pSeq->_pData = (DataType*)realloc(pSeq->_pData,sizeof(DataType)* pSeq->_capacity*2);
   }

//尾插
void SeqListDPushBack(PSeqListD pSeq,int data)
{
   assert(pSeq);
   if(pSeq->_size >= pSeq->_capacity)
   {
        CheckCapacity(pSeq);
   }
   pSeq->_pData[pSeq->_size] = data;
   pSeq->_size++;
}

//尾删
void SepListPopBack(PSeqListD pSeq)
{
   assert(pSeq);
   pSeq->_size--;
}

//判断是否为空，为空返回true，否则返回false
int SeqListDEmpty(PSeqListD pSeq)
{
    assert(pSeq);
    return (0 == pSeq->_size);
}

//获取有效数字的个数
int SeqListDSize(PSeqListD pSeq)
{
   assert(pSeq);
   return pSeq->_size;
}

//获取容量
int SeqListDCapacity(PSeqListD pSeq)
{
   assert(pSeq);
   return pSeq->_capacity;
}

//清空顺序表中的所有元素
void SeqListDClear(PSeqListD pSeq)
{
   assert(pSeq);
   pSeq->_size = 0;
}

//销毁顺序表
void SeqListDDestroy(PSeqListD pSeq)
{
   assert(pSeq);
   pSeq->_size = 0;
   pSeq->_capacity = 0;
   free(pSeq->_pData);
}

//顺序表任意位置插入元素
void SeqListDInsert(PSeqListD pSeq,int pos ,int data)
{
   int i = 0;
   assert(pSeq);
   pSeq->_size++;
   if(pSeq->_size >= pSeq->_capacity)
   {
   CheckCapacity(pSeq);
   }
   for(i=pSeq->_size ;i>=pos;i--)
   {
	pSeq->_pData[i + 1] =pSeq->_pData[i];
   }
    pSeq->_pData[pos] =data;
}

//顺序表任意位置删除元素
void SeqListDErase(PSeqListD pSeq,int pos ,int data)
{
   int i = 0;
   assert(pSeq);
   if(pSeq->_size>0)
   {
   for(i=pos;i<pSeq->_size - 1;i++)
   {
   pSeq->_pData[i] =pSeq->_pData[i + 1];
   }
   }
}
//打印顺序表
void SeqListDPrint(PSeqListD pSeq)
{ 
   int i = 0;
   assert(pSeq);
	   for(i=0;i<pSeq->_size;i++)
	   {
		   printf("%d", pSeq->_pData[i]);
	   }
	   printf("\n");
}
int main()
{
	SeqListD PSListD;


	SeqListDInit(&PSListD,5);
	printf("顺序表的容量大小是: %d\n", SeqListDCapacity(&PSListD));
    
	SeqListDPushBack(&PSListD,0);
    SeqListDPushBack(&PSListD,1);
	SeqListDPushBack(&PSListD,2);
	SeqListDPushBack(&PSListD,3);
    SeqListDPushBack(&PSListD,4);
	printf("尾插后的顺序表： ");
	SeqListDPrint(&PSListD);

	SepListPopBack(&PSListD);
	printf("尾删后的顺序表： ");
	SeqListDPrint(&PSListD);

    printf("任意位置插入之后的顺序表： ");
	SeqListDInsert(&PSListD ,3,9);
    SeqListDPrint(&PSListD);

	SeqListDErase(&PSListD,3,9);
	printf("任意位置删除之后的顺序表：");
	SeqListDPrint(&PSListD);

	SeqListDClear(&PSListD);
	printf("销毁后的顺序表的容量为：%d ",SeqListDSize(&PSListD));
	SeqListDPrint(&PSListD);

return 0;
}

 

线性表：

从数据在物理内存上的存储形式线性表可以分为：

顺序表和链表

顺序表:

用一段地址连续的储存单元依次储存元素的线性结构。

地址空间连续：一般情况采用数组，但是数组分为静态数组和动态数组

所以顺序表分为静态顺序表和动态顺序表

链表：

一种链式储存的线性表，用一组地址任意的储存单元放线性表的元素，成储存单元为一个节点

链表分类：

1. 单链表（带头节点和不带头结点）
2. 双链表（带头节点和不带头结点）
3. 双向循环链表（带头节点和不带头结点）

链表和顺序表的比较：

1. 顺序表支持随机访问，单链表不行
2. 顺序表的插入删除效率很低，时间复杂度为O（n）（除了尾插尾删），单链表的插入删除效率很高O(1)
3. 顺序表比单链表的CPU高速缓存效率更高