线性表的顺序存储总结

关键思想：首先，上层把所需插入的类型封装成void *类型，也就是一个地址值，而底层接到这个地址值之后，

并不关心这个上层所传入的什么，只需要将这个地址值存起来即可，所以底层强制类型转换把void *类型的地址

转成unsigned int类型，此时通过unsigned int类型的node可以存入这个地址值。而当需要输出上层存入的东西

时，底层只要通过node去出相应的地址，把地址给上层，上层就可以相应的指针类型去接这个传出的地址，然后

就可以用这个指针去打开内存。

SeqList.h                     //理解：上层用户看到的就是此函数接口，因为不想让上层用户知道如何实现的，所有在此用void类型来封装

#ifndef  __MY_SEQLIST_H__ 
#define __MY_SEQLIST_H__

typedef void SeqList;
typedef void SeqListNode;

SeqList* SeqList_Create(int capacity);

void SeqList_Destroy(SeqList* list);

void SeqList_Clear(SeqList* list);

int SeqList_Length(SeqList* list);

int SeqList_Capacity(SeqList* list);

int SeqList_Insert(SeqList* list, SeqListNode* node, int pos);  //对于底层来说，上层传什么不需要关心，传的肯定是个地址，然后把这个地址用void类型封装下
                                                                  底层接到这个地址之后，会做相应类型转换，把这个地址给接住。
SeqListNode* SeqList_Get(SeqList* list, int pos);

SeqListNode* SeqList_Delete(SeqList* list, int pos);


#endif  //__MY_SEQLIST_H__

//关于void *类型，男人是人，女人也是人，但是不能说人是男人或者人是女人

SeqList.cpp

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



//
//SeqList* SeqList_Create(int capacity);
//
//void SeqList_Destroy(SeqList* list);
//
//void SeqList_Clear(SeqList* list);
//
//int SeqList_Length(SeqList* list);
//
//int SeqList_Capacity(SeqList* list);
//
//int SeqList_Insert(SeqList* list, SeqListNode* node, int pos);
//
//SeqListNode* SeqList_Get(SeqList* list, int pos);
//
//SeqListNode* SeqList_Delete(SeqList* list, int pos);

typedef struct NSeqList               //内部真正实现的
{
	int capacity;
	int length;
	unsigned int *node;    //unsigned int *node[]     因为接的是指针所以用的死unsigned int *类型
}TSeqLIst;


SeqList* SeqList_Create(int capacity)
{
	TSeqLIst *list = NULL;
	list = (TSeqLIst *)malloc(sizeof(TSeqLIst));
	if (list == NULL)
	{
		printf("(TSeqLIst *)malloc(sizeof(TSeqLIst)) err");
		return  NULL;
	}
	memset(list, 0, sizeof(TSeqLIst));
	
	list->node = (unsigned int *)malloc(sizeof(unsigned int *)*capacity);    
	if (list->node == NULL)
	{
		printf("(unsigned int *)malloc(sizeof(unsigned int *)*capacity) err");    //用unsigned int或是unsigned int *类型都是4个字节，并不影响 
		return NULL;
	}
	list->capacity = 10;
	list->length = 0;
	return list;
}


void SeqList_Destroy(SeqList* list)
{
	TSeqLIst *tlist = NULL;
	if (list == NULL)
	{
		printf("list already NULL");
		return;
	}
	else
	{
		tlist = (TSeqLIst *)list;
		free(tlist->node);
		free(tlist);
		printf("OK");
		return;
	}
}

void SeqList_Clear(SeqList* list)
{
	int i= 0;
	TSeqLIst *tlist = NULL;
	if (list == NULL)
	{
		printf("list is NULL");
		return;
	}
	tlist = (TSeqLIst *)list;
	for (i = 0; i < SeqList_Length(list); i++)
	{
		tlist->node[i] = NULL;
	}
	printf("OK!");
}

int SeqList_Length(SeqList* list)
{
	TSeqLIst *tlist = NULL;
	if (list == NULL)
	{
		printf("list is NULL");
		return -1;
	}
	tlist = (TSeqLIst *)list;

	return tlist->length;
}

