Source code Penjumlah dan Pengurangan Matriks pada Java

Source code Penjumlah dan Pengurangan Matriks orde 3 X 3 

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package PraktikumASD;

import java.util.Scanner;

/**
 *
 * @author Nenov
 */
public class Matriks {

    private int A[][] = new int[3][3];
    private int B[][] = new int[3][3];
    private int C[][] = new int[3][3];

    public void input() {
        Scanner input = new Scanner(System.in);

        int i, j, k, m;

        System.out.println("   Matriks A");
        for (i = 0; i < 3; i++) {
            for (j = 0; j < 3; j++) {
                System.out.print("Baris " + (i + 1) + " Kolom " + (j + 1) + " : ");
                A[i][j] = input.nextInt();
            }
            System.out.println("");
        }

        System.out.println("\n    Matriks B");
        for (k = 0; k < 3; k++) {
            for (m = 0; m < 3; m++) {
                System.out.print("Baris " + (k + 1) + " Kolom " + (m + 1) + " : ");
                B[k][m] = input.nextInt();
            }
            System.out.println("");
        }
    }

    public void penjumlahan() {
        System.out.println("\nHasil Penjumlahan Matriks A dan B adalah ");

        for (int x = 0; x < 3; x++) {
            for (int y = 0; y < 3; y++) {
                C[x][y] = A[x][y] + B[x][y];
            }
        }
    }

    public void pengurangan() {
        System.out.println("\nHasil Pngurangan Matriks A dan B adalah ");

        for (int x = 0; x < 3; x++) {
            for (int y = 0; y < 3; y++) {
                C[x][y] = A[x][y] - B[x][y];
            }
        }
    }

    public void Cetak() {
        for (int x = 0; x < 3; x++) {
            for (int y = 0; y < 3; y++) {
                System.out.print(C[x][y] + "   ");
            }
            System.out.println("");
        }

    }

}
class MainMatriks{
    public static void main(String[] args) {
    Matriks a = new Matriks();
    a.input();
    a.penjumlahan();
    a.Cetak();
    a.pengurangan();
    a.Cetak();
        
    }
}

Source Code Merge Sort Pada Java

contoh source code pengurutan angka menggunakan prinsip merge sort,. kalo ada salah dalam source codenya atau komenanya,., mohon maaf ya, karena aku baru belajar,., :) :)

========================================================================


/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package PraktikumASD;

import java.util.Scanner;

/**
 *
 * @author Nenov
 */
public class MergeSort {
    
    // method untuk proses mengurutkan angka yang berada dalam array
    public void MergeSort(int angka[], int rnd, int tg) { 

        int low = rnd;
        int high = tg;
        //meriksa apakah low lebih kecil dari pada high, jika tidak maka angka telah terurut
        if (low < high) {
            int middle = (low + high) / 2;//mendapatkan indeks dari elemen yang ada di tengah 
            MergeSort(angka, low, middle);//melakukan rekrusif untuk mengurutkan sisi kiri array 
            MergeSort(angka, middle + 1, high);//melakukan rekrusif untuk  mengurutkan sisi kanan array
            int end_low = middle;
            int start_high = middle + 1;
            // proses perulangan untuk membandingkan isi array dengan isi array sebelah kananya, 
            // perulangan akan terus dilakukan selama rnd lebih kecil sama dengan end_low dan start_high kecil sama dengan dengan high
            while ((rnd <= end_low) && (start_high <= high)) { 
                if (angka[low] < angka[start_high]) {// jika isi array lebih kecil dari isi array sesudahnya atau sebelah kananya
                    low++;// maka low akan bertambah 1
                } else {  //jika isi array lebih besarkecil dari isi array sesudahnya atau sebelah kananya
                    int Temp = angka[start_high]; // temp adalah isi dari array ke start_high, start_high adalh indeks yang di peroleh dari indeks yang di tengah ditambah 1
                    for (int k = start_high - 1; k >= low; k--) {// perulangan untuk penukaran array
                        angka[k + 1] = angka[k]; //proses penukuran tempat array dari array yg sebelah kananya array saat ini menjadi array sekarang
                    }
                    angka[low] = Temp; // mengisi array dengn temp
                    low++;// low bertambah 1
                    end_low++; // end_low akan bertambah
                    start_high++;// strat_high kan bertambah 1
                }

            }
            System.out.println(" ");
            for (int i = 0; i < angka.length; i++) {//perulangan untuk menampilkan proses 
                System.out.print(angka[i] + " ");
            }
        }
    }
    // method untuk mencetak angka - angka setelah di urutkan
    public void cetak(int angka[], int pj) {
        MergeSort(angka, 0, pj - 1);//memanggil method MergeSort
        System.out.print("\n\nSetelah sorting:\n");
        for (int i = 0; i < pj; i++) {// perulangan untuk menampilkan angka yang tlah di urutkan
            System.out.print(angka[i] + "  ");
        }
        System.out.println();
    }
}


