So konvertieren Sie das ursprüngliche Array in ein Sparse-Array in Java

1 Was ist das?

Wenn es beispielsweise ein 11 * 11 Backgammon-Brett gibt und wir es mit einem Programm simulieren möchten, muss es ein zweidimensionales Array sein. Verwenden Sie dann 1, um den schwarzen Stein darzustellen, und 2, um den weißen Stein darzustellen, wenn es nur einen schwarzen Stein und einen weißen Stein auf dem Schachbrett gibt, dann gibt es in dieser zweidimensionalen Anordnung nur eine 1 und eine 2 und die anderen sind bedeutungslose Nullen, die keine Schachfiguren darstellen, wie folgt:

0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 1 0 0 0 0 0 0
0 0 0 2 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
……

Wenn die meisten Elemente in einem Array 0 sind oder denselben Wert haben, können Sie ein Sparse-Array verwenden, um das Array zu speichern . Warum das tun? Weil es Platz sparen kann.

2. Wie verwende ich?

• Zeichnen Sie auf, wie viele Zeilen, Spalten und wie viele verschiedene Werte es im ursprünglichen Array gibt

#🎜🎜 ##🎜🎜 #Zeichnen Sie die Zeilen, Spalten und Werte von Elementen mit unterschiedlichen Werten in einem kleinen Array auf. Dieses kleine Array wird als Sparse-Array bezeichnet

Das vorhandene 6 * 7-Originalarray ist wie folgt:

0   0   0   22   0   0   15
0   11  0   0    0   17   0
0   0   0  -6    0   0    0
0   0   0   0    0   39   0
91  0   0   0    0   0    0
0   0   28  0    0   0    0

Zuerst, die erste Zeile und Die erste Spalte des Sparse-Arrays dient dazu, aufzuzeichnen, wie viele Zeilen das Elementarray hat. Die erste Zeile und die zweite Spalte zeichnen auf, wie viele Spalten das ursprüngliche Array hat, und die erste Zeile und die dritte Spalte zeichnen auf, wie viele verschiedene Werte das Original hat Array hat (außer 0). Eine Zeile des Sparse-Arrays sollte also wie folgt aussehen:

行    列    值
6     7     8

Beginnend mit der zweiten Zeile des Sparse-Arrays zeichnet jede Zeile die Zeile, Spalte und Wertgröße des Nicht-0-Werts im ursprünglichen Array auf . Wenn die zweite Zeile beispielsweise die Zeile, Spalte und den Wert von 22 im ursprünglichen Array aufzeichnen soll, lautet die zweite Zeile des Sparse-Arrays:

行    列    值
0     3     22

Verwenden Sie dann diese Methode, um 15 aufzuzeichnen , 11, 17, -6, 39 , 91, 28 verwandte Informationen, sodass das aus dem ursprünglichen Array schließlich konvertierte Sparse-Array lautet:

行    列    值
6     7     8
0     3     22
0     6     15
1     1     11
1     5     17
2     3     -6
3     5     39
4     0     91
5     2     28

Auf diese Weise wird ein 6 * 7-Array in ein umgewandelt 9 * 3-Array, um den Komprimierungseffekt zu erzielen.

Original-Array in Sparse-Array:

# 🎜🎜#

• Sie können ein spärliches Array basierend auf der Anzahl erstellen
;

• int[count + 1][3]

  Gültiges Array im Sparse-Array speichern

• Sparse-Array in ursprüngliches Array: # 🎜🎜#

Anhand der ersten Zeile des Arrays können Sie ermitteln, wie viele Zeilen und Spalten das ursprüngliche Array hat, und dann das Array erstellen ursprüngliches Array;

• Lesen Sie das Array der letzten Zeilen des Sparse-Arrays und weisen Sie es dem ursprünglichen Array zu

• 5. Code tatsächlich Fuck:

public class SparseArray {
    public static void main(String[] args){
        // 创建一个 11 * 11的原始数组
        int[][] arr1 = new int[11][11];
        arr1[1][2] = 1;
        arr1[2][3] = 2;

        // 原始数组转稀疏数组
        // 1. 遍历，得到非0数据的个数以及所在的行列
        int count = 0;
        Map<String, Integer> map = new HashMap<>();
        for (int i = 0; i < arr1.length; i++) {
            for (int j = 0; j < arr1[i].length; j++) {
                if (arr1[i][j] != 0){
                    count ++;
                    map.put(i+ "," + j, arr1[i][j]);
                }
            }
        }
        // 2. 创建稀疏数组
        int[][] sparseArr = new int[count + 1][3];
        sparseArr[0][0] = arr1.length;
        sparseArr[0][1] = arr1[0].length;
        sparseArr[0][2] = count;
        // 3. 给稀疏数组赋值
        int row = 1;
        for (String key : map.keySet()){
            String[] ij = key.split(",");
            int i = Integer.parseInt(ij[0]);
            int j = Integer.parseInt(ij[1]);
            sparseArr[row][0] = i;
            sparseArr[row][1] = j;
            sparseArr[row][2] = map.get(key);
            row ++;
        }
        // 4. 遍历稀疏数组
        for (int i = 0; i < sparseArr.length; i++) {
            for (int j = 0; j < sparseArr[i].length; j++) {
                System.out.print(sparseArr[i][j] + "   ");
            }
            System.out.println("\r\n");
        }

        // 稀疏数组恢复原始数组
        // 1. 根据第一行第一列第二列创建出原始数组
        int i = sparseArr[0][0];
        int j = sparseArr[0][1];
        int[][] arr2 = new int[i][j];
        // 2. 给原始数组赋值
        for (int k = 1; k < sparseArr.length; k++) {
            int x = sparseArr[k][0];
            int y = sparseArr[k][1];
            int val = sparseArr[k][2];
            arr2[x][y] = val;
        }
        // 3. 遍历转换的数组
        for (int a = 0; a < arr2.length; a++) {
            for (int b = 0; b < arr2[a].length; b++) {
                System.out.print(arr2[a][b] + "   ");
            }
            System.out.println("\r\n");
        }
    }
}

Das obige ist der detaillierte Inhalt vonSo konvertieren Sie das ursprüngliche Array in ein Sparse-Array in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!