数据结构之顺序表

数据结构：数据与数据之间的组织形式
=== > 怎么存数据

线性表

线性表：除去头尾，中间元素有且只有一个前继，有且只有一个后继

根据存储空间的分布：
1、 顺序表： 存储的内存空间连续
2、 链表： 存储的内存空间不连续

顺序表

思维导图

内存结构

C程序实现

• 头文件

#ifndef  _SEQ_H_
#define  _SEQ_H_

#define  INIT_SIZE  10
#define  ADD_SIZE   5

typedef int Data;

typedef enum {TRUE,FALSE,ERROR} Bool;

typedef struct _seq
{
	Data *pData;  	       //顺序表的存储空间
	Data  maxsize ;        //顺序表最大存储空间
	Data  current_size ;   // 当前使用空间
}Seq;


//创建顺序表
Seq* Creat ();

//摧毁顺序表
void destroy(Seq*s);


// 为顺序表重新分配空间
Bool AgainMalloc(Seq*s);

// 插入数据：尾插
// s：要插入的顺序表
// data：要插入的数据
// 返回值：成功返回 TRUE，失败返回FALSE，其他返回ERROR
Bool Insert_Last(Seq* s, Data data);

// 插入数据：头插
// s：要插入的顺序表
// data：要插入的数据
// 返回值：成功返回 TRUE，失败返回FALSE，其他返回ERROR
Bool Insert_Head(Seq* s, Data data);


// 插入数据：根据位置插入数据
// s    ：要插入的顺序表
// index: 要插入位置的下标
// data ：要插入的数据
// 返回值：成功返回 TRUE，失败返回FALSE，其他返回ERROR
Bool Insert_Pos(Seq* s, int index, Data data);

// 插入数据：根据位置删除数据
// s    ：要删除的顺序表
// index: 要删除位置的下标
// 返回值：成功返回 TRUE，失败返回FALSE，其他返回ERROR
Bool Delete_Pos(Seq* s, int index);

//打印
void Display(Seq*s);

#endif  // _SEQ_H_

• 源文件

#include <stdlib.h>
#include <stdio.h>
#include "seq.h"
//#include  "assert.h"


Seq* Creat ()
{
	
	Seq *s =(Seq*)malloc(sizeof(Seq)/sizeof(char));
	if(NULL == s)
	{
		
		return NULL;
	}
	
	s->pData = (Data*)malloc(sizeof(Data)/sizeof(char)*INIT_SIZE);
	if(NULL == s->pData)
	{
		free(s);
		return NULL ;
	}
	
	s->maxsize      = INIT_SIZE;
	s->current_size = 0;
	
	return s;	
}


void destroy(Seq*s)
{
	if(NULL == s)
		return ;
	
	free(s->pData);
	free(s);
}


// 为顺序表重新分配空间
Bool AgainMalloc(Seq*s)
{
	if(NULL == s)
	{
		return ERROR;
	}
	Data newsize = sizeof(Data)/sizeof(char)*(s->maxsize + ADD_SIZE);
	
	Data* p = (Data*)realloc(s->pData,newsize);
	if(NULL == p)
	{
		return FALSE;
	}
	s->pData    = p;
	s->maxsize += ADD_SIZE ;
	
	return TRUE;	
}

//插入数据
Bool Insert_last(Seq*s,Data data)
{
	//
	if(NULL == s)
		return ERROR;
	
	
	if(s->current_size == s->maxsize )
	{
		if(AgainMalloc(s) != TRUE)
			return FALSE;		
	}
	
	s->pData[s->current_size++] = data;
	
	
	return TRUE;
	
}

Bool Insert_Head(Seq* s, Data data)
{
	if(NULL == s)
		return ERROR;
	
	if(s->current_size == s-> maxsize)
		if(AgainMalloc(s) != TRUE)
			return FALSE;
	
	int i;
	for(i = s->current_size;i>0;i--)
	{
		s->pData[i] = s->pData[i-1];
	}
	s->pData[0] = data ;
	s->current_size++;
	
	return TRUE;
}

Bool Insert_Pos(Seq* s, int index, Data data)
{
	
 	if(NULL == s || index<0 || index > s->current_size )
		return ERROR;
	
	if(s->current_size == s->maxsize )
	{
		if(AgainMalloc(s) != TRUE)
			return FALSE;		
	}
	
	int i;
	for(i = s->current_size; i>index;  i--)
	{
		s->pData[i] = s->pData[i-1];
	}
	s->pData[index] = data;
	s->current_size++;	
	
	return TRUE;	
}

Bool Delete_Pos(Seq* s, int index)
{
	if(NULL == s || index<0 || index >= s->current_size )
		return ERROR;
	
	
	int i;
	for(i=index;i<s->current_size-1;i++)
	{
		s->pData[i] = s->pData[i+1];
	}
	
	s->current_size--;
	
	return TRUE;
}

void Display(Seq*s)
{
	if(NULL == s)
		return ;
	
	
	int i;
	for(i = 0;i< s->current_size;i++)
	{
		printf("%-4d",s->pData[i]);
	}
	printf("\n");
}

• 测试文件

#include <stdio.h>
#include "seq.h"



int main()
{
	
	Seq*s = Creat();
	if(NULL == s)
	{
		printf("创建失败\n");
	}
	else 
	{
		printf("创建成功\n");
	}
	

	
 	int i;
	for(i=0;i<20;i++)
	{
		Insert_last(s,i);
		
	} 
	Display(s);
	
	Insert_Head(s,520);
	Display(s);
		
	Insert_Pos(s,5,200);
	Display(s);
	
	Insert_Pos(s,2,15);
	Display(s);
	
	printf("***************************\n");
	Delete_Pos(s,5);
	Display(s);
	
	destroy(s);
	return 0;
}