DEV C++顺序表的一些基本操作

初始化 查找元素位置 插入 删除 输入 求长度 求第i个元素
两个表无序合并 表升序 两个无序表升序合并到第三个表

/*
初始化 查找元素位置 插入 删除 输入 求长度 求第i个元素
两个表无序合并 表升序 两个无序表升序合并到第三个表
*/

#include <iostream>
#include <stdio.h>
using namespace std;
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int Status;  //Status是函数返回值类型,其值是函数结果状态代码
typedef int ElemType;  //ElemType为可定义的数据类型,此设为int类型


#define MAXSIZE 100

typedef struct {
	ElemType *elem;   //储存空间基地址
	int length;
} SqList;

/**
  * @brief  顺序表的初始化
  * @param  SqList类型
  * @retval 无
  */
Status SqList_Init(SqList &L) {
	L.elem = new ElemType[MAXSIZE];
	if (! L.elem )
		exit(OVERFLOW);   //储存分配失败
	L.length = 0;
	return OK;
}

/**
  * @brief  顺序表查找元素位置
  * @param  SqList类型,ElemType类型
  * @retval 无
  */
int SqList_LocateElem(SqList L, ElemType e) {
	for (int i = 0; i < L.length; i++)
		if (L.elem [i] == e)
			return i + 1;
	return 0;
}

/**
  * @brief  顺序表的插入,i之前
  * @param  SqList类型,插入位置,ElemType类型
  * @retval 无
  */
Status SqList_Insert(SqList &L, int i, ElemType e) {
	if (i < 1 || i > L.length + 1)
		return ERROR;
	if (L.length == MAXSIZE)
		return ERROR;//表满
	for (int j = L.length - 1; j >= i - 1; j--)
		L.elem [j + 1] = L.elem [j];
	L.elem [i - 1] = e;
	++L.length ;
	return OK;
}

/**
  * @brief  顺序表的删除，并返回删除的元素
  * @param  SqList类型,删除位置,ElemType类型
  * @retval 无
  */
Status SqList_Delete(SqList &L, int i, ElemType &e) {
	if (i < 1 || i > L.length )
		return ERROR;
	e = L.elem [i - 1];
	for (int j = i; j <= L.length ; j++)
		L.elem [j - 1] = L.elem [j];
	--L.length ;
	return OK;
}

/**
  * @brief  顺序表输入
  * @param  SqList类型,元素个数n
  * @retval 无
  */
void SqList_Input(SqList &L, int n) {
	int i;
	SqList_Init(L);
	cout << "请输入" << n << "个数:\n";
	for (i = 0; i < n; i++)
		cin >> L.elem[i] ;
	L.length = n;
}

/**
  * @brief  求顺序表长度
  * @param  SqList类型
  * @retval 顺序表长度
  */
int SqList_Length(SqList L) {
	return L.length ;
}

/**
  * @brief  求顺序表第i个元素，以e返回
  * @param  SqList类型，位置i，返回值e
  * @retval 无
  */
void SqList_GetElem(SqList L, int i, ElemType &e) {
	e = L.elem [i - 1];
}

/**
  * @brief  把顺序表B合并到A中，去重，无序
  * @param  SqList类型，SqList类型
  * @retval 无
  */
void SqList_Union(SqList &A, SqList B) {
	int A_len, B_len, i, e;
	A_len = SqList_Length(A);
	B_len = SqList_Length(B);
	for (i = 1; i <= B_len; i++) {
		SqList_GetElem(B, i, e);
		if (!SqList_LocateElem(A, e))
			SqList_Insert(A, SqList_Length(A) + 1, e);
	}
	A.length = SqList_Length(A) ;
}

/**
  * @brief  顺序表冒泡排序，升序
  * @param  SqList类型
  * @retval 无
  */
void SqList_Maopao(SqList a) {
	int n;  //存放数组a中元素的个数
	int i;  //比较的轮数
	int j;  //每轮比较的次数
	int buf;  //交换数据时用于存放中间数据
	n = a.length ;
	for (i = 0; i < n - 1; ++i) { //比较n-1轮
		for (j = 0; j < n - 1 - i; ++j) { //每轮比较n-1-i次,
			if (a.elem [j] > a.elem [j + 1]) {
				buf = a.elem [j];
				a.elem [j] = a.elem [j + 1];
				a.elem [j + 1] = buf;
			}
		}
	}
}


/**
  * @brief  把无序顺序表X和Y合并到C中，不去重，升序
  * @param  SqList类型，SqList类型，SqList类型
  * @retval 无
  */
void SqList_Union_Orderly(SqList X, SqList Y, SqList &C) {
	int *pa, *pb, *pc, *pa_last, *pb_last;
	ElemType e;
	/************************************************/
	SqList A;
	A.length = X.length ;
	A.elem = new ElemType[A.length ];
	for (int i = 0; i < A.length ; ++i)
		A.elem [i] = X.elem [i];
	SqList B;
	B.length = Y.length ;
	B.elem = new ElemType[B.length ];
	for (int i = 0; i < B.length ; ++i)
		B.elem [i] = Y.elem [i];
	/***********************************************/
	/**以上新建两个顺序表为的是不打乱原顺序表排序***/
	SqList_Maopao(A);
	SqList_Maopao(B);//使两个顺序表元素降序
	pa = A.elem ;
	pb = B.elem ;
	C.length = A.length + B.length ;
	C.elem = new int[C.length ];
	pc = C.elem ;
	pa_last = A.elem + A.length - 1;
	pb_last = B.elem + B.length - 1;
	while (pa <= pa_last && pb <= pb_last) {
		if (*pa <= *pb)
			*pc++ = *pa++;
		else *pc++ = *pb++;
	}
	while (pa <= pa_last)
		*pc++ = *pa++;
	while (pb <= pb_last)
		*pc++ = *pb++;
	/***********************************************/
	while (A.length )
		SqList_Delete(A, A.length, e);
	while (B.length )
		SqList_Delete(B, B.length, e);
	/***********删除两个没用的顺序表***************/
}

+ 输出，逆置

/**
  * @brief  顺序表的输出
  * @param  SqList类型
  * @retval 无
  */
void SqList_Output(SqList L) {
	for (int i = 0; i < L.length ; ++i)
		cout << L.elem [i];
	cout << endl;
}

/**
  * @brief  顺序表的逆置
  * @param  SqList类型
  * @retval 无
  */
Status SqList_Reverse(SqList &L) {
	if (L.length == 0) {
		cout << "该链表为空" << endl;
		return ERROR;
	}
	int i = 0;
	ElemType temp;
	for (i = 0; i < (L.length / 2); i++) {
		temp = L.elem [i];
		L.elem [i] = L.elem [L.length - i - 1];
		L.elem [L.length - i - 1] = temp;
	}
	cout << "逆置后的顺序表为:";
	SqList_Output(L);
	return OK;
}