ArrayList

 

#ifndef SEQUENCE_LIST_H
#define SEQUENCE_LIST_H

typedef void* sequence_list;

sequence_list create_sequence_list();
void destroy_sequence_list(sequence_list list);
void clear_sequence_list(sequence_list list);
int size_sequence_list(sequence_list list);
void* get_sequence_list(sequence_list list, int pos);
int insert_sequence_list(sequence_list list, void *data, int pos);
int remove_by_position_sequence_list(sequence_list list, int pos);
int remove_by_value_sequence_list(sequence_list list, void *data, int(*compare)(void* data1, void* data2));


#endif // !SEQUENCE_LIST_H

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

#define MAX 1024

typedef struct tag_inner_sequence_list{
	void **dataArray;
	int capacity;
	int size;
}inner_sequence_list;


sequence_list create_sequence_list()
{
	//静态开辟链表空间
	inner_sequence_list *inner_list = (inner_sequence_list *)malloc(sizeof(inner_sequence_list));
	//内存分配检查
	if (inner_list == NULL)
	{
		return NULL;
	}
	//初始化开辟的内存空间，做一个负责任的人。
	memset(inner_list, 0, sizeof(inner_sequence_list));

	//给数据域分配内存
	inner_list->dataArray = malloc(sizeof(void* )*MAX);
	if (inner_list->dataArray == NULL)
	{
		return NULL;
	}
	memset(inner_list->dataArray, 0, sizeof(void*)*MAX);

	inner_list->capacity = MAX;
	inner_list->size = 0;
	
	return inner_list;
}

void destroy_sequence_list(sequence_list list)
{
	inner_sequence_list *inner_list = NULL;
	void **dataArray = NULL;

	if (list == NULL)
	{
		return;
	}
	inner_list = (inner_sequence_list *)list;
	dataArray = inner_list->dataArray;
	if (dataArray != NULL)
	{
		free(dataArray);
	}
	free(inner_list);
	return;
}

void clear_sequence_list(sequence_list list)
{
	inner_sequence_list *inner_list = NULL;

	if (list == NULL)
	{
		return;
	}
	inner_list = (inner_sequence_list *)list;
	inner_list->size = 0;

	return;
}

int size_sequence_list(sequence_list list)
{
	inner_sequence_list *inner_list = NULL;
	int size = 0;

	if (list == NULL)
	{
		return -1;
	}
	inner_list = (inner_sequence_list *)list;
	size = inner_list->size;
	return	size;
}

void* get_sequence_list(sequence_list list, int pos)
{
	inner_sequence_list *inner_list = NULL;

	if (list == NULL)
	{
		return NULL;
	}
	inner_list = (inner_sequence_list *)list;
	if ((pos < inner_list->size) && (pos >= 0))
	{
		void *m = inner_list->dataArray[pos];
		return m;
	}
	else
	{
		return NULL;
	}
}

int insert_sequence_list(sequence_list list, void *data, int pos)
{
	inner_sequence_list *inner_list = NULL;
	
	//输入检查
	if ((list == NULL) || (data == NULL))
	{
		return -1;							//无效的链表或者数据
	}
	inner_list = (inner_sequence_list *)list;

	//check pos 
	if ((pos < 0) || (pos > inner_list->size))
	{
		return -1;
	}

	//容量检查
	if (inner_list->size == inner_list->capacity)
	{
		inner_list->capacity = inner_list->capacity * 2;
		//重新开辟内存
		void **data_temp = malloc(sizeof(void *)*inner_list->capacity);
		if (data_temp == NULL)
		{
			return -1;
		}
		memset(data_temp,0, sizeof(void *)*inner_list->capacity);
		//内存数据copy
		memcpy(data_temp,inner_list->dataArray, sizeof(void *)*inner_list->capacity);
		inner_list->dataArray = data_temp;
		//插入数据
		inner_list->dataArray[inner_list->size] = data;
		inner_list->size++;
		return 0;
	}
	else
	{
		int i ;
		for ( i = inner_list->size-1; i >= pos; i--)
		{
			inner_list->dataArray[i+1] = inner_list->dataArray[i];
		}

		//插入数据
		inner_list->dataArray[pos] = data;
		inner_list->size++;
		return	0;
	}
}

int remove_by_position_sequence_list(sequence_list list, int pos)
{
	inner_sequence_list * inner_list = NULL;
	int i = 0;

	if (list == NULL)
	{
		return -1;
	}
	inner_list = (inner_sequence_list *)list;
	if ((pos < 0) || (pos >= inner_list->size))
	{
		return -1;
	}
	for (i = pos; i < inner_list->size - 1; i++)
	{
		inner_list->dataArray[i] = inner_list->dataArray[i + 1];
	}

	inner_list->size--;
	return	0;
}

int remove_by_value_sequence_list(sequence_list list, void *data,int (*compare)(void* data1,void* data2)) {
	int i, flag = 0;

	if ((list == NULL)|| (data == NULL))
	{
		return -1;
	}
	inner_sequence_list *inner_list = (inner_sequence_list *)list;
	for (i = 0; i < inner_list->size; i++)
	{
		if (compare(inner_list->dataArray[i], data)) {
			flag = 1;
			break;
		}
	}
	if (0==flag)
	{
		return 0;
	}
	else
	{
		return remove_by_position_sequence_list(list, i);
	}
}

//link_list test program

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


int cp(void *t1, void *t2) {
	if (*(int*)t1 == *(int*)t2) {
		return 1;
	}
	else
	{
		return 0;
	}
}


int main(int argc, char** argv)
{

	sequence_list slist = create_sequence_list();
	int a1 = 31;
	int a2 = 32;
	int a3 = 33;
	int a4 = 34;
	int a5 = 35;
	int a6 = 36;
	int i = 0;


	insert_sequence_list(slist, &a1, 0);
	insert_sequence_list(slist, &a2, 0);
	insert_sequence_list(slist, &a3, 0);
	insert_sequence_list(slist, &a4, 0);
	insert_sequence_list(slist, &a5, 0);
	insert_sequence_list(slist, &a6, 0);

	int len = size_sequence_list(slist);
	printf("length: %d\n", len);

	for (i = 0; i < len; i++)
	{
		int* node = (int*)get_sequence_list(slist, i);
		printf("the %dth: %d\n", i, *node);
	}
	remove_by_value_sequence_list(slist, &a1, cp);
	printf("删除后的长度：%d\n", size_sequence_list(slist));

	for (i = 0; i < len; i++)
	{
		remove_by_position_sequence_list(slist, 0);
		printf("正在删除 the %dth\n", i);
	}
	printf("删除后的长度：%d\n", size_sequence_list(slist));

	clear_sequence_list(slist);
	destroy_sequence_list(slist);

	system("pause");
	return 0;
}