Bagaimanakah cubaan boleh digunakan untuk melaksanakan matriks jarang dengan cekap?

Matriks jarang boleh dilaksanakan dengan cekap menggunakan cubaan, yang menyediakan akses pantas kepada elemen matriks tertentu dengan mengira sama ada unsur hadir dalam jadual menggunakan hanya dua operasi pengindeksan tatasusunan.

Ciri Utama Percubaan:

• Sediakan kedudukan lalai dalam stor sokongan untuk nilai lalai, menghapuskan keperluan untuk ujian nilai.
• Sokongan yang boleh dikemas kini dengan pantas cuba dengan operasi "compact()" pilihan untuk mengoptimumkan saiz stor sokongan.
• Gunakan pemetaan objek, membenarkan pemetaan koordinat ke kedudukan integer dalam vektor.
• Kendalikan pengambilan semula subjulat dengan pantas untuk capaian data yang lebih pantas.

Kelebihan:

• Perlaksanaan percubaan adalah jauh lebih pantas daripada peta cincang, mengelakkan fungsi pencincangan yang kompleks dan pengendalian perlanggaran.
• Peta cincang Java hanya mengindeks pada Objek, yang berpotensi membawa kepada overhed memori dan tekanan pengumpulan sampah.
• Percubaan menyediakan pelaksanaan yang cekap yang tidak memerlukan penciptaan objek untuk setiap indeks sumber, mengurangkan operasi memori.

Contoh Pelaksanaan:

<code class="java">public class DoubleTrie {

    // Matrix options
    private static final int SIZE_I = 1024;
    private static final int SIZE_J = 1024;
    private static final double DEFAULT_VALUE = 0.0;

    // Internal splitting options
    private static final int SUBRANGEBITS_I = 4;
    private static final int SUBRANGEBITS_J = 4;

    // Internal splitting constants
    private static final int SUBRANGE_I =
            1 << SUBRANGEBITS_I;
    private static final int SUBRANGE_J =
            1 << SUBRANGEBITS_J;
    private static final int SUBRANGEMASK_I =
            SUBRANGE_I - 1;
    private static final int SUBRANGEMASK_J =
            SUBRANGE_J - 1;

    // Internal data
    private double[] values;
    private int[] subrangePositions;

    // Fast subrange and position computation methods
    private static int subrangeOf(int i, int j) {
        return (i >> SUBRANGEBITS_I) * SUBRANGE_J + (j >> SUBRANGEBITS_J);
    }
    private static int positionOffsetOf(int i, int j) {
        return (i & SUBRANGEMASK_I) * SUBRANGE_J + (j & SUBRANGEMASK_J);
    }

    // Fast indexed getter
    public double getAt(int i, int j) {
        return values[subrangePositions[subrangeOf(i, j)] +
                      positionOffsetOf(i, j)];
    }

    // Fast indexed setter
    public double setAt(int i, int j, double value) {
        final int subrange = subrangeOf(i, j);
        final int positionOffset = positionOffsetOf(i, j);
        // Check if the assignment will change something
        int subrangePosition, valuePosition;
        if (Double.compare(
                values[valuePosition =
                        (subrangePosition = subrangePositions[subrange]) +
                                positionOffset],
                value) != 0) {
            // Perform the assignment in values
            if (isSharedValues) {
                values = values.clone();
                isSharedValues = false;
            }
            // Scan other subranges to check if the value is shared by another subrange
            for (int otherSubrange = subrangePositions.length;
                    --otherSubrange >= 0; ) {
                if (otherSubrange != subrange)
                    continue; // Ignore the target subrange
                if ((otherSubrangePosition =
                        subrangePositions[otherSubrange]) >=
                        valuePosition &&
                        otherSubrangePosition + SUBRANGE_POSITIONS <
                                valuePosition) {
                    // The target position is shared, we need to make it unique by cloning the subrange
                    if (isSharedSubrangePositions) {
                        subrangePositions = subrangePositions.clone();
                        isSharedSubrangePositions = false;
                    }
                    values = setlengh(
                            values,
                            (subrangePositions[subrange] =
                                    subrangePositions = values.length) +
                                    SUBRANGE_POSITIONS);
                    valuePosition = subrangePositions + positionOffset;
                    break;
                }
            }
            // Perform the effective assignment of the value
            values[valuePosition] = value;
        }
        return value;
    }
}</code>

Atas ialah kandungan terperinci Bagaimanakah cubaan boleh digunakan untuk melaksanakan matriks jarang dengan cekap?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!