diff --git a/bucketsort.c b/bucketsort.c
new file mode 100644
index 0000000000000000000000000000000000000000..c7776ff59f800c20ed0d0bc995f319157a2c1534
--- /dev/null
+++ b/bucketsort.c
@@ -0,0 +1,118 @@
+#include <stdlib.h>
+#include <time.h>
+#include <stdio.h>
+#include <string.h>
+#include <omp.h>
+
+#ifndef ElmtMaks
+#define ElmtMaks 100
+#endif
+
+typedef struct Bucket {
+    int* content;
+    int n_elmt;
+} Bucket;
+
+int *copyArray(int const * oldArray, size_t size) {
+   int * newArray = malloc(sizeof(int) * size);
+   memcpy(newArray, oldArray, sizeof(int) * size);
+   return newArray;
+}
+
+int *sort(int *array,int n){
+    int d,c,t;
+    for (c = 1 ; c <= n - 1; c++) {
+        d = c;
+        while ( d > 0 && array[d] < array[d-1]) {
+            t          = array[d];
+            array[d]   = array[d-1];
+            array[d-1] = t;
+            d--;
+        }
+    }
+    return array;
+}
+
+void printElmt (int *array, int size) {
+    int i;
+    for (i = 0; i < size; i++) {
+        printf("%d\n", array[i]);
+    }
+}
+
+
+int main(int argc, char *argv[]) {
+    if(argc != 3){
+        fprintf(stderr, "Usage: bucketsort N(jumlah elemen) M(jumlah bucket)\n");
+        exit(1);
+    }
+
+    /* get input */
+    int N = atoi(argv[1]);
+    int M = atoi(argv[2]);
+
+    int world_size = 6;
+
+    /* Bucket */
+    int *random_numbers = NULL;
+    Bucket *myBucket = NULL;
+    int i;
+	int *randomNumbers = (int *) malloc(sizeof(int) * N);
+	srand(time(NULL));
+    for (i = 0; i < N; i++ ) {
+        randomNumbers[i] = (rand() % ElmtMaks) + 1;
+    }
+    random_numbers = randomNumbers;
+    myBucket = (Bucket *) malloc(sizeof(Bucket) * M);
+    int n = (ElmtMaks / M) + 1;
+    int j,k;
+    for (i = 0; i < M; i++) {
+            k = 0;
+            int *t = (int *) malloc(sizeof(int) * N);
+            for (j = 0; j < N; j++) {
+                if (( random_numbers[j] >= i * n ) &&( random_numbers[j] < (i * n) + n )){
+                    t[k] = random_numbers[j];
+                    k++;
+                }
+            }
+            myBucket[i].n_elmt = k;
+            myBucket[i].content = copyArray(t, k);
+            free(t);
+        }
+
+        i = 0;
+
+        if(M < world_size)
+            world_size = M;
+
+        int *sorted_nums[world_size];
+        int sorted_size[world_size];
+
+        int *sorted_zero = sort(myBucket[0].content, myBucket[0].n_elmt);
+        sorted_nums[0] = copyArray(sorted_zero, myBucket[0].n_elmt);
+        sorted_size[0] = myBucket[0].n_elmt;
+        if(M == 1){
+            sorted_nums[0] = sort(random_numbers,N);
+        } else {
+			int temp[world_size];
+            for (i = 1; i < world_size; i++) {
+				/*
+                MPI_Send(&myBucket[i].n_elmt, 1, MPI_INT, i, 0, MPI_COMM_WORLD);
+                MPI_Send(myBucket[i].content, myBucket[i].n_elmt, MPI_INT, i, 1, MPI_COMM_WORLD);
+				*/
+				#  pragma omp parallel num_threads(M)
+				temp = copyArray(sort(myBucket[i].content, myBucket[i].n_elmt));
+				
+				sorted_nums[i] = copyArray(temp, world_size);
+				sorted_size[i] = world_size;
+            }
+        }
+
+
+        /* Print Sorted */
+        for (i = 0; i < world_size; i++) {
+            //printf("Hasil dari bucket ke-%d",i);
+            printElmt(sorted_nums[i], sorted_size[i]);
+        }
+
+}