Java Common algorithms

Ext.: http://blog.csdn.net/spy19881201/article/details/5867721

Https://www.cnblogs.com/hexiaochun/archive/2012/09/03/2668324.html

First, bubble sort

[Java]View PlainCopy

2. Package sort.bubble;
4. Import Java.util.Random;
6. /**
8. * Compare adjacent two numbers in turn, place decimals in front, large numbers on the back
10. * Bubble sort, with stability
12. * Time complexity of O (n^2)
14. * Less than heap sort, quick sort O (Nlogn, base 2)
16. * @author Liangge
18. *
20. */
22. Public class Main {
24. public static void Main (string[] args) {
26. Random ran = new Random ();
28. int[] sort = new int[10];
30. For (int i = 0; i < i++) {
32. Sort[i] = Ran.nextint (50);
34. }
36. System.out.print ("Array before sorting is");
38. For (int i:sort) {
40. System.out.print (i+"");
42. }
44. Buddlesort (sort);
46. System.out.println ();
48. System.out.print ("sorted array is");
50. For (int i:sort) {
52. System.out.print (i+"");
54. }
56. }
60. /** 
62. * Bubble Sort
64. * @param sort
66. */
68. private static void Buddlesort (int[] sort) {
70. For (int i=1;i<sort.length;i++) {
72. For (int j=0;j<sort.length-i;j++) {
74. if (sort[j]>sort[j+1]) {
76. int temp = sort[j+1];
78. sort[j+1] = sort[j];
80. SORT[J] = temp;
82. }
84. }
86. }
88. }
90. }

Second, choose the sort

[Java]View PlainCopy

2. Package sort.select;
4. Import Java.util.Random;
6. /**
8. * Select sort
10. * Each trip selects the smallest (or largest) element from the data element to be sorted,
12. * The order is placed at the end of the ordered sequence, until all the data elements are sorted out.
14. * Select Sort is an unstable sort method.
16. * @author Liangge
18. *
20. */
22. Public class Main {
24. public static void Main (string[] args) {
26. Random ran = new Random ();
28. int[] sort = new int[10];
30. For (int i = 0; i < i++) {
32. Sort[i] = Ran.nextint (50);
34. }
36. System.out.print ("Array before sorting is");
38. For (int i:sort) {
40. System.out.print (i + "");
42. }
44. Selectsort (sort);
46. System.out.println ();
48. System.out.print ("sorted array is");
50. For (int i:sort) {
52. System.out.print (i + "");
54. }
56. }
58. /** 
60. * Select sort
62. * @param sort
64. */
66. private static void Selectsort (int[] sort) {
68. For (int i =0;i<sort.length-1;i++) {
70. For (int j = i+1;j<sort.length;j++) {
72. if (Sort[j]<sort[i]) {
74. int temp = sort[j];
76. SORT[J] = Sort[i];
78. Sort[i] = temp;
80. }
82. }
84. }
86. }
88. }

Three, quick sort

 1 package Com.quick; 2 3 public class Quick {4 public void Quick_sort (int[] arrays, int lenght) {5 if (null = = Arrays | | lenght < 1) {6 System.out.println ("Input error!"); 7 return; 8} 9 _quick_sort (arrays , 0, lenght-1);}11 public void _quick_sort (int[] arrays, int start, int end) {if (start>=end) {return;15}16-int i = start;18 int j = end;19 int value = array  S[I];20 Boolean flag = true;21 while (i! = j) {if (flag) {(Value >                     Arrays[j]) {Swap (arrays, I, j); flag=false;26} else {28                     j--;29}30}else{31 if (Value<arrays[i]) {32          Swap (arrays, I, j); Flag=true;34}else{35 i++;36       }37}38}39 SNP (arrays); _quick_sort (arrays, start, j-1); _quick_so RT (Arrays, i+1, end),}44, public void SNP (int[] arrays) {$ = (int i = 0; i < arrays. Length i++) {System.out.print (Arrays[i] + "),}49 System.out.println (),}51 (Priva) te void Swap (int[] arrays, int i, int j) {int temp;54 temp = arrays[i];55 Arrays[i] = arrays[j]          ; Arrays[j] = temp;57}58 public static void Main (String args[]) {Quick q = new quick (); 61 Int[] A = {$, 65,12,45,5,};62 q.quick_sort (a,6); 63} 64 65}

Quick Sort Explanation

The idea of the so-called quick sort is to first take out the first number of the array as a key, set a i,j as the identity before and after each, and then take the key to the array from behind, and j--, until we find the first number less than this key, and then exchange the two values, after the exchange is complete , we take this key to go backwards from I, and i++, loop until the end of the i=j, when this is over, we will find that the value greater than this key will go to the back of the key, not if you write the wrong, less than this key will run to the front of this value Then we can complete the ordering of the entire array by invoking the array recursively.

Represented by a graphical representation of the following:

This will be divided into two segments of the key, we will take these two paragraphs further to solve the problem.

Java Common algorithms