created bubbleSorting in java

GayanSampathManamendra · GayanSampathManamendra · commit 0674828d9df9 · 2018-08-28T23:10:09.000+05:30
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
@@ -0,0 +1,185 @@
+## How to contribute an implementation (code)?
+
+* Have a look at open issues. They contain the list of algorithms/DS we plan to be implemented. Pick an unassigned issue.
+* You can also create a new issue for an algorithm that is not in the list.
+* Make sure you are assigned for the issue.
+* Code the algorithm/DS following the styleguide defined below.
+* Send a PR. 
+* Be sure to not include any compiled binaries in the patch.
+* While sending a PR make sure you follow one issue per PR rule.
+
+
+<a name="sa"></a>
+
+## Suggesting an algorithm / DS
+
+* First make sure you are not suggesting a duplicate.
+* If not, proceed and create the issue. Make sure that you specify only one language in an issue. Create multiple issues for different languages.
+* Title of issue should be of the following format -
+    ```
+        Algorithm/DS Name [Language]
+    ```
+* Please include at least one external link for the algorithm/DS in the issue's body for each issue. The link should explain the algorithm/problem/DS in detail.
+
+
+<a name="cs"></a>
+
+## Code Styleguide
+
+* Code submitted should be modular. 
+* Don't use global variables.
+* Use separate folders for each concept. Folder name should be in full lowercase. If the algorithm/DS name has multiple words, separate them by underscores. (eg `longest_common_subsequence`)
+* Filename should be derived from the folder name. (eg `longest_common_subsequence` becomes `longestCommonSubsequence.c` or `LongestCommonSubsequence.java`)
+* Name of master function of the code should be kept same as filename to the best extent possible.
+* Prefer classes instead of multiple helper functions (where applicable).
+* Currently we are accepting contributions in C, C++, C#, Java, Python, Go and JavaScript but other languages may be considered after a discussion.
+* Define `tester` code only in `main` routine.
+* Use meaningful variable, method and function names and comments.
+* No profanity.
+* Use external libraries only when no other solution is possible/plausible.
+* We have defined [skeleton codes](#samples) for some popular languages below. Please follow them whenever possible.
+
+
+<a name="points"></a>
+
+## Standalone points
+
+* In some cases, C and C++ implementation will be similar. In that case, only the C implementation must be done.
+
+
+<a name="improving"></a>
+
+## Improving an implementation
+
+* If you feel you can improve upon an implementation, feel free to open an issue discussing the improvements.
+
+
+<a name="samples"></a>
+
+## Samples
+
+#### C
+
+```c
+void quicksort(int ar_size, int *ar) {
+    /*
+        Your implementation here...
+    */
+}
+
+int main() {
+	int ar_size = 4, i;
+	int a[4] = {2, 3, 0, 4};
+	quicksort(ar_size, a);
+
+	for (i=0; i<ar_size; i++){
+		printf("%d\n", a[i]);
+	}
+	return 0;
+}
+```
+
+#### Python
+```python
+def quicksort(arr):
+    #
+    # Your implementation here...
+    #
+
+
+def main():
+    arr = [2, 3, 0, 4]
+    sorted_arr = quicksort(arr)
+    print(sorted_arr)
+
+    
+if __name__ == '__main__':
+    main()
+```
+
+#### Java
+```java
+public class QuickSort {
+    
+    static void quickSort(int[] a) {
+        /*
+            Your implementation here...
+        */
+    }
+    
+    public static void main(String[] args) {
+        int[] arr = new int[] {2, 3, 0, 4};
+        quickSort(arr);
+        for(int element: arr) {
+            System.out.println(element);
+        }
+    }
+}
+```
+
+#### Golang
+
+```go
+package main
+
+import "fmt"
+
+// QuickSort sorts an array using QuickSort algorithm
+func QuickSort(array []int) []int {
+    // Your implementation here
+    return array
+}
+
+func main() {
+    array := []int{2, 3, 0, 4}
+    sortedArray := QuickSort(array)
+    fmt.Println(sortedArray)
+}
+```
+
+#### JavaScript
+
+```JavaScript
+function quickSort (arr) {
+	/*
+	Your implementation here
+	*/
+}
+
+function main () {
+	let input = [2, 3, 0, 4];
+	quickSort(input);
+	for (let x in input) {
+		console.log(input[x] + ' ');
+	}
+}
+
+main();
+```
+
+#### C#
+
+```csharp
+using System;
+
+public class QuickSort
+{  
+    public static void DoQuickSort(int[] a)
+    {
+        /*
+            Your implementation here...
+        */
+    }
+    
+    public static void Main()
+    {
+        int[] arr = new int[] {2, 3, 0, 4};
+        DoQuickSort(arr);
+        foreach(int element in arr)
+        {
+            Console.Write(element + " ");
+        }
+        Console.WriteLine("");
+    }
+}
+```
diff --git a/README.md b/README.md
@@ -0,0 +1,102 @@
+# Algos
+
+Community (college) maintained list of Algorithms and Data Structures implementations.
+
+
+
+## Implemented Algorithms
+
+
+| Algorithm | C | CPP | Java | Python | Golang | JavaScript | C# |
+|:--------------|:----------------:|:----------------:|:----------------:|:-----------------:|:-----------------:|:-----------------:| :-----------------:|
+| [Bin Sort](http://www.cdn.geeksforgeeks.org/bucket-sort-2/)| | | |  | | | |
+| [Binary Search](https://en.wikipedia.org/wiki/Binary_search_algorithm) |  | |  |  |  |  |  |
+| [Breadth First Search](https://en.wikipedia.org/wiki/Breadth-first_search) | | |  | | | | |
+| [Breadth First Traversal](https://www.cs.bu.edu/teaching/c/tree/breadth-first/) | | |  || | | |
+| [Coin Change Problem](http://www.algorithmist.com/index.php/Coin_Change) |  | | |  | |  | |
+| [Counting Sort](http://www.geeksforgeeks.org/counting-sort/)| | |  | |  |  |  |
+| [Depth First Traversal](http://www.geeksforgeeks.org/depth-first-traversal-for-a-graph/) | | |  |  | | | |
+| [Dijkstra Algorithm](https://en.wikipedia.org/wiki/Dijkstra's_algorithm) | | | | | | | |
+| [Euclidean GCD](https://en.wikipedia.org/wiki/Euclidean_algorithm) |  | |  | | |  |  |
+| [Exponentiation by Squaring](https://en.wikipedia.org/wiki/Exponentiation_by_squaring) | | |  |  | |  | |
+| [Heap Sort](https://en.wikipedia.org/wiki/Heapsort) |  | |  |  | |  | |
+| [Insertion Sort](https://en.wikipedia.org/wiki/Insertion_sort) | | | |  |  |  |  |
+| [k-NN](https://en.wikipedia.org/wiki/K-nearest_neighbors_algorithm) | | | |  | | | |
+| [Largest Sum Contiguous Subarray](http://www.geeksforgeeks.org/largest-sum-contiguous-subarray/) | | | | |  |  | |
+| [Linear Regression](https://en.wikipedia.org/wiki/Linear_regression) | | | |  | | | |
+| [Linear Search](https://en.wikipedia.org/wiki/Linear_search) | | |  || |  |  |
+| [Longest Common Subsequence](http://www.geeksforgeeks.org/dynamic-programming-set-4-longest-common-subsequence) | | |  |  |  | | |
+| [Longest Palindromic Substring](http://www.geeksforgeeks.org/longest-palindrome-substring-set-1/) | |  |  |  | |  | |
+| [Merge Sort](https://www.khanacademy.org/computing/computer-science/algorithms/merge-sort/a/overview-of-merge-sort) |  | |  |  |  |  |  |
+| [Modular Exponential](http://www.geeksforgeeks.org/modular-exponentiation-power-in-modular-arithmetic/) |  | |  |  || | |
+| | | |  |  | | | |
+| [Prime Factor](https://en.wikipedia.org/wiki/Prime_factor) |  | |  |  |  |  | |
+| [Prims](https://en.wikipedia.org/wiki/Prim%27s_algorithm) |  | |  | |  |  | |
+| [Quick Select](https://en.wikipedia.org/wiki/Quickselect) |  | |  |  | | | |
+| [Quicksort](https://en.wikipedia.org/wiki/Quicksort) | | |  |  | | | |
+| [Radix Sort](http://www.geeksforgeeks.org/radix-sort/) |  | |  |  | | | |
+| [Rod Cutting Problem](http://www.geeksforgeeks.org/dynamic-programming-set-13-cutting-a-rod/) |  | |  |  |  |  | |
+| [Shell Sort](https://en.wikipedia.org/wiki/Shellsort) | |  | | |  |  |  |
+| [Sieve of Eratosthenes](https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes) | | | |  |  |  | |
+| [Sleep Sort](http://www.geeksforgeeks.org/sleep-sort-king-laziness-sorting-sleeping/) | |  |  |  |  | | | |
+
+
+## Implemented Data Structures
+
+| Data Structure | C | CPP | Java | Python | Golang | JavaScript | C# |
+|:--------------|:----------------:|:----------------:|:----------------:|:-----------------:|:-----------------:|:-----------------:|:-----------------:|
+| [AVL Tree](http://www.geeksforgeeks.org/avl-tree-set-1-insertion)|| | | | | | |
+| | | |  |  |  | | |
+| [Linked List](https://en.wikipedia.org/wiki/Linked_list) |  | |  |  |  |  |  |
+| [Queue](https://en.wikipedia.org/wiki/Queue_(abstract_data_type)) | | | |  | | | |
+| [Stack](https://en.wikipedia.org/wiki/Stack_(abstract_data_type)) |  | | |  |  |  |  |
+| [Trie](https://en.wikipedia.org/wiki/Trie) | |  |  | |  | | | |
+| [Queue](https://en.wikipedia.org/wiki/Queue_(abstract_data_type)) | | |  | | | | | |
+
+
+
+## How to run them
+
+| Language | Steps |
+|:--------------|:----------------|
+| C |<pre>gcc [filename.c]<br>./a.out  # unix<br>a.exe  # windows</pre>|
+| CPP |<pre>g++ [filename.cpp]<br>./a.out # unix<br>a.exe # windows</pre>|
+| Java |<pre>javac [filename.java]<br>java [filename]</pre>|
+| Python |<pre>python [filename.py]</pre>|
+| Golang |<pre>go run [filename.go]</pre>|
+| JavaScript |<pre>node [filename.js]</pre>|
+| C# |<pre>mcs [filename.cs]<br/>mono [filename.exe]</pre>|
+
+
+## Resources
+
+* [Algorithms - Learneroo](https://www.learneroo.com/subjects/8)
+* [Awesome-Algorithms](https://github.com/tayllan/awesome-algorithms)
+* [Algorithms List - GeeksforGeeks](http://www.geeksforgeeks.org/fundamentals-of-algorithms/)
+* [Intro to Algorithms - Khan Academy](https://www.khanacademy.org/computing/computer-science/algorithms)
+* [Popular Data Structures and Algorithms - Codechef](https://discuss.codechef.com/questions/48877/data-structures-and-algorithms)
+* [Stanford-ACM-Codes](https://github.com/jaehyunp/stanfordacm) - A list of codes written by previous Stanford ACM team members and coaches.
+* [Data Structures and Algorithms](https://hackr.io/tutorials/learn-data-structures-algorithms) - A user ranked list of online tutorials to learn Data Structures and Algorithms online. 
+
+
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md).
+
+If you plan to suggest a new algorithm or DS, please make sure to read [the guidelines](CONTRIBUTING.md#sa).
+
+
+## Credits
+
+Idea by [@RavinduSachintha](https://github.com/RavinduSachintha)
+
+
+## Project Maintainers
+
+* [RavinduSachintha](https://github.com/RavinduSachintha)
+* [Danushka Herath](https://github.com/danushka96)
+* [Asitha Indrajith](https://github.com/AsithaIndrajith)
+* [Sachintha Rathnayake](https://github.com/Sacheerc)
+
+Only project maintainers should merge a PR. Other members can add their reviews to a PR but the merging should be done by only a project maintainer.
diff --git a/bubble_sort/bubbleSort.java b/bubble_sort/bubbleSort.java
@@ -0,0 +1,35 @@
+import java.util.Scanner;
+
+class bubbleSort{
+	public static void main(String a[]){
+
+		Scanner sc=new Scanner(System.in);
+		System.out.print("Size of array :");
+		int n=sc.nextInt();
+
+		int[] num=new int[n];
+		int i,j,tmp;
+
+		for(i=0;i<n;i++){
+			num[i]=sc.nextInt();
+		}
+		
+		for(i=0;i<n;i++){
+			for(j=0;j<(n-i);j++){
+				if(j==(n-1)){
+					break;
+				}
+				else{
+					if(num[j]>num[j+1]){
+						tmp=num[j];
+						num[j]=num[j+1];
+						num[j+1]=tmp;
+					}
+				}
+			}
+		}
+		for(i=0;i<n;i++){
+			System.out.print(num[i]+"  "  );
+		}
+	}
+}
diff --git a/stack/stack.py b/stack/stack.py
@@ -0,0 +1,28 @@
+# Implementing the Stack class
+# This is Complete
+
+
+class Stack:
+    def __init__(self):
+        self.items = []
+
+    def isEmpty(self):
+        return self.items == []
+
+    def push(self, ele):
+        self.items.append(item)
+
+    def pop(self):
+        return self.items.pop()
+
+    def peek(self):
+        return self.items[len(self.items) - 1]
+
+    def size(self):
+        return len(self.items)
+
+    def printStack(self):
+        print(self.items)
+
+# ///// End of Stack class
+