//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

class test {

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.print("Masukan Batasan array : ");
        int max = input.nextInt();// menyimpan inputan dari user ke dalam max
        int[] angka = new int[max]; // membuat tempat array sebanyak yang di inputkan user
        System.out.println("Masukan data yang ingin di sorting : ");
        for (int i = 0; i < max; i++) { // perulangan untuk mengisi array dengan angka
            System.out.print("Data ke-" + (i + 1) + " : ");
            angka[i] = input.nextInt();// angka yang di masukan di simpan di dalam array
        }
        MergeSort sort = new MergeSort(); // membuat objek baru dari kelas MergeSort
        sort.cetak(angka, max); 

    }
}

source code avl tree di java

Alhamdulillah akhirnya selesai jga tugas ku ini, terima kasih untuk yang telah membantu aku dalam mengerjakan tugas ini.

source code di bawah ini memiliki 3 Kelas yaitu :
- Kelas AvlNode

- Kelas AvlTree

-Kelas AVLmain

maaf jika ada kesalahan komentnya atau soure codenya, karena aku baru belajar

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

/*

 * To change this template, choose Tools | Templates

 * and open the template in the editor.

 */

package PraktikumASD.AVLTree;

/**

 *

 * @author Nenov

 */

class AvlNode {

 public AvlNode left;

 public AvlNode right;

 public AvlNode parent;

 public int data;

 public int balance;

 public AvlNode(int k) {

  left = right = parent = null;

  balance = 0;

  data = k;

 }

 public String toString() {

  return "" + data;

 }

}

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++

/*

 * To change this template, choose Tools | Templates

 * and open the template in the editor.

 */

package PraktikumASD.AVLTree;

import java.util.ArrayList;

import java.util.Stack;

/**

 *

 * @author Nenov

 */

public class AvlTree {

    protected AvlNode root; // membuat node dari root

// method yang akan di panggil d kelas main untuk memasukan angka-angka

    public void insert(int k) { // k adalah angka yang di masukan

        // membuat node baru dari k

        AvlNode n = new AvlNode(k);

        // memanggil  method insertAVL untuk memasukan node

        insertAVL(this.root, n);

    }

    // method untuk menentukan sebuah node itu menjadi root, anak kiri, atau anak kanan

    private void insertAVL(AvlNode p, AvlNode q) {

        // Jika simpul untuk membandingkan adalah null, node adalah node yang dimasukkan. Jika akar adalah nol, node tersebut adalah adalah akar pohon.

        if (p == null) {

            this.root = q;

        } else {

            // jika perbandingan node yang dimasukan lebih kecil dari pada node yang menjadi parent maka node tersebut berada di sebelah kiri

            if (q.data < p.data) {

                if (p.left == null) { // jika node kirinya kosong 

                    p.left = q; // maka node di sebelah kiri adalah node yang di masukan

                    q.parent = p; // maka node parent dari node yang dimasukan adalah node yang sudah ada

                    // Memanggil method CheckAVL untuk mengecek kesetimbangan dari node yang di masukan sekarang

                    CheckAVL(p);

                } else { // jika node kirinya ada

                    insertAVL(p.left, q);// maka melakukan rekrusif untuk memasukan node, dengan yang bertindak sebagai parent adalah node kirinya

                }

                // jika perbandingan node yang dimasukan lebih besar dari pada node yang menjadi parent maka node tersebut berada di sebelah kanan

            } else if (q.data > p.data) {

                if (p.right == null) {// jika node kanan kosong

                    p.right = q;// maka node di sebelah kanan adalah node yang di masukan

                    q.parent = p;// maka node parent dari node yang dimasukan adalah node yang sudah ada

                    // Memanggil method CheckAVL untuk mengecek kesetimbangan dari node yang di masukan sekarang

                    CheckAVL(p);

                } else {// jika node kananya ada

                    insertAVL(p.right, q);// maka melakukan rekrusif untuk memasukan node, dengan yang bertindak sebagai parent adalah node kananya

                }

            } else { // jika node yang di masukan sudah ada di dalam pohon maka tidak dilakukan apa-apa

            }

        }

    }

