线性表

线性表是一种非常简单的数据结构，采用数组描述，非线程安全。

LinearList.c

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

#define LL_TRUE   0
#define LL_FALSE  1
#define LL_ERROR -1

typedef struct LinearList LinearList;

struct LinearList {
	int ele_nums;
	int curr_pos;
	int *data;
	int (*init)(LinearList *ll);
	void (*destroy)(LinearList *);
	int (*is_empty)(LinearList *);
	int (*is_full)(LinearList *);
	int (*get_len)(LinearList *);
	int (*get_ele_by_index)(LinearList *, int index, int *target);
	int (*del_ele_by_index)(LinearList *, int index);
	int (*add_ele)(LinearList *, int target);
	void (*output)(LinearList *);
};

static int ll_init(LinearList *ll)
{
	int i = 0;

	if(NULL == ll || ll->ele_nums <= 0)
		return LL_ERROR;

	ll->data = (int *)malloc(sizeof(int) * ll->ele_nums);
	if(NULL == ll->data) 
		return LL_FALSE;

	// init ll->data. -1 means empty.
	for(i = 0; i < ll->ele_nums; i++)
		ll->data[i] = -1;

	return LL_TRUE;
}

static void ll_destroy(LinearList *ll)
{
	if(NULL == ll)
		return;

	if(ll->data)
		free(ll->data);
	ll->data = NULL;
}

static int is_ll_empty(LinearList *ll) 
{
	if(NULL == ll)
		return LL_ERROR;

	if(ll->curr_pos == -1)
		return LL_TRUE;

	return LL_FALSE;
}

static int is_ll_full(LinearList *ll) 
{
	if(NULL == ll)
		return LL_ERROR;

	if(ll->curr_pos == (ll->ele_nums - 1))
		return LL_TRUE;

	return LL_FALSE;
}

static int get_ll_len(LinearList *ll)
{
	if(NULL == ll)
		return LL_ERROR;

	return (ll->curr_pos + 1);
}

static int get_ele_by_index(LinearList *ll, int index, int *target)
{
	if(NULL == ll || NULL == target)
		return LL_ERROR;

	if(index < 0 || index > ll->curr_pos)
		return LL_FALSE;

	target = &(ll->data[index]);
	printf("The %d element is %d\n", index, *target);
	
	return LL_TRUE;
}

static int del_ele_by_index(LinearList *ll, int index)
{
	int i = 0;

	if(NULL == ll || NULL == ll->data || index < 0 || index > ll->curr_pos)
		return LL_ERROR;

	printf("The index[%d]=[%d] element will be deleted.\n", index, ll->data[index]);
	for(i = index; i <= ll->curr_pos; i++) {
		if(i == ll->ele_nums - 1) {
			ll->data[i] = -1;
			ll->curr_pos--;
			return LL_TRUE;
		}

		ll->data[i] = ll->data[i+1];
	}
	ll->curr_pos--;

	return LL_TRUE;
}

static int add_ll_ele(LinearList *ll, int target)
{
	if(NULL == ll || -1 == target)
		return LL_ERROR;

	if(is_ll_full(ll) == LL_TRUE)
		return LL_FALSE;

	ll->data[++(ll->curr_pos)] = target;

	return LL_TRUE;
}

static void output_ll(LinearList *ll)
{
	int i = 0;
	
	if(NULL == ll || NULL == ll->data)
		return;

	printf("There are %d elements in LinearList\n", ll->curr_pos + 1);
	for(i = 0; i <= ll->curr_pos; i++)
		printf("%d ", ll->data[i]);
	printf("\n");
}


/* test code: usage of LinearList */
int main()
{
	int target;

	// Define a LinearList
	LinearList myll = {
		.ele_nums = 10,
		.curr_pos = -1,
		.data     = NULL,
		.init     = ll_init,
		.destroy  = ll_destroy,
		.is_empty = is_ll_empty,
		.is_full  = is_ll_full,
		.get_len  = get_ll_len,
		.get_ele_by_index = get_ele_by_index,
		.del_ele_by_index = del_ele_by_index,
		.add_ele  = add_ll_ele,
		.output   = output_ll,
	};

	// Initialize
	myll.init(&myll);
	
	// Add 10 elements, make LinearList is full
	myll.add_ele(&myll, 8);
	myll.add_ele(&myll, 28);
	myll.add_ele(&myll, 56);
	myll.add_ele(&myll, 30);
	myll.add_ele(&myll, 22);
	myll.add_ele(&myll, 43);
	myll.add_ele(&myll, 789);
	myll.add_ele(&myll, 654);
	myll.add_ele(&myll, 123);
	myll.add_ele(&myll, 999);
	myll.add_ele(&myll, 10000);  // LinearList is full, so this element will not be added
	// Output
	myll.output(&myll);

	// Find an element by index
	myll.get_ele_by_index(&myll, 9, &target);
	myll.get_ele_by_index(&myll, 8, &target);
	myll.get_ele_by_index(&myll, 7, &target);
	myll.get_ele_by_index(&myll, 6, &target);
	myll.get_ele_by_index(&myll, 5, &target);
	myll.get_ele_by_index(&myll, 4, &target);
	myll.get_ele_by_index(&myll, 3, &target);
	myll.get_ele_by_index(&myll, 2, &target);
	myll.get_ele_by_index(&myll, 1, &target);
	myll.get_ele_by_index(&myll, 0, &target);

	// Delete element
	myll.del_ele_by_index(&myll, 5);
	// Output
	myll.output(&myll);

	// Delete element
	myll.del_ele_by_index(&myll, 8);
	// Output
	myll.output(&myll);

	// Destroy
	myll.destroy(&myll);


	return 0;
}