线性表--顺序表

 

#include <stdio.h>

#define MAX_SIZE  100
typedef int ElementType;

struct SeqList
{
	ElementType data[MAX_SIZE];
	int length;
};

/*
空表
表长为0
*/
void Init(SeqList &L) {
	L.length = 0;
}

/*
数组尾部追加一个元素 
表长+1
*/
void Append(SeqList &L, ElementType elem) {
	if (L.length == MAX_SIZE) {
		printf("表满\n");
		return;
	}

	L.data[L.length] = elem;
	L.length++;
}

/*
将elem插入到顺序表的第i个位置	1<=i<=length+1(length+1即为在尾部追加)
从后往前遍历到下标为i-1的元素，这些元素都往后挪一位，
然后在i-1的位置上插入元素elem
表长+1
错误的做法：从前往后遍历挪一位会覆盖掉后面的值
*/
void Insert(SeqList &L, int i,ElementType elem) {
	if (L.length == MAX_SIZE) {
		printf("表满\n");
		return;
	}
	if (i < 1 || i > L.length + 1) {
		printf("插入位置不存在\n");
		return;
	}
	for (int k = L.length - 1; k >= i - 1;--k) {
		L.data[k + 1] = L.data[k];
	}

	L.data[i - 1] = elem;
	L.length++;
}
/*
删除顺序表的第i个元素，将删除元素的值存入elem中 1<=i<=length
删除的元素下标为i-1，先保存下标为i-1的元素的值到elem中，
从下标为i的元素遍历到最后将这些元素往前挪一位，通过往前挪一位覆盖掉i-1元素的值。
表长-1
错误的做法：从后往前遍历往前挪会覆盖掉前面的值
*/
void Delete(SeqList &L, int i, ElementType& elem) {
	if (i < 1 || i > L.length) {
		printf("删除位置不存在\n");
		return;
	}
	elem = L.data[i - 1];
	for (int k = i; k < L.length; ++k) {
		L.data[k - 1] = L.data[k];
	}
	L.length--;
}

/*
返回顺序表中第i个元素, 1<=i<=length
直接取数组中第i-1个元素
*/
void getElem(SeqList &L, int i, ElementType& elem) {
	if (i < 1 || i > L.length) {
		printf("查询位置不存在\n");
		return;
	}

	elem = L.data[i - 1];
}

/*
找到顺序表中某个元素的位置，如果有相同元素则返回第一个找到的元素，
从前往后遍历数组找到和这个值相同的元素 返回位置，没有找到返回0
*/
int localElem(SeqList &L,ElementType& elem) {
	for (int i = 0; i < L.length;++i) {
		if (L.data[i] == elem) {
			return i + 1;
		}
	}
	
	return 0;
}

/*
从前往后输出顺序表中的元素
*/
void Traverse(SeqList &L) {
	for (int i = 0; i < L.length;++i) {
		printf("%d ",L.data[i]);
	}
	printf("\n");
}

//获取表长
int getLength(SeqList &L) {
	return L.length;
}

//判断顺序表是否为空表
bool isEmpty(SeqList &L) {
	return L.length == 0 ? true : false;
}

/*
清空线性表 
创建在栈上由系统释放内存,函数返回后顺序表释放
*/
void clearList(SeqList &L) {
	L.length = 0;
}

int main() {
	SeqList list;
	Init(list);
	Append(list,1);
	Append(list,5);
	Append(list,3);
	Append(list,8);
	Append(list,4);
	Traverse(list);

	Insert(list, 3, 10);
	Traverse(list);
	ElementType elem = 0;
	Delete(list, 7, elem);
	printf("删除的元素为 %d\n", elem);
	Traverse(list);
	getElem(list, 4, elem);
	printf("找到的元素为 %d\n", elem);
	printf("该元素的位置为 %d\n", localElem(list, elem));
	printf("顺序表长度为 %d\n", getLength(list));
	clearList(list);
	printf("顺序表是否为空表 :%s\n", isEmpty(list) == true ? "是" : "否");
	printf("顺序表长度为 %d\n", getLength(list));

	getchar();
	return 0;
}

 

 

#include <stdio.h>
#include <malloc.h>

//内存分配增量
#define INCREMENT 10

typedef int ElementType;

struct SeqList
{
	ElementType *data;
	int length;
	int size;
};

