数据结构之顺序表（创建、使用、销毁）

顺序表是在计算机内存中采用顺序存储的方式存储的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。顺序表的物理结构和逻辑结构都是连续的。顺序表的增删操作麻烦，需要移动的元素可能很多，修改和查找操作方便，通过下标访问，访问速度快。

下面，我将实现顺序表的创建、使用和删除。（包含头文件与源文件）

头文件：SeqList.h

#ifndef __SEQLIST_H__

#define __SEQLIST_H__
#define INIT_SIZE 10
#define INCRESS_SIZE 20
#define FALSE 0
#define TRUE  1

typedef int SeqData;
// 顺序表结构
typedef struct _SeqList
{
	SeqData * list;         // 指向存储空间的指针
	SeqData max_len;       // 保存存储空间最大长度
	SeqData len;         // 保存当前使用的长度
}SeqList;

// 创建顺序表
SeqList *Create_List();

// 销毁顺序表
void Destory(SeqList *s);

// 插入数据：尾插法
int Insert_Last(SeqList *s,SeqData data);

// 插入数据：头插法
int Insert_Head(SeqList *s,SeqData data);

// 插入数据：在下标为 pos 的位置插入数据
int Insert_Pos(SeqList *s,int pos,SeqData data);

//获得下标pos的元素的值
int GetData(SeqList *s,int pos,SeqData *x);

// 查找元素，如果找到，将该元素的下标给x
int FindData(SeqList *s, SeqData data, SeqData *x);

// 删除 pos 下标的元素
int Delete_Pos(SeqList *s, int pos);

// 删除指定数据
int Delete_Data(SeqList *s, SeqData data);

//修改顺序表中所有值为data1的元素的值为data2
int Update_Data(SeqList *s,SeqData data1,SeqData data2);

//修改顺序表中下标为pos的元素的值为data
int Update_Pos(SeqList *s,int pos,SeqData data);

// 逆序顺序表
int Reverse_List(SeqList *s);

//将一张顺序表排序
int Order_List(SeqList *s);

//合并两张顺序表，合并后的表要求是从小到大排列的，函数返回新表的指针
SeqList * Merge_Order_List(SeqList *s1,SeqList *s2);

// 合并两张从小到大的有序顺序表，合并后的表要求是从小到大排列的，函数返回新表的指针
SeqList * Merge_List(SeqList *s1,SeqList *s2);

//打印顺序表
void Display(SeqList *s);
#endif

源文件：SeqList.c

#include <stdlib.h>
#include "SeqList.h"
#include <stdio.h>

// 创建顺序表
SeqList *Create_List()
{
	SeqList *s = (SeqList *)malloc(sizeof(SeqList)/sizeof(char));
	if (s == NULL)
	{
		return NULL;
	}
	s -> list = (SeqData *)malloc(sizeof(SeqData)/sizeof(char)*INIT_SIZE);
	if (s -> list == NULL)
	{
		free(s);
		return NULL;
	}
	s -> max_len = INIT_SIZE;
	s -> len = 0;

	return s;
}

// 销毁顺序表
void Destory (SeqList *s)
{
	if (s == NULL)
	{
		return;
	}
	free (s -> list);
	free (s);
}

//扩大顺序表的长度
int AgainMalloc (SeqList *s)
{
	if (s == NULL)
	{
		return FALSE;
	}
	SeqData newsize = sizeof(SeqData)/sizeof(char)*(INIT_SIZE + INCRESS_SIZE);
	SeqData *tmp = (SeqData *)realloc(s -> list,newsize);
	if (tmp == NULL)
	{
		return FALSE;
	}	
	s -> list = tmp;
	s -> max_len += INCRESS_SIZE;
	return TRUE;	
}

// 插入数据：尾插法
int Insert_Last(SeqList *s,SeqData data)
{
	if (s == NULL)
	{
		return FALSE;
	}
	if (s -> max_len == s -> len)
	{
		if(AgainMalloc(s) == FALSE)
		{
			return FALSE;
		}
	}
	s -> list[s -> len] = data;
	s -> len ++;
	return TRUE;
}

// 插入数据：头插法
int Insert_Head(SeqList *s,SeqData data)
{
	if (s == NULL)
	{
		return FALSE;
	}
	if (s -> max_len == s -> len)
	{
		if(AgainMalloc (s) == FALSE)
		{
			return FALSE;
		}
	}
	int i;
	for (i = s -> len -1;i >= 0;i--)
	{
		s -> list[i + 1] = s -> list[i];
	}
	s -> list[0] = data;
	s -> len ++;
	return TRUE;
}

// 插入数据：在下标为 pos 的位置插入数据
int Insert_Pos(SeqList *s,int pos,SeqData data)
{
	if (s == NULL || pos < 0 || pos > s -> len)
	{
		return FALSE;
	}
	if (s -> max_len == s -> len)
	{
		if(AgainMalloc (s) == FALSE)
		{
			return FALSE;
		}
	}
	s -> list[pos] = data;
	s -> len ++;
	return TRUE;
}

//获得下标pos的元素的值
int GetData(SeqList *s,int pos,SeqData *x)
{
	if (s == NULL || pos < 0 || pos >= s -> len || x == NULL)
	{
		return FALSE;
	}
	*x = s -> list[pos];
	return TRUE;
}

