王道第二章【线性表】

1.

bool findMin(Sqlist *&L,int &value)
{ //删除顺序表L中最小值元素结点，并通过引用型草书value返回其值
  //若删除成功，则返回true,否则返回false
 	if(L.length == 0)
		return 0;
	int i;
	value = L.data[0];
	int minPosition = 0;
	for(i=1;i<L.length;i++) 
	{
		if(L.data[i] < min)
		{
			value = L.data[i]; //让value记忆当前具有最小值的元素
			minPosition = i;
		}
	}
	L.data[minPosition] = L.data[L.length-1]; //空出的位置由最后一个元素填补
	L.length--;
	return true; //此时value即为最小值
}

2.

void Reverse(Sqlist &L)
{
	int i,j;
	int temp;
	for(i=0,j=L.length-1;i<j;i++,j--)
	{
		temp = L.data[i];
		L.data[i] = L.data[j];
		L.data[j] = temp;
	}
}

3.

void Delete(Sqlist &L,int x)
{ //本算法实现删除顺序表L中所有值为x的数据元素
	int i,k = 0; //记录值不等于x的元素个数
	for(i=0;i<L.length;i++)
	{
		if(L.data[i] != x)
		{
			L.data[k] = L.data[i];
			k++; //不等于x的元素增1
		}
	}
	L.length = k; //顺序表L的长度等于k
}

void Delete(Sqlist &L,int x)
{
	int k = 0,i = 0; //k记录值等于x的元素个数
	while(i < L.length)
	{
		if(L.data[i] == x)
			k++;
		else
			L.data[i-k] = L.data[i]; //当前元素前移k个位置
		i++;
	}
	L.length = L.length-k; //顺序表L的长度递减
}

4.

bool Delete(Sqlist &L,int s,int 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)
		return false; //所有元素值均小于s，返回
	for(j=i;j < L.length && L.data[j] <= t;j++); //寻找值大于t的第一个元素
	for(;j < L.length;i++,j++)
		L.data[i] = L.data[j]; //前移，填补被删元素位置
	L.length = i;
	return true;
}

5.

bool Delete(Sqlist &L,int s,int t)
{//删除顺序表L中值在给定值s和t之间（要求s<t）的所有元素
	int i,k=0;
	if(s >= t || L.length == 0)
		return false; //线性表为空或s、t不合法
	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]; //当前元素前移k个位置
	}
	L.length -= k; //长度减小
	return true;
}

6.

bool Delete(Sqlist &L)
{
	if(L.length == 0)
		return false;
	int i,j; //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;
}

7.

typedef struct
{
	int *data; //指示动态分配数组的指针
	int MaxSize; //数组的最大容量
	int length; //数组的当前个数
}Seqlist;
bool Merge(Seqlist A,Seqlist B,Seqlist &C)
{//将有序顺序表A与B合并为一个新的有序顺序表C
	if(A.length+B.length > C.MaxSize) //大于顺序表的最大长度
		return false;
	int i=0,j=0,k=0;
	while(i < A.length && j < B.length) //循环，两两比较，小者存入结果表
	{
		if(A.data[i] <= B.data[j])
			C.data[k++] = A.data[i++];
		else
			C.data[k++] = B.data[j++];
	}
	while(i < A.length) //还剩一个没有比较完的顺序表
		C.data[k++] = A.data[i++];
	while(j < A.length)
		C.data[k++] = B.data[j++];
	C.length = k;
	return true;	
}

8.

void Reverse(int A[],int left,int right,int arraySize)
{
	if(left >= right || right >= arraySize)
		return;
	int i,j;
	int temp;
	for(i=left,j=right;i<j;++i,--j)
	{
		temp = A[i];
		A[i] = A[j];
		A[j] = temp;
	}
}
void Exchange(int A[],int m,int n,int arraySize)
{
	Reverse(A,0,m+n-1,arraySize);
	Reverse(A,0,n-1,arraySize);
	Reverse(A,n,m+n-1,arraySize);
}

9.