/*
空表
表长为0
*/
void Init(SeqList &list,int n) {
	list.data = (ElementType*)malloc(n * sizeof(ElementType));
	if (NULL == list.data) {
		printf("顺序表内存分配失败");
		return;
	}

	list.length = 0;
	list.size = n;
}

/*
数组尾部追加一个元素 
表长+1
*/
void Append(SeqList &L, ElementType elem) {
	if (L.length == L.size) {
		L.data = (ElementType*)realloc(L.data,(L.size + INCREMENT)* sizeof(ElementType));
		L.size += INCREMENT;
	}

	L.data[L.length] = elem;
	L.length++;
}

/*
将elem插入到顺序表的第i个位置	1<=i<=length+1(length+1即为在尾部追加)
从后往前遍历到下标为i-1的元素，这些元素都往后挪一位，
然后在i-1的位置上插入元素elem
表长+1
错误的做法：从前往后遍历挪一位会覆盖掉后面的值
*/
void Insert(SeqList &L, int i,ElementType elem) {
	if (L.length == L.size) {
		L.data = (ElementType*)realloc(L.data, (L.size + INCREMENT) * sizeof(ElementType));
		L.size += INCREMENT;
	}
	if (i < 1 || i > L.length + 1) {
		printf("插入位置不存在\n");
		return;
	}
	for (int k = L.length - 1; k >= i - 1;--k) {
		L.data[k + 1] = L.data[k];
	}

	L.data[i - 1] = elem;
	L.length++;
}
/*
删除顺序表的第i个元素，将删除元素的值存入elem中 1<=i<=length
删除的元素下标为i-1，先保存下标为i-1的元素的值到elem中，
从下标为i的元素遍历到最后将这些元素往前挪一位，通过往前挪一位覆盖掉i-1元素的值。
表长-1
错误的做法：从后往前遍历往前挪会覆盖掉前面的值
*/
void Delete(SeqList &L, int i, ElementType& elem) {
	if (i < 1 || i > L.length) {
		printf("删除位置不存在\n");
		return;
	}
	elem = L.data[i - 1];
	for (int k = i; k < L.length; ++k) {
		L.data[k - 1] = L.data[k];
	}
	L.length--;
}

/*
返回顺序表中第i个元素, 1<=i<=length
直接取数组中第i-1个元素
*/
void getElem(SeqList &L, int i, ElementType& elem) {
	if (i < 1 || i > L.length) {
		printf("查询位置不存在\n");
		return;
	}

	elem = L.data[i - 1];
}

/*
找到顺序表中某个元素的位置，如果有相同元素则返回第一个找到的元素，
从前往后遍历数组找到和这个值相同的元素 返回位置，没有找到返回0
*/
int localElem(SeqList &L,ElementType& elem) {
	for (int i = 0; i < L.length;++i) {
		if (L.data[i] == elem) {
			return i + 1;
		}
	}
	
	return 0;
}

/*
从前往后输出顺序表中的元素
*/
void Traverse(SeqList &L) {
	for (int i = 0; i < L.length;++i) {
		printf("%d ",L.data[i]);
	}
	printf("\n");
}

//获取表长
int getLength(SeqList &L) {
	return L.length;
}

//判断顺序表是否为空表
bool isEmpty(SeqList &L) {
	return L.length == 0 ? true : false;
}

/*
清空线性表 
创建在堆上，需要手动释放
*/
void clearList(SeqList &L) {
	free(L.data);
	L.data = NULL;
	L.length = 0;
}

int main() {
	SeqList list;
	Init(list,5);
	Append(list,1);
	Append(list,5);
	Append(list,3);
	Append(list,8);
	Append(list,4);
	printf("顺序表容量:%d\n",list.size);
	Traverse(list);
	
	Insert(list, 3, 10);
	printf("顺序表容量:%d\n", list.size);
	Traverse(list);
	ElementType elem = 0;
	Delete(list, 7, elem);
	printf("删除的元素为 %d\n", elem);
	Traverse(list);
	getElem(list, 4, elem);
	printf("找到的元素为 %d\n", elem);
	printf("该元素的位置为 %d\n", localElem(list, elem));
	printf("顺序表长度为 %d\n", getLength(list));
	clearList(list);
	printf("顺序表是否为空表 :%s\n", isEmpty(list) == true ? "是" : "否");
	printf("顺序表长度为 %d\n", getLength(list));

	getchar();
	return 0;
}