天勤2022数据结构（四）数组、矩阵与广义表

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

提示：这里可以添加本文要记录的大概内容：

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、综合应用题

1. 设数组A［0，…，n－1］的n个元素中有多个零元素，设计一个算法，将A中所有的非零元素依次移动到A数组的前端

   void move(int A[], int n){
   	int i = -1, j, temp;
   	for(j = 0; j<n; j++){
   		if(A[j] != 0){
   			i++;
   			if(i != j){
   				temp = A[i];
   				A[i] = A[j];
   				A[j] = temp;
   			}
   		}
   	}
   }
   

2. 关于浮点型数组 A[0，…，n－1］，试设计实现下列运算的递归算法

   • 求数组A中的最大值。

     float findmax(float A[], int i, int j){
     	if(i == j){
     		return A[i];
     	}
     	return A[i] > findmax(A, i+1, j)? A[i]: findmax(A, i+1, j);
     }
     

   • 求数组中n个数之和

     float sum(float A[], int i, int j){
     	if(i == j){
     		return A[i];
     	}
     	return A[i] + sum(A[i], i+1, j);
     }
     

   • 求数组中n个数的平均值

     float avg(float A[], int i, int j){
     	if(i == j){
     		return A[i];
     	}
     	return (A[i] +(j-i) * avg(A, i+1, j)) / (j-i+1);
     }
     

3. 试设计一个算法，将数组 A[0，…，n－1］中 所有奇数移到偶数之前。要求不另增加存储空间，且时间复杂度为O(n）

   void divide(int A[], int n){
   	int i = 0, j = n - 1, temp;
   	while(i<j){
   		while(i<j && A[i]%2 == 1){	找第一个偶数
   			i++;
   		}
   		while(i<j && A[j]%2 == 0){	找最后一个奇数
   			j--;
   		}
   		if(i<j){
   			temp = A{i];
   			A[i] = A{j];
   			A[j] = temp;
   			i++;
   			j--;
   		}
   	}
   }
   

4. 设有一元素为整数的线性表L，存放在一维数组A［0，…，n－1］中，设计一个算法，以A［n－1]为参考量，将该 数组分为左右两个部分 ，其中左半部分的元素值均小于等于A［n－1］，右半部分的元素值均大于A［n－1］，A［n－1］则位于这两部分之间要求结果仍存放在数组A中

   快排划分

   void divide(int A[], int n){
   	int temp;
   	int i = 0, j = n - 1;
   	temp = A[i];
   	A[i] = A[j];
   	A[j] = temp;
   	temp = A[i];	相当与把n-1位置元素放到0位置上，仍以0位置元素为参考量
   	while(i!=j){
   		while(i<j && A[j]>temp)	后往前 找第一个比temp小的数
   			j--;
   		if(i<j){
   			A[i] = A[j];
   			i++;
   		}
   		while(i<j && A[i]<temp){ 前往后 找第一个比temp大的数
   			j++
   		if(i<j){
   			A[j] = A[i];
   			j--;
   		}
   	}
   	A[i] = temp;
   }
   

5. 设计一个算法，对给定的一个整型$m\times n$矩阵A，统计这个矩阵中具有下列特征的元素个数并输出它们的坐标及数值：它们既是所在行中的最小值，又是所在列中的最小值；或者它们既是所在行中的最大值，又是所在列中的最大值。假设矩阵中元素各不相同，要求结果在处理过程中用输出语句输出

   三重循环
   第一重 第二重：行最小
   第三重：列最小

   void printmin(int A[][maxSize], int m, int n){
   	int i, j, k, min, minIndex;
   	int flag;
   	for(i = 0; i<m; i++){
   		min = A[i][0];
   		minIndex = 0;
   		for(j = 0; j<n; j++){
   			if(A[i][j] < min){
   				min = A[i][j];
   				minIndex = j;
   			}
   			flag = 1;
   			for(k = 0; k<m; k++){
   				if(min>A[k][minIndex]){
   					flag = 0;
   					break;
   				}
   			}
   			if(flag)
   				cout<<min<<",["<<i<<","<<minIndex<<"]"<<" ";
   		}
   		cout<<end;
   	}
   }
   
   void printmax(int A[][maxSize], int m, int n){
   	int i, j, k, max, maxIndex;
   	int flag;
   	for(i = 0; i<m; i++){
   		max = A[i][0];
   		maxIndex = 0;
   		for(j = 0; j<n; j++){
   			if(A[i][j] > max){
   				max = A[i][j];
   				maxIndex = j;
   			}
   			flag = 1;
   			for(k = 0; k<m; k++){
   				if(max<A[k][maxIndex]){
   					flag = 0;
   					break;
   				}
   			}
   			if(flag)
   				cout<<max<<",["<<i<<","<<maxIndex<<"]"<<" ";
   		}
   		cout<<end;
   	}
   }
   

6. 简要介绍稀疏矩阵的三元组存储结构特点，并实现稀疏矩阵的基本操作。

   1. 给定稀疏矩阵A（int型），创建其三元组存储结构B

        三元组存储结构是一种顺序结构，是顺序表。表中每个结点对应稀疏矩阵的一个非零元素，其中包括3个字段，分别为该元素的值，行下标和列下标。
        用第0行的第1个元素存储矩阵中非零元素的个数，第0行的第2个元素存储矩阵的行数，第0行的第3个元素存储矩阵的列数

      void create(int A[][maxSize], int m, int n, int B[][3]){
      	int i, j;, k = 1;
      	for(i = 0; i<m; i++){
      		for(j = 0; j<n; j++){
      			if(A[i][j] != 0){
      				B[k][0] = A[i][j];		值
      				B[k][1] = i;			行标
      				B[k][2] = j;			列标
      			}
      		}
      	}
      }
      

   2. 查找给定元素x是否在矩阵中。

      int search(int B[][3], int x){
      	int i, t;
      	t = B[0][0];	非零元素个数
      	i = 1;
      	while(i<t && B[i][0]!=x){
      		i++;
      	}
      	if(i<=t){
      		return 1;
      	}else{
      		return 0;
      	}
      }
      

7. 假设稀疏矩阵A采用三元组表示，编写一个函数，计算其转置矩阵B，要求B也采用三元组表示。

   两重循环 $colSize\times elemSize$

   void transpose(int A[][3], int B[][3]){
   	B[0][0] = A[0][0];
   	B[0][1] = A[0][2];
   	B[0][2] = A[0][1];
   	int index = 1;
   	if(B[0][0]>0){
   		for(int col = 0; col<B[0][1]; col++){
   			for(int j = 1; j<=B[0][0]; j++){
   				if(A[j][2] == col){
   					B[index][0] = A[j][0];
   					B[index][1] = A[j][2];
   					B[index][2] = A[j][1];
   				}
   			}
   		}
   	}
   }
   

8. 假设稀疏矩阵A和B（两矩阵行列数对应相等）都采用三元组表示，编写一个函数，计算C=A+B，要求C也采用三元组表示，所有矩阵均为int型。

   注意 相加可能为0

   void add(int A[][3], int B[][3], int C[][3]){
   	int i=1, j=1, k=1, m;
   	while(i<=A[0][0] && j<=B[0][0]){
   		if(A[i][1] == B[j][1]){
   			if(A[i][2] < B[j][2]){
   				C[k][0] = A[i][0];
   				C[k][1] = A[i][1];
   				C[k][2] = A[i][2];
   				k++;i++;
   			}else if(A[i][2] > B[j][2]){
   				C[k][0] = B[j][0];
   				C[k][1] = B[j][1];
   				C[k][2] = B[j][2];
   				k++;j++;
   			}else{
   				m = A[i][0] + B[j][0];
   				if(m!=0){
   					C[k][0] = m;
   					C[k][1] = A[j][1];
   					C[k][2] = A[j][2];
   					k++;
   				}
   				i++;j++;
   			}
   		}else if(A[i][1] < B[j][1]){
   			C[k][0] = A[i][0];
   			C[k][1] = A[i][1];
   			C[k][2] = A[i][2];
   			k++;i++;
   		}else{
   			C[k][0] = B[j][0];
   			C[k][1] = B[j][1];
   			C[k][2] = B[j][2];
   			k++;j++;
   		}
   	}
   	while(i<=A[0][0]){
   		C[k][0] = A[i][0];
   		C[k][1] = A[i][1];
   		C[k][2] = A[i][2];
   		k++;i++;
   	}
   	while(j<=B[0][0]){
   		C[k][0] = B[j][0];
   		C[k][1] = B[j][1];
   		C[k][2] = B[j][2];
   		k++;j++;
   	}
   	C[0][0] = k - 1;
   	C[0][1] = A[0][1];
   	C[0][2] = A[0][2];
   }
   

9. 假设稀疏矩阵A和B（分别为$m\times n$和$n\times k$矩阵）采用三元组表示，编写一个函数，计算$C=A\times B$，要求$C$也是采用三元组表示的稀疏矩阵。

   int getValue(int D[][maxSize], int i, int j){
   	int k = 1;
   	while(k<=D[0][0] && (D[k][1] != i || D[k][2] != j))
   		k++;
   	if(k<=D[0][0])
   		return D[k][0];
   	else
   		return 0;
   }
   void mul(int A[][3], int B[][3], int C[][3], int m, int n, int k){
   	int i, j, l, p=1, s;
   	for(i = 0; i<m; i++){
   		for(j = 0; j<k; j++){
   			s = 0;
   			for(l = 0; l<n; l++){
   				s += getValue(A, i, l) * getValue(B, l, j);
   				if(s != 0){
   					C[p][0] = s;
   					C[p][1] = i;
   					C[p][2] = j;
   					p++;
   				}
   			}
   		}
   	}
   	C[0][0] = p-1;
   	C[0][1] = m;
   	C[0][2] = k;
   }
   

总结

提示：这里对文章进行总结：