int SeqList_Capacity(SeqList* list)
{
	TSeqLIst *tlist = NULL;
	if (list == NULL)
	{
		printf("list is NULL");
		return -1;
	}
	tlist = (TSeqLIst *)list;

	return tlist->capacity;
	
}

int SeqList_Insert(SeqList* list, SeqListNode* node, int pos)
{
	TSeqLIst *tlist = NULL;
	if (list == NULL)
	{
		printf("list is NULL");
		return -1;
	}
	tlist = (TSeqLIst *)list;

	if (pos > tlist->capacity&&tlist->length == tlist->capacity)
	{
		printf("not input");
		return - 1;
	}
	int p = tlist->length;
	if (pos > p)
	{
		pos = p;
	}
	while (p != pos)
	{
		tlist->node[p] = tlist->node[p - 1];
		p--;
	}
	tlist->node[p] = (unsigned int)node;
	tlist->length++;
	return 0;
}

SeqListNode* SeqList_Get(SeqList* list, int pos)
{
	TSeqLIst *tlist = NULL;
	if (list == NULL)
	{
		printf("list is NULL");
		return NULL;
	}
	tlist = (TSeqLIst *)list;

	if (pos > tlist->length)
	{
		printf("Get err");
		return NULL;
	}
	return (void *)tlist->node[pos];
}

SeqListNode* SeqList_Delete(SeqList* list, int pos)
{
	TSeqLIst *tlist = NULL;
	if (list == NULL)
	{
		printf("list is NULL");
		return NULL;
	}
	tlist = (TSeqLIst *)list;

	if (pos > tlist->length)
	{
		printf("Delete err");
		return NULL;
	}
	
	tlist->node[pos] = NULL;
	tlist->length--;
	int p = pos + 1;
	while (p < tlist->length)
	{
		tlist->node[p - 1] = tlist->node[p];
		p++;
	}
	return NULL;	
}

SeqList_Test.cpp

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


//typedef void SeqList;
//typedef void SeqListNode;
//
//SeqList* SeqList_Create(int capacity);
//
//void SeqList_Destroy(SeqList* list);
//
//void SeqList_Clear(SeqList* list);
//
//int SeqList_Length(SeqList* list);
//
//int SeqList_Capacity(SeqList* list);
//
//int SeqList_Insert(SeqList* list, SeqListNode* node, int pos);
//
//SeqListNode* SeqList_Get(SeqList* list, int pos);
//
//SeqListNode* SeqList_Delete(SeqList* list, int pos);

struct MyStruct
{
	int age;
}a1{ 1 }, a2{ 2 }, a3{ 3 };

//int main()
//{
//
//	int i = 0;
//	SeqList  *list = NULL;
//	list = SeqList_Create(10);
//
//	printf("SeqList length:%d", SeqList_Length(list));
//	int a = 1;
//	int b = 2;
//	int c = 3;
//	SeqList_Insert(list, (SeqListNode *)&a, 0);
//	SeqList_Insert(list, (SeqListNode *)&b, 0);
//	SeqList_Insert(list, (SeqListNode *)&c, 0);
//
//	for (i = 0; i < SeqList_Length(list); i++)
//	{
//
//		int *d = (int *)SeqList_Get(list, i);
//		if (d == NULL)
//		{
//			break;
//		}
//		printf("%d\n", *d);
//	}
//
//
//	printf("OK\n");
//
//	system("pause");
//}


int main()
{

	int i = 0;
	SeqList  *list = NULL;
	list = SeqList_Create(10);

	
	SeqList_Insert(list, (SeqListNode *)&a1, 0);
	SeqList_Insert(list, (SeqListNode *)&a2, 0);
	SeqList_Insert(list, (SeqListNode *)&a3, 0);

	for (i = 0; i < SeqList_Length(list); i++)
	{

		int *d = (int *)SeqList_Get(list, i);
		if (d == NULL)
		{
			break;
		}
		printf("%d\n", *d);
	}


	printf("OK\n");

	system("pause");
}