// 查找元素，如果找到，将该元素的下标给x
int FindData(SeqList *s, SeqData data, int *x)
{
	if (s == NULL || x == NULL)
	{
		return FALSE;
	}
	int i = 0;
	int count = 0;
	while (i < s -> len)
	{
		if (data == s -> list[i])
		{
			x[count] = i;
			count++;
		}
		i++;
	}
	x[count] = -1;
	if (count)
	{
		return TRUE;
	}
	return FALSE;
}

// 删除 pos 下标的元素
int Delete_Pos(SeqList *s, int pos)
{
	if (s == NULL || pos < 0 || pos >= s -> len)
	{
		return FALSE;
	}
	while(pos < s -> len)
	{
		s -> list[pos] = s -> list[pos++ + 1];
	}
	s -> len--;
	return TRUE;
}

// 删除指定数据
int Delete_Data(SeqList *s, SeqData data)
{
	if (s == NULL)
	{
		return FALSE;
	}	
	int index[s -> len];
	if (FindData(s,data,index) == FALSE)
	{
		return FALSE;
	}
	else
	{
		int i = 0;
		while (index[i] > -1)
		{
			Delete_Pos(s,index[i] - i++);
		}
	}
	return TRUE;
}

//修改顺序表中所有值为data1的元素的值为data2
int Update_Data(SeqList *s,SeqData data1,SeqData data2)
{
	if (s == NULL)
	{
		return FALSE;
	}
	int index[s -> len];
	if (FindData(s,data1,index) == FALSE)
	{
		return FALSE;
	}
	else
	{
		int i = 0;
		while (index[i] > -1)
		{
			s -> list[index[i++]] = data2;
		}		
	}
	return TRUE;
}

//修改顺序表中下标为pos的元素的值为data
int Update_Pos(SeqList *s,int pos,SeqData data)
{
	if (s == NULL || pos < 0 || pos >= s -> len)
	{
		return FALSE;
	}
	s -> list[pos] = data;
	return TRUE;
}

// 逆序顺序表
int Reverse_List(SeqList *s)
{
	if (s == NULL)
	{
		return FALSE;
	}
	int min = 0;
	int max = s -> len - 1;
	SeqData tmp;
	while (min < max)
	{
		tmp = s -> list[min];
		s -> list[min++] = s -> list[max];
		s -> list[max--] = tmp;
	}
	return TRUE;
}

//将一张顺序表排序
int Order_List(SeqList *s)
{
	if (s == NULL)
	{
		return FALSE;
	}
	int i,j;
	SeqData tmp;
	for (i = 0; i < s -> len - 1 ; i++)
	{
		for (j = 0; j < s -> len - 1 - i ; j++)
		{
			if (s -> list[j] > s -> list[j + 1])
			{
				tmp = s -> list[j];
				s -> list[j] = s -> list[j + 1];
				s -> list[j + 1] = tmp;
			}
		}
	}
	return TRUE;
}

//合并两张顺序表，合并后的表要求是从小到大排列的，函数返回新表的指针
SeqList * Merge_Order_List(SeqList *s1,SeqList *s2)
{
	if (s1 == NULL ||s2 == NULL)
	{
		return NULL;
	}
	SeqList *s3 = (SeqList *)malloc(sizeof(SeqList)/sizeof(char));
	if (s3 == NULL)
	{
		return NULL;
	}
	SeqData newsize = s1 -> len + s2 -> len;
	s3 -> list = (SeqData *)malloc(sizeof(SeqData)/sizeof(char)*newsize);
	if (s3 -> list == NULL)
	{
		free(s3);
		return NULL;
	}
	s3 -> max_len = newsize;
	s3 -> len = newsize;
	int i = 0;
	int j = 0;
	int k = 0;
	while(i < s1 -> len)
	{
		s3 -> list[k++] = s1 -> list[i++];
	}
	while(j < s2 -> len)
	{
		s3 -> list[k++] = s2 -> list[j++];
	}
	Order_List(s3);
	return s3;
}

// 合并两张从小到大的有序顺序表，合并后的表要求是从小到大排列的，函数返回新表的指针
SeqList * Merge_List(SeqList *s1,SeqList *s2)
{
	if (s1 == NULL ||s2 == NULL)
	{
		return NULL;
	}
	SeqList *s3 = (SeqList *)malloc(sizeof(SeqList)/sizeof(char));
	if (s3 == NULL)
	{
		return NULL;
	}
	SeqData newsize = s1 -> len + s2 -> len;
	s3 -> list = (SeqData *)malloc(sizeof(SeqData)/sizeof(char)*newsize);
	if (s3 -> list == NULL)
	{
		free(s3);
		return NULL;
	}
	s3 -> max_len = newsize;
	s3 -> len = newsize;
	int i = 0;
	int j = 0;
	int k = 0;
	while (i < s1 -> len && j < s2 -> len)
	{
		if (s1 -> list[i] < s2 -> list[j])
		{
			s3 -> list[k++] = s1 -> list[i++];
		}
		else
		{
			s3 -> list[k++] = s2 -> list[j++];
		}
	}
	while(i < s1 -> len)
	{
		s3 -> list[k++] = s1 -> list[i++];
	}
	while(j < s2 -> len)
	{
		s3 -> list[k++] = s2 -> list[j++];
	}
	return s3;
}

//打印顺序表
void Display(SeqList *s)
{
	if (s == NULL)
	{
		return;
	}
	int i;
	for (i = 0;i < s -> len;i++)
	{
		if (i % 4 == 0)
		{
			printf ("\n");
		}
		printf ("%8d",s -> list[i]);
	}
	printf ("\n");
}

关于顺序表的更多的功能，可以大家一起去实现。