void SearchExchangeInsert(int A[],int x)
{
	int low = 0,high = A.length-1,mid;
	int temp;
	while(low <= high)
	{
		mid = (low + high) / 2;
		if(A[mid] == x)
			break;
		else if(A[mid] < x)
			low = mid + 1;
		else
			high = mid - 1;
	}
	if(A[mid] == x && mid != A.length-1)
	{
		temp = A[mid];
		A[mid] = A[mid+1];
		A[mid+1] = temp;
	}
	if(low > high) //查找失败 如果比x大，high前移，比x小，low后移
							//无论如何，high所指位置的后面就是要插入的位置
	{
		for(i=n-1;i>high;i--) //后移元素
			A[i+1] = A[i];
		A[i+1] = x; //插入x
	}
}

10.

void Reverse(int R[],int left,int right)
{
	int i,j;
	int temp;
	for(i=left,j=right;i<j;++i,--j)
	{
		temp = R[i];
		R[i] = R[j];
		R[j] = temp;
	}
}
void Exchange(int R[],int n,int p)
{
	if(p <= 0 || p >= n)
		return;
	else
	{
		Reverse(R,0,p-1);
		Reverse(R,p,n-1);
		Reverse(R,0,n-1);
	}	
}

11.

int Search(int A[],int B[],int n)
{
	int s1 = 0,d1 = n-1,m1,s2 = 0,d2 = n-1,m2;
	//分别表示A和B的首位数、末尾数和中位数
	while(s1 != d1 || s2 != d2)
	{
		m1 = (s1+d1)/2;
		m2 = (s2+d2)/2;
		if(A[m1] == B[m2])
			return A[m1];
		if(A[m1] < B[m2])
		{
			if((s1+d1)%2 == 0) //若元素个数为奇数
			{
				s1 = m1; //舍弃A中间点以前的部分且保留中间点
				d2 = m2; //舍弃B中间点以后的部分且保留中间点
			}
			else //若元素个数为偶数
			{
				s1 = m1 + 1; //舍弃A中间点及中间点以前部分
				d2 = m2; //舍弃B中间点以后部分且保留中间点
			}
		}
		else
		{
			if((s2+d2)%2 == 0) //若元素个数为奇数
			{
				d1 = m1; //舍弃A中间点以后的部分且保留中间点
				s2 = m2; //舍弃B中间点以前的部分且保留中间点
			}
			else
			{
				d1 = m1; //舍弃A中间点以后部分且保留中间点
				s2 = m2 + 1; //舍弃B中间点及中间点以前部分
			}
		}
	}
	return A[s1] < B[s2]? A[s1]:B[s2];
} //时间复杂度O(log2n),空间复杂度O(1)

12.

int JudgeMainElem(int A[],int n)
{
	int i,c,count = 1; //c用来保存候选元素，count用来计数
	c = A[0];
	for(i=1;i<n;i++) //查找候选元素
	{
		if(A[i] == c)
			count++; //对A中候选元素计数
		else
		{
			if(count > 0) //处理不是候选主元素的情况
				count--;
			else //更换候选元素，重新计数
			{
				c = A[i];
				count = 1;
			}
		}
	}
	if(count > 0)
	{
		for(i=count=0;i<n;i++) //统计候选元素的实际出现次数
		{
			if(A[i] == c)
				count++;
		}
	}
	if(count > n/2) return c;
	else return -1;	
} //时间复杂度为O(n),空间复杂度为O(1)

13.

int findMissMin(int A[],int n)
{
	int i,*B;
	B = (int *)malloc(sizeof(int)*n); //分配空间
	for(i=0;i<n+1;i++) //为B数组赋初值
		B[i] = 0;
	for(i=0;j<n;j++)
	{
		if(A[i] > 0 && A[i] <= n)
			B[A[i]-1] = 1;
	}
	for(i=0;i<n;i++)
	{
		if(B[i] == 0)
			break;
	}
	return i+1;
}//时间复杂度为O(n)，空间复杂度为O(n)