    //method untuk menghitung selisih tinggi dari anak kanan dan anak kiri

    private void setBalance(AvlNode cur) {

        cur.balance = height(cur.right) - height(cur.left);

    }

    // method untuk memeriksa keseimbangan untuk setiap node dan memanggil metode yang diperlukan untuk menyeimbangkan pohon .

    private void CheckAVL(AvlNode cur) {

        setBalance(cur);// memanggil method untuk menghitung selisih tinggi antara anak kanan dan anak kiri dari node yang di berikan

        int balance = cur.balance; // pendeklarasi balance untuk menyimpan hasil dari selisih tinggi antara anak kanan dan anak kiri

        // check keseimbangan jika tinggi dari kanan dikurang tinggi dari kiri adalah -2

        if (balance == -2) {

            // jika tinggi anak kiri dari anak kiri lebih besar sama dengan dari pada  tinggi anak kanan dari anak kiri tersebut.

            if (height(cur.left.left) >= height(cur.left.right)) {

                cur = rotateRight(cur); // maka melakukan rotasi kanan berdasarkan node yang di berikan

            } else { // jika tidak

                cur = doubleRotateLeftRight(cur); // maka akan melakukan double rotasi berdasarkan node yang di berikan

            }

            // check keseimbangan jika tinggi dari kanan dikurang tinggi dari kiri adalah 2

        } else if (balance == 2) {

            // jika tinggi anak kanan dari anak kanan lebih besar sama dengan dari pada  tinggi anak kiri dari anak kanan tersebut.

            if (height(cur.right.right) >= height(cur.right.left)) {

                cur = rotateLeft(cur); // maka akan melakukan rotasi kiri berdasarkan node yang di berikan

            } else {//jika tidak

                cur = doubleRotateRightLeft(cur);// maka akan melakukan double rotasi berdasarkan node yang di berikan

            }

        }

        if (cur.parent != null) {// jika parent dari node tersebut tidak kosong

            CheckAVL(cur.parent); // maka melakukan rekrusif dengan node yang di masukan adalah parent dari node tersebut

        } else {// jika tidak

            this.root = cur; // root adalah node tersebut

        }

    }

    //method untuk rotasi kiri

    private AvlNode rotateLeft(AvlNode n) {

        AvlNode v = n.right; // membuat node baru, dan node tersebut adalah node kanan dari node yang di masukan

        v.parent = n.parent;// maka parent dari node node baru adalaha node yang di masukan

        n.right = v.left; // node kanan adalah node kiri dari node baru

        if (n.right != null) { // jika node kanan tidak kosong

            n.right.parent = n; // maka parent dari node kanan adalah node yang dimasukan

        }

        v.left = n; // node kiri dari node baru adalah node yang di masukan

        n.parent = v; // parent dari node tersebut adalah node baru

        if (v.parent != null) { // jika parent dari node baru tidak kosong

            if (v.parent.right == n) { // jika anak kanan dari parent node baru sama dengan node yang ada

                v.parent.right = v;// maka anak kanan dari parent node baru adalah node baru

            } else if (v.parent.left == n) { // jika anak kiri dari parent node baru sama dengan node yang ada

                v.parent.left = v; // maka anak kiri dari parent node baru adalah node baru

            }

        }

        return v;// mengembalikan node baru

    }

    // method untuk rotasi kanan

