数据结构-顺序表

1.顺序表初始化

/*初始化顺序表*/
bool InitList(SqList &L){
	L.data = (ElemType *)malloc(InitSize*sizeof(ElemType)); //初始化表长
	if(L.data == 0){
		cout << "内存分配出错" << endl;
		return 0; 
	} 
	L.length = 0;
	L.MaxSize = InitSize;
	return true; 
}

2.顺序表插入

/*顺序表的插入（在第i个位置进行插入,i与物理上的位置相对应），插入使用前插法*/
bool SqListInsert(SqList &L,int i,ElemType e){  
	if(i < 0 || i > L.length){
		cout << "插入位置不合理" << endl;
		return false; 	
	} 
	if(L.length == L.MaxSize){  //存储空间已满，追加存储空间 
		L.data = (ElemType*)realloc(L.data,(L.MaxSize+1)*sizeof(ElemType));  //在原来基础上面追加一个空间 
		if(L.data == 0){
		cout  << "存储空间分配失败" << endl;
		return false; 	
		}
	}
	for (int j = L.length; j > i; j--){
		L.data[j] = L.data[j - 1];	
	}
	L.data[i] = e;
	L.length++;
	return true;
} 

} 

3.顺序表删除

/*顺序表删除，在指定位置删除，并返回删除值*/
int SqlListDelete(SqList &L,int addr){
	int e;
	if(addr < 0 || addr > L.length){
		cout << "删除位置不合理" << endl;
		return false; 
	}
	e = L.data[addr];
	for(int i = addr; i < L.length; i ++){
		L.data[i] = L.data[i + 1];
	}
	L.length --;
	return e;	

4.查找

/*查找,查找某个特定值，返回下标*/
int FindItem(SqList L,ElemType e){
	for(int i = 0; i < L.length; i++)
	{
		if(L.data[i] == e){
			return i;
		}
	 } 
	return -1;  //
}
/*查找，按照下标位置查找指定值*/
int GetItem(SqList L,int i){
	if(i < 0 || i > L.length){
		cout << "下标越界" << endl;
	}
	return L.data[i];
} 

5.顺序表的运用

1.顺序表原地逆质，时间复杂度为O(1)

void rever(SqList &L){
	int temp = 0;
	for( int i = 0; i < L.length / 2; i++){
		temp = L.data[i];
		L.data[i] = L.data[L.length - i -1];
		L.data[L.length - i - 1] = temp;
	}
} 

2.将两个顺序表合并成一个新表长

bool MergeSqlList(SqList &L1,SqList &L2,SqList &L3){
	if(L1.length + L2.length > L3.MaxSize){
		return false;
	}
	int i = 0, j = 0,K = 0;
	while(i < L1.length && j < L2.length){
		if(L1.data[i] < L2.data[j]){
			L3.data[k++] = L1.data[i++];
			L3.length++;
		}
		else{
			L3.data[k++] = L2.data[j++]
			L3.length++;
		}
		while(i < L2.length){
			L3.data[k++] = L2.data[i++];
			L3.length++;
		}
		while(j < L1.length){
			L3.data[k++] = L1.data[j++];
			L3.length++;
		}
	}
}

3.删除顺序表中所有值为x的数据元素，时间复杂度为0(n),空间复杂度为o(1)

int Deletex(SqList &L,int e){
	int k = 0;
	for(int i = 0; i < L.length; i++){
		if(L.data[i] != e){
			L.data[k] = L.data[i];
			k++;
		}
	}
	L.length = k;
} 

4.在有序表中删除值在s和t之间的所有元素（不包括s和t）

bool DelBetween(SqList &L,ElemType s,ElemType t) {
	int i,j;
	if(s >= t || L.length == 0){
		return false;
	}
	for( i = 0; i < L.length && L.data[i] < s; i++); //寻找开始值区间s的下标 
	if(i >= L.length){   //未找到s 
		return false;
	} 
	for(j = i; j < L.length && L.data[j] <= t; j++);  //寻找区间值为t的下标 
	for(; j < L.length; i++ , j++){   //将s到t区间的值，用t后面的值进行填充 
		L.data[i] = L.data[j];
	} 
	L.length = i;  //i的长度即为顺序表的表长 
	return true;
}

5.在有序表中删除s到t之间的元素（包括s和t）

bool DeleteBet1(SqList &L,ElemType s,ElemType t) {
	int i,k = 0;
	if(s >= t || L.length == 0){
		return false;
	}
	for(i = 0; i < L.length; i++){
		if(L.data[i] >= s && L.data[i] <= t){
			k++;
		}
		else
		  L.data[i - k] = L.data[i];
	}
	L.length = L.length - k;
	return true;
}

6.删除顺序表中重复的元素，使其值不同

bool DeleteDupValue(SqList &L){
	int i,k = 0;
	if(L.length == 0){
		return false;
	}
	for (int i = 1; i < L.length; i++){
		if(L.data[i] == L.data[i - 1]){
			k++;
		}
		else{
			L.data[i - k] = L.data[i];
		}	
	}
	return true;
}

6.完整代码

#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <stdio.h>

using namespace std;
#define InitSize 100     //定义初始表长 
typedef int  ElemType; 

typedef struct{
	ElemType * data;   //动态分配数组的指针 
	int length;
	int MaxSize;  //定义最大表长 
}SqList;

/*初始化顺序表*/
bool InitList(SqList &L){
	L.data = (ElemType *)malloc(InitSize*sizeof(ElemType)); //初始化表长
	if(L.data == 0){
		cout << "内存分配出错" << endl;
		return 0; 
	} 
	L.length = 0;
	L.MaxSize = InitSize;
	return true; 
}

/*顺序表的插入（在第i个位置进行插入,i与物理上的位置相对应），插入使用前插法*/
bool SqListInsert(SqList &L,int i,ElemType e){  
	if(i < 0 || i > L.length){
		cout << "插入位置不合理" << endl;
		return false; 	
	} 
	if(L.length == L.MaxSize){  //存储空间已满，追加存储空间 
		L.data = (ElemType*)realloc(L.data,(L.MaxSize+1)*sizeof(ElemType));  //在原来基础上面追加一个空间 
		if(L.data == 0){
		cout  << "存储空间分配失败" << endl;
		return false; 	
		}
	}
	for (int j = L.length; j > i; j--){
		L.data[j] = L.data[j - 1];	
	}
	L.data[i] = e;
	L.length++;
	return true;
} 
/*顺序表删除，在指定位置删除，并返回删除值*/
int SqlListDelete(SqList &L,int addr){
	int e;
	if(addr < 0 || addr > L.length){
		cout << "删除位置不合理" << endl;
		return false; 
	}
	e = L.data[addr];
	for(int i = addr; i < L.length; i ++){
		L.data[i] = L.data[i + 1];
	}
	L.length --;
	return e;	
} 
/*求表长*/
int SqlListLength(SqList L){
	return L.length;
}
/*查找,查找某个特定值，返回下标*/
int FindItem(SqList L,ElemType e){
	for(int i = 0; i < L.length; i++)
	{
		if(L.data[i] == e){
			return i;
		}
	 } 
	return -1;  //
}
/*查找，按照下标位置查找指定值*/
int GetItem(SqList L,int i){
	if(i < 0 || i > L.length){
		cout << "下标越界" << endl;
	}
	return L.data[i];
} 
/*按下标输出所有元素*/
void PrintList(SqList L){
	if(L.length == 0){
		cout << "顺序表为空" << endl; 
		exit(1);  //程序异常退出 
	}
	for(int i = 0; i < L.length; i++)
	{
	  cout << L.data[i] ;
	} 
}
/*删除表中最小元素，空出位置由最后一个元素进行替换*/
int DelSqlMin(SqList &L,int &value) 
{

	if (L.length  == 0 ){
		return 0;
	}
	value = L.data[0];
	int  addr = 0;
	for ( int i = 0; i < L.length; i++){
		if(L.data[i] < value){
			value = L.data[i];
			addr = i;
		}
	}
	L.data[addr] = L.data[L.length - 1];
	//L.length --;
	return value;
}

/*顺序表原地逆质，时间复杂度为O(1)*/
void rever(SqList &L){
	int temp = 0;
	for( int i = 0; i < L.length / 2; i++){
		temp = L.data[i];
		L.data[i] = L.data[L.length - i -1];
		L.data[L.length - i - 1] = temp;
	}
} 
/*删除顺序表中所有值为x的数据元素，时间复杂度为0(n),空间复杂度为o(1)
思想： 使用一个新参数，用来数组重新赋值，存储不为x的元素 
*/
int Deletex(SqList &L,int e){
	int k = 0;
	for(int i = 0; i < L.length; i++){
		if(L.data[i] != e){
			L.data[k] = L.data[i];
			k++;
		}
	}
	L.length = k;
} 
/*在有序表中删除值在s和t之间的所有元素（不包括s和t）
思想：先找出s和t，然后使用t后面的替代s--t之间的值 */
bool DelBetween(SqList &L,ElemType s,ElemType t) {
	int i,j;
	if(s >= t || L.length == 0){
		return false;
	}
	for( i = 0; i < L.length && L.data[i] < s; i++); //寻找开始值区间s的下标 
	if(i >= L.length){   //未找到s 
		return false;
	} 
	for(j = i; j < L.length && L.data[j] <= t; j++);  //寻找区间值为t的下标 
	for(; j < L.length; i++ , j++){   //将s到t区间的值，用t后面的值进行填充 
		L.data[i] = L.data[j];
	} 
	L.length = i;  //i的长度即为顺序表的表长 
	return true;
}
/*在有序表中删除s到t之间的元素（包括s和t）
思想： 先判断值在 s--t 之间的元素个数有几个，然后用t后面的值替代s-t之间的值*/
bool DeleteBet1(SqList &L,ElemType s,ElemType t) {
	int i,k = 0;
	if(s >= t || L.length == 0){
		return false;
	}
	for(i = 0; i < L.length; i++){
		if(L.data[i] >= s && L.data[i] <= t){
			k++;
		}
		else
		  L.data[i - k] = L.data[i];
	}
	L.length = L.length - k;
	return true;
}
/*删除顺序表中重复的元素，使其值不同*/
bool DeleteDupValue(SqList &L){
	int i,k = 0;
	if(L.length == 0){
		return false;
	}
	for (int i = 1; i < L.length; i++){
		if(L.data[i] == L.data[i - 1]){
			k++;
		}
		else{
			L.data[i - k] = L.data[i];
		}	
	}
	return true;
}

/*将两个顺序表合并成一个新表的有序表*/
bool MergeSqlList(SqList &L1,SqList &L2,SqList &L3){
	if(L1.length + L2.length > L3.MaxSize){
		return false;
	}
	int i = 0, j = 0,K = 0;
	while(i < L1.length && j < L2.length){
		if(L1.data[i] < L2.data[j]){
			L3.data[k++] = L1.data[i++];
			L3.length++;
		}
		else{
			L3.data[k++] = L2.data[j++]
			L3.length++;
		}
		while(i < L2.length){
			L3.data[k++] = L2.data[i++];
			L3.length++;
		}
		while(j < L1.length){
			L3.data[k++] = L1.data[j++];
			L3.length++;
		}
	}
}
int main(){
	SqList L;
	InitList(L);
	int value;
	cout << "请输入元素个数：";
	cin >> L.length;
	for (int i = 0; i < L.length; i++){
			L.data[i] = i;
	}
	SqListInsert(L,2,2);  //在第0个位置上面插入10 
//	SqlListDelete(L,2);   //删除下标为2的元素 
	PrintList(L);  //打印所有元素 
//	DelSqlMin(L,value);
//	//rever(L);
    cout << "删除重复值后：";
	DeleteDupValue(L);
	//DelBetween(L,2,3); 
	PrintList(L);
}