数据结构----线性表顺序存储的基本操作

线性表的抽象数据类型定义：

ADT LinearList{

        数据元素：D = { ai | ai ∈ D , i = 1, 2 , 3, ..., n,  n >= 0, D 为某一数据类型 }

        结构关系：R = { < ai , a(i+1) > | ai , a(i+1) ∈ D，i =1,2,3,...,n-1 }

        基本操作：

        ①InitList(L)

                操作前提：L为未初始化线性表

                操作结果：将L初始化为空表

        ②ListList(L)

                操作前提：线性表L已存在

                操作结果：如果L为空表则返回0，否则返回表中的元素个数

        ③GetData(L)

                操作前提：表L存在，且 1 <= i <= ListList(L)

                操作结果：返回线性表L中第i个法元素的值

        ④InsList(L,i,e)

                操作前提：表L已存在，e为合法元素值且1 <= i <= ListLength(L)+1

                操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1

        ⑤DelList(L)

                 操作前提：表L已存在且非空， I <= i <= ListLenfth(L)

                操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1

        ⑥Locate(L,e)

                操作前提：表L已存在，e为合法数据元素值

                操作结果：如果L中存在数据元素e，则将当前指针指向数据元素e所在位置并返回TEUE，否则返回FLASE

        ⑦DestroyList(L)

                操作前提：线性表L集存在

                操作结果：将L销毁

        ⑧ClearList(L)

                操作前提：线性表L已存在

                操作结果：将L置为空表

        ⑨EmptyList(L)

                操作前提：线性表L已存在

                操作结果：如果L为空表则返回TRUE，否则返回FLASE

} ADT LinearList ；

目录

1.初始化线性表

2.线性表的访问输出

3.求线性表元素的个数

4.求表中第i个元素的值

5.查找表中值为e的数据元素的位置

6.在线性表中第i个位置之前插入特定元素e

7.删除表中第i个位置上的元素

8.表的逆置

9.将表中的数据元素的值按照从小到大排序

10.将两个非递减顺序表合并为一个非递减的表

11.将顺序表置为空表

12.销毁顺序表

---

1.初始化线性表

     

线性表的顺序存储结构可以借助结构体来表示

typedef struct {
	ElemType* Data;  //这里对数组采用了动态申请内存
                     //在初始化的时候要用malloc
                     //也可以用静态申请，例如：ElemType Data[100];
	int last;        //这里的last指的是数组的下标，
                     //在初始化函数时，我们把它初始化为-1，表示空表
}SeqList;            //我们构造了一个SeqList类型的线性表

在构建线性表类型的时候，我们对也可以额外用

typedef stuct SeqList* PtrL;

来表示表示结构体指针PtrL，这是因为我们在设计后续函数的时候，函数传递的参数一般都会被设计成指针类型，这样可以较为高效地对（可能会比较大的）线性表进行操作。

typedef SeqList* PtrL;
void OutPut(SeqList* L);    //函数的形参为指针类型，即SeqList*类型

                            //由于定义了PtrL，所以这两个语句是等价的

void OutPut(PtrL L);        //函数的形参为PtrL类型，即SeqList*类型

由于线性表是抽象数据类型，其抽象的是指（但是不仅限于此）数据元素的类型是抽象的，因此我们用ElemType来表示，在本文中，我们用

#define ElemType int

来表示，以求方便。

因此，初始化函数为

#include<stdio.h>
#include<stdlib.h>             //malloc的头文件
#define ElemType int
#define MAXSIZE 100
int InitList(SeqList* L) {

	L->Data = (ElemType*)malloc(MAXSIZE * sizeof(ElemType));
    //用malloc函数申请内存空间，注意要将结果强制转化为指针类型(ElemType *)

	if (!L->Data) {		       //注意，如果内存申请失败，要给出提示
		printf("初始化失败\n");
		return -1;
	}
	L->last = -1;		        //空表的last初始化为 -1
	return 0;
}

2.线性表的访问输出

void OutPut(SeqList* L)
{
	int i;
	printf("The figuar of SeqList is :");
	for (i = 0; i <= L->last; i++) {
		printf("%d ",L->Data[i]);
	}
	printf("\n");
}

3.求线性表元素的个数

int ListLength(SeqList* L) {
	return L->last + 1;
}

4.求表中第i个元素的值

ElemType GetData(SeqList* L, ElemType i)
{
	if (i < 1 || i > L->last + 1) {
		printf("Illegal position\n");
		return -1;
	}
	return L->Data[i - 1];
}

5.查找表中值为e的数据元素的位置

int Locate(SeqList* L, ElemType e)
{
	int i = 0;
	while (i <= L->last && L->Data[i] != e)
		i++;
	if (i <= L->last)
		return i + 1;
	else return -1;
	return 0;
}

6.在线性表中第i个位置之前插入特定元素e

int InsList(SeqList* L,int i, ElemType e)
{
	if (i<1 || i>L->last + 1) {
		printf("Illegal position\n");
		return -1;
	}
	if (i >= MAXSIZE + 1) {
		printf("The SeqList is full\n");
		return -1;
	}
	int k;
	for (k = L->last; k >= i - 1; k--) {
		L->Data[k + 1] = L->Data[k];
	}
	L->Data[i - 1] = e;
	L->last++;
	return 0;
}

7.删除表中第i个位置上的元素

int DelList(SeqList* L, int i, ElemType* e)
{
	if (i<1 || i>L->last + 1) {
		printf("Illegal position\n");
		return -1;
	}
	*e = L->Data[i - 1];
	int k;
	for (k = i - 1; k < L->last; k++) {
		L->Data[k] = L->Data[k + 1];
	}
	L->last--;
	return 0;
}

8.表的逆置

void Inverse(SeqList* L)
{
	int i, temp;
	for (i = 0; i <= (L->last) / 2; i++) {
		temp = L->Data[i];
		L->Data[i] = L->Data[L->last - i];
		L->Data[L->last - i] = temp;
	}
}

9.将表中的数据元素的值按照从小到大排序

void Sort(SeqList* L)
{
	int i, j, temp;
	for (i = 0; i < L->last; i++) {
		for (j = 0; j < L->last - i; j++) {
			if (L->Data[j] > L->Data[j + 1]) {
				temp = L->Data[j];
				L->Data[j] = L->Data[j + 1];
				L->Data[j + 1] = temp;
			}
		}
	}
}

10.将两个非递减顺序表合并为一个非递减的表

void Merge(SeqList* L1, SeqList* L2, SeqList* L3)
{
	int i = 0, j = 0, k = 0;
	while (i <= L1->last && j <= L2->last) {
		if (L1->Data[i] < L2->Data[j]) {
			L3->Data[k] = L1->Data[i];
			i++;
			k++;
		}
		else if (L1->Data[i] >= L2->Data[j]) {
			L3->Data[k] = L2->Data[j];
			j++;
			k++;
		}
		while (i <= L1->last) {
			L3->Data[k] = L1->Data[i];
			k++;
			i++;
		}
		while (j <= L2->last) {
			L3->Data[k] = L2->Data[j];
			k++;
			j++;
		}
		L3->last = L1->last + L2->last + 1;
	}
}

11.将顺序表置为空表

void ClearList(SeqList* L)
{
	L->last = -1;
}

12.销毁顺序表

void DestroyList(SeqList* L)
{
	free(L->Data);
	L->Data = NULL;
	L->last = -1;
}