Estructuras de Datos y Algoritmos (d) - las distintas operaciones de la forma lineal

Más de 800, según el código directamente mensaje +

Manifestación:

/**删除顺序表中最小值，由最后的元素填补这个位置**/
bool Del_Min(sqList &L , ElemType &value)
{
	if(L.length == 0)
		return false;
	value = L.data[0];
	int pos = 0;
	for(int i = 1; i<L.length; i++)
		if(L.data[i]<value)
		{
			value = L.data[i];
			pos = i;
		}
	L.data[pos] = L.data[L.length - 1];
	L.length--;
	return true; 
}


/*设计一个高效算法，将顺序表的所有元素逆置，要求空间复杂度为O(1)*/
void Reverse(Sqlist &L)
{
	ElemType temp;
	for(i=0;i<L.length;i++)
	{
		temp = L.data[i];
		L.data[i] = L.data[L.length-i-1];
		L.data[L.length-i-1] = temp;	
	}	
}

/**长度为n的顺序表L,编写一个时间复杂度为O(n)、空间复杂度为O(1)的算法，该算法删除线性表中所有值为x的数据元素**/
void del_x_1(Sqlist &L, ElemType x)
{
	int k = 0;
	for(i = 0; i<L.length; i++)
		if(L.data[i]!= x)
		{
			L.data[k] = L.data[i];
			k++;
		}
	L.length = k;
}

/**从有序顺序表表中删除其值在给定值s到t之间(要求s<t)的所有元素，如果s或t不合理或者顺序表为空则显示出错信息并退出运行**/
bool Del_s_t(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++);
	if(i>=L.length)
		return false;
	for(j=i;j<L.length&&L.data[i]<=t;j++);
	for(;j<L.length;i++;j++)
		L.data[i]=L.data[j];
	L.length = i+1;
	return true;
}

/**从有序顺序表表中删除其值在给定值s到t之间(包含s和t，要求s<t)的所有元素，如果s或t不合理或者顺序表为空则显示出错信息并退出运行**/
bool Del_s_t(SqList &L , ElemType s, ElemType t)
{
	int i , k = 0;
	if(L.length == 0 || s>t )
	{
		return false;
	}
	for(i=0;i<L.length;i++)
	{
		if(L.data[i]>=s && L.data[i]<=t)
		{
			k++;			//统计s-t之间的元素个数 
		}
		else
		L.data[i-k] = L.data[i];	// 将后面的元素前移 
	}
	L.length -= k;			//长度减小k个单位 
	return true;
}

/*从有序表中删除所有其值重复的元素，使表中的所有元素值均不同*/
bool Delete_Same(SqList &L)
{
	if(L.length==0)
		return false;
	int i,j;
	for(i=0,j=1;j<L.length;j++)	//先将第一个位置的元素和其他地方一一对比
		if(L.data[i]!=L.data[j])	//比较判断，如果不匹配
			L.data[++i]=L.data[j];	//将每个元素和每一次的位置对比
	L.length = i+1;		//长度是不相同元素的个数
	return true; 
 }

/*将两个有序表合并成一个新的有序顺序表*/
bool Merge(SqList A, SqList B, SqList &C)
{
	if(A.length+B.length>C.maxSize)	//A和B的长度不能超过最大容量
		return false;
	int i = 0, j = 0, k = 0;	
	while(i<A.length || j<B.length)		//在A和B的长度范围内
	{
		if(A.data[i]<B.data[j])			//将小的元素先放进去
			C.data[k++] = A.data[i++];	//同步到下个位置
		else
			C.data[k++] = B.data[j++];
	} 
	while(i<A.length)				//当较短的表比较结束，i和j都停止自增
		C[k++] = A.data[i++];		//将还没比较完的表后面的元素直接插入
	while(j<B.length)
		C[k++] = B.data[j++]; 
	return true;
 }

/*在A[m+n]数组中依次存放着两个线性表(a1,a2,...an)(b1,b2,...bn)，将两个顺序表位置互换b放在a前面*/
 typedef int DataType;
 void Reverse(DataType A[], int left, int right, int arraySize) 
 {
 	if(left>=right||right>=arraySize)
 		return ;
	int mid = (left+right)/2;
	for(int i=0;i<mid-left;i++)
		DataType temp = A[left+i];
		A[left+i] = A[right-i];	//将第一个和最后一个互换位置
		A[right-i] = temp;		//位置递增或递减
 }
void Exchange(DataType A[], int m, int n, int arraySize)
 {
 	Reverse(A,0,m+n-1,arraySize);		//先全体反转
 	Reverse(A,0,n-1,arraySize);		//b1-bn到了左侧，反转0到n-1的元素
 	Reverse(A,n,m+n-1,arraySize);		//反转n到最后的右侧元素
 }

/*线性表中的元素递增有序且按照顺序存储，以最少的时间查找值为x的元素，并将其与后继元素交换，若找不到则将其插入表中使元素递增有序*/
void SearchExchangeInsert(ElemType A[], ElemType x)
{
	int low=0,high=n-1,mid;
	while(low<=high)		//从头开始 
	{
		mid = (low+high)/2;	//二分查找 
		if(A[mid]==x)		//找中间位置 
			break;			//找到退出 
		else if(A[mid]<x)	//中间值小于x 
			low = mid+1;	//查找的最小值位置加1，在右侧查找
		else				//中间值大于x 
			high = mid-1;	//查找的最大值位置减1，在左侧查找
	}	
	if(A[mid]==x && mid!=n-1)	//中间位置的值是x
	{
		t = A[mid]; A[mid] = A[mid+1]; A[mid+1] = t;	//交换元素 
	}
	if(low>high)		//表中查不到的话 
	{
		for(i=n-1;i>high;i--)	 //从最后元素到排序的位置开始
			A[i+1] = A[i];	//后移元素 
		A[i+1] = x;			//在排序的位置后插入x 
	}
}