数据结构与算法 三元组顺序对矩阵转置（稀疏数组的压缩、三元组转置）Java实现

三元组顺序对矩阵转置
步骤：

1. 构造一个三元组，i,j,data
2. 输入一个二维矩阵
3. 将二维矩阵转成三元组
4. 一个num数组，存每一列的非0元素的个数
5. 一个cpot数组，存每一列第一个每0元素在new_triple中的位置
6. 用一个for循环，利用cpot找到转置后的的位置，然后行列交换就ok了
7. 打印原二维数组、转置前的三元组、转置后的三元组

package 数据结构实验;

import java.util.Arrays;
import java.util.Scanner;


public class MyTriple {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        int[][] arr = new int[n][m];

        int i, j, k = 0;
        Triple[] pre_Triple = new Triple[100];
        Triple[] new_Triple = new Triple[100];



        //2. 输入一个二维矩阵
        for(i = 0; i < n; i++) {
            for(j = 0; j < m; j++) {
                arr[i][j] = sc.nextInt();
            }
        }

        //3. 将二维矩阵转成三元组
        for(i = 0; i < n; i++) {
            for(j = 0; j < m; j++) {
                if(arr[i][j] != 0) {
                    pre_Triple[k++] = new Triple(i,j,arr[i][j]);
                }
            }
        }

        int[] num = new int[k];
        int[] cpot = new int[k];
        //4. 一个num数组，存每一列的非0元素的个数
        for(i = 0; i < k; i++) {
            for(j = 0; j < k; j++) {
                if(pre_Triple[j].j == i) {
                    num[i]++;
                }
            }
        }

        //5. 一个cpot数组，存每一列第一个每0元素在new_triple中的位置
        //cpot[0] = 0;
        for(i = 1; i < k; i++) {
            cpot[i] = cpot[i-1] + num[i-1];
        }

        //6. 用一个for循环，利用cpot找到转置后的的位置，然后行列交换就ok了
        int col = 0;
        int q = 0;
        for( i = 0; i < k; i++) {
            //每一行的元素都根据num数组，安排了足够的空间
            col = pre_Triple[i].j;
            q = cpot[col];
            new_Triple[q] = new Triple(pre_Triple[i].j,pre_Triple[i].i, pre_Triple[i].data);
            cpot[col]++;
        }

        //7. 打印原二维数组、转置前的三元组、转置后的三元组
        System.out.println("二维矩阵");
        for(int p[] : arr) {
            System.out.println(Arrays.toString(p));
        }
        System.out.println("转置前的三元组");
        for (i = 0; i < k; i++) {
            System.out.println(pre_Triple[i].i + " " + pre_Triple[i].j + " " + pre_Triple[i].data);
        }
        System.out.println("转置后的三元组");
        for (i = 0; i < k; i++) {
            System.out.println(new_Triple[i].i + " " + new_Triple[i].j + " " + new_Triple[i].data);
        }
    }
}

//1. 构造一个三元组，i,j,data
class Triple {
    int i;//行
    int j;//列
    int data;//值

    public Triple(int i, int j, int data) {
        this.i = i;
        this.j = j;
        this.data = data;
    }
}