若干年后自己是否会想起在这里的加密

编写java三元组表与矩阵之间的转换

三元组节点类
public class TripleNode {

    private int row;
    private int column;
    private double value;
    public TripleNode(int row ,int column,double value){
        super();
        this.row=row;
        this.column=column;
        this.value=value;

    }
    public TripleNode(){

        this(0,0,0);
    }

    public int getRow() {
        return row;
    }

    public void setRow(int row) {
        this.row = row;
    }
    /**
     * @return the column
     */
    public int getColumn() {
        return column;
    }
    /**
     * @param column the column to set
     */
    public void setColumn(int column) {
        this.column = column;
    }
    /**
     * @return the value
     */
    public double getValue() {
        return value;
    }
    /**
     * @param value the value to set
     */
    public void setValue(double value) {
        this.value = value;
    }

    public String toString(){

        return "[("+row+","+column+")," +value+"]";
    }


}

下面是矩阵类数组类

public class SparseArray {

    private TripleNode[] data;
    private int rows;
    private int cols;
    private int nums;
    public TripleNode[] getDate() {
        return data;
    }

    public void setDate(TripleNode[] data) {
        this.data = data;
        this.nums=data.length;
    }

    public int getRows() {
        return rows;
    }

    public void setRows(int rows) {
        this.rows = rows;
    }

    public int getCols() {
        return cols;
    }

    public void setCols(int cols) {
        this.cols = cols;
    }

    public int getNums() {
        return nums;
    }

    public void setNums(int nums) {
        this.nums = nums;
    }

    public SparseArray(int maxSize){
        data=new TripleNode[maxSize];
        for(int i=0;i<data.length;i++){
            data[i]=new TripleNode();

        }   
        rows=0;
        cols=0;
        nums=0;
    }

    public SparseArray(double [][]  arr){
        this.rows=arr.length;
        this.cols=arr[0].length;
        for(int i=0;i<arr.length;i++){
            for(int j=0;j<arr[0].length;j++ ){
                if(arr[i][j]!=0){
                    nums++;
                }
            }
        }
        //根据上面统计的非0数据的个数，将每一个非0元素进行保存

        data=new TripleNode[nums];
        for(int i=0,k=0;i<arr.length;i++){
            for(int j=0;j<arr[0].length;j++){
                if(arr[i][j]!=0){
                    data[k]=new TripleNode(i,j,arr[i][j]);
                    k++;
                }

            }
        }
    }

    public void printArrayOfRC(){

        System.out.println("稀疏矩阵的三元素存储结构为：");
        System.out.println("行数："+rows+"，列数："+cols+"，非0元素的个数："+nums);
        System.out.println("行下标                                                                                             列下标                                                                                      元素值");
        for(int i=0;i<nums;i++){
            System.out.println(""+data[i].getRow()+"                                   "
                    +data[i].getColumn()+"                                   "+data[i].getValue());


        }
    }
    public void printArr(){

        System.out.println("稀疏矩阵的多维数组存储结构为");
        System.out.println("行数："+rows+"列数："+cols+"，非0元素的个数："+nums);
        double [][] origArr=reBackToArr();
        for (int i = 0; i < origArr.length; i++){
            for (int j = 0; j < origArr[i].length; j++) {
                System.out.print(origArr[i][j]+"\t");
            }
                System.out.println("\n");
            }
        System.out.println("\n");
        }

    private double[][] reBackToArr() {
        double [][] arr=new double[rows][cols];
        for(int i=0;i<nums;i++){
            arr[data[i].getRow()][data[i].getColumn()]=data[i].getValue();

        }
        return arr;
    }

    public SparseArray transpose(){

        SparseArray tm=new SparseArray(nums); //创建一个转制后的矩阵对象
        tm.cols=rows;  //行变化，非零个数不变
        tm.rows=cols;
        tm.nums=nums;
        int q=0;
        for(int col=0;col<cols;col++){
            for(int p=0;p<nums;p++){
                if(data[p].getColumn()==col){
                    tm.data[q].setColumn(data[p].getRow());
                    tm.data[q].setRow(data[p].getColumn());
                    tm.data[q].setValue(data[p].getValue());
                    q++;
                }
            }

        }
        return tm;
    }
    public SparseArray fastTranspose(){

        /*
         * 首先将位置进行预留，然后再"填空" 。 num[cols] ； 每个“空”的大小。
         * copt【cols】   每个‘空的起始位置’
         * 
         */
        SparseArray tm=new SparseArray(nums);
        tm.cols=rows; //行变化非零元素不变
        tm.rows=cols;
        tm.nums=nums;
        int tCol=0,indexOfC=0;
        if(nums>0){
            int[]num=new int [cols]; //原始矩阵中第col列的非零元素的个数
            int[]copt=new int [rows];   //初始值为N中的第col列的第一个非零元素在tm中的位置

            //初始化num和copt数组

            for(int i=0;i<nums;i++){
                tCol=data[i].getColumn();
                num[tCol]++;
            }
            copt[0]=0;
            for(int i=0;i<cols;i++){
                copt[i]=copt[i-1]+num[i-1];
            }
            //找到每个元素转制后的三元组中的位置
            for(int i=0;i<nums;i++){
                tCol=data[i].getColumn();   //取得扫描TN的第一个元素的列值 tCol
                indexOfC=copt[tCol];        //取得该tcol列的下一个元素应该存储的位置
                tm.data[indexOfC].setRow(data[i].getColumn());      
                tm.data[indexOfC].setColumn(data[i].getRow());      
                tm.data[indexOfC].setValue(data[i].getValue());
                copt[tCol]++;       //此时的copt【col】表示的是下一个该col列元素会存储的位置

            }
        }
        return tm;
    }

}

这是自己的秘钥：151215324512304520404530040203250431
希望自己若干年会看起这片日子解密出来。
大家不要管这些这是我自己的私有日志。

---

2016.1.5 —————————————–matx