    private AvlNode rotateRight(AvlNode n) {

        AvlNode v = n.left;// membuat node baru, dan node tersebut adalah node kiri dari node yang di masukan

        v.parent = n.parent;// maka parent dari node node baru adalaha node yang di masukan

        n.left = v.right;// node kiri adalah node kanan dari node baru

        if (n.left != null) {// jika node kiri kosong

            n.left.parent = n; // maka parent dari node kiri adalah node yang di masukan

        }

        v.right = n;// node kanan dari node baru adalah node yang di masukan

        n.parent = v;// parent dari node tersebut adalah node baru

        if (v.parent != null) { // jika parent dari node baru tidak kosong

            if (v.parent.right == n) { // jika anak kanan dari parent node baru sama dengan node yang ada

                v.parent.right = v;// maka anak kanan dari parent node baru adalah node baru

            } else if (v.parent.left == n) { // jika anak kiri dari parent node baru sama dengan node yang ada

                v.parent.left = v; // maka anak kiri dari parent node baru adalah node baru

            }

        }

        return v;// mengembalikan node baru

    }

// method proses double rotasi

    private AvlNode doubleRotateLeftRight(AvlNode u) {

        u.left = rotateLeft(u.left);// melakukan rotasi kiri

        return rotateRight(u);// mengembalikan rotasi kanan

    }

    // method proses double rotasi

    private AvlNode doubleRotateRightLeft(AvlNode u) {

        u.right = rotateRight(u.right); // melakukan rotasi kanan

        return rotateLeft(u); // mengembalikan hasil dari rotasi kiri

    }

    // method untuk mencari tinggi atau level dari tree

    private int height(AvlNode cur) {

        if (cur == null) { // jika root tidak ad

            return -1; //maka level atau tingginya adalah -1

        }

        if (cur.left == null && cur.right == null) {// jika ada akar dan tidak mempunyai anak kanan dan kiri

            return 0; // maka level atau tingginya adalah 0

        } else if (cur.left == null) { // jika hnya memiliki anak kiri

            return 1 + height(cur.right); // maka level atau tingginya adalah 1 di tambah dengan jumlah level atau tinggi dari anak dari anak kiri tersebut

        } else if (cur.right == null) {// jika hanya memiliki anak kanan

            return 1 + height(cur.left);// maka level atau tingginya adalah 1 di tambah dengan jumlah level atau tinggi dari anak dari anak kanan tersebut

        } else {// jika punya anak kiri dan kanan

            return 1 + Math.max(height(cur.left), height(cur.right));

            // maka tingginya adalah 1 di tambah dengan nilai tertinggi antara anak kiri dan anak kanan

        }

    }

    public void displayTree() {

        Stack stack = new Stack();

        stack.push(root);

        int nBlanks = 32;

        boolean isRowEmpty = false;

        System.out.println(".............................................................");

        while (isRowEmpty == false) {

            Stack localStack = new Stack();

            isRowEmpty = true;

            for (int j = 0; j < nBlanks; j++) {

                System.out.print(' ');

            }

            while (stack.isEmpty() == false) {

                AvlNode temp = (AvlNode) stack.pop();

                if (temp != null) {

                    System.out.print(temp.data);

                    localStack.push(temp.left);

                    localStack.push(temp.right);

                    if (temp.left != null || temp.right != null) {

                        isRowEmpty = false;

                    }

                } else {

                    System.out.print("--");

                    localStack.push(null);

                    localStack.push(null);

                }

                for (int j = 0; j < (nBlanks * 2) - 2; j++) {

                    System.out.print(' ');

                }

            }

            System.out.println();

            nBlanks /= 2;

            while (localStack.isEmpty() == false) {

                stack.push(localStack.pop());

            }

        }

        System.out.println("............................................................");

    }

}

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++

/*

 * To change this template, choose Tools | Templates

 * and open the template in the editor.

 */

package PraktikumASD.AVLTree;

/**

 *

 * @author Nenov

 */

public class AVLmain {

    public static void main(String[] args) {

        AvlTree Fn = new AvlTree();

        Fn.insert(35);

        Fn.insert(20);

        Fn.insert(45);

        Fn.insert(25);

        Fn.insert(18);

        Fn.insert(40);

        Fn.insert(43);

        Fn.insert(30);

        Fn.insert(10);

        Fn.insert(27);

        Fn.displayTree();

    }

}