8 Big sorting algorithms that Java programmers must master

The relationship between the 8 kinds of sorting:

1, direct Insert sort

(1) Basic idea: In the set of numbers to be sorted, assume that the number of front (n-1) [n>=2] is already a row

In a good order, now you want to insert the nth number into the ordinal number in front, so that the n number

It's also in the right order. This cycle is repeated until all the rows are in order.

(2) Example

(3) Implementation in Java

Packagecom.njue;

public class Insertsort {

Publicinsertsort () {

INTA[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};

Inttemp=0;

for (inti=1;i<a.length;i++) {

Intj=i-1;

Temp=a[i];

for (; j>=0&&temp<a[j];j--) {

A[J+1]=A[J]; Move the value greater than temp to one unit after the whole

}

A[j+1]=temp;

}

for (inti=0;i<a.length;i++)

System.out.println (A[i]);

}

}
2, Hill Sort (minimum incremental sort)

(1) Basic idea: The algorithm will sort the group of numbers according to an increment D (n/2,n to the number of orders to be sorted) into groups, each group of records of the subscript difference D. Direct insert sorting of all elements in each group, followed by a smaller increment (D/2) to group it, The direct insert sort is then done in each group. When the increment is reduced to 1 o'clock, the sort is completed after the direct insert sort.

(2) Example:

(3) Implementation in Java

public class Shellsort {

Public Shellsort () {

INTA[]={1,54,6,3,78,34,12,45,56,100};

Doubled1=a.length;

Inttemp=0;

while (true) {

d1= Math.ceil (D1/2);

intd= (int) D1;

for (intx=0;x<d;x++) {

for (Inti=x+d;i<a.length;i+=d) {

intj=i-d;

Temp=a[i];

for (; j>=0&&temp<a[j];j-=d) {

A[J+D]=A[J];

}

A[j+d]=temp;

}

}

if (d==1)

Break

}

for (inti=0;i<a.length;i++)

System.out.println (A[i]);

}

}
3. Simple selection of sorting

(1) Basic idea: In the group of numbers to be sorted, choose the smallest one and the number of the first position to exchange;

Then in the remaining number, find the smallest and second position of the number of exchanges, so loop to the penultimate number and the last number comparison.

(2) Example:

(3) Implementation in Java

public class Selectsort {

Public Selectsort () {

INTA[]={1,54,6,3,78,34,12,45};

intposition=0;

for (inti=0;i<a.length;i++) {

intj=i+1;

Position=i;

Inttemp=a[i];

for (; j<a.length;j++) {

if (a[j]<temp) {

TEMP=A[J];

Position=j;

}

}

A[position]=a[i];

A[i]=temp;

}

for (inti=0;i<a.length;i++)

System.out.println (A[i]);

}

}
4, Heap sort

(1) Basic idea: heap sorting is a sort of tree selection, which is an effective improvement to the direct selection sort.

The heap is defined as follows: A sequence with n elements (h1,h2,..., HN) is called a heap when and only if it satisfies (hi>=h2i,hi& gt;=2i+1) or (hi<=h2i,hi<=2i+1) (i=1,2,..., N/2). Only the heap that satisfies the former condition is discussed here. As can be seen from the definition of a heap, the top element of the heap (that is, the first element) must be the largest (large top heap). A fully binary tree can represent the structure of a heap visually. Heap top is the root, the other is Zuozi, right subtree. The sequence of the numbers to be sorted is initially treated as a two-fork tree that is stored sequentially, adjusting their storage order to become a heap, when the heap has the largest number of root nodes. The root node is then exchanged with the last node of the heap. The number of fronts (n-1) is then re-adjusted to make it a heap. And so on, until there are only two nodes of the heap, and exchange them, and finally get an ordered sequence of n nodes. In terms of algorithm description, heap sequencing requires two processes, one is to build the heap, and the other is the last element of the heap to exchange the position. So the heap sort has two functions. One is to build the seepage function of the heap, and the second is to call the function of the infiltration function to realize the sorting.

(2) Example:

Initial sequence: 46,79,56,38,40,84

Build heap:

Swap, kicking the maximum number out of the heap

And so on: The last two remaining nodes in the heap are exchanged, kicked out, and sorted.

(3) Implementation in Java

Importjava.util.Arrays;

Publicclass Heapsort {

INTA[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};

Public Heapsort () {

Heapsort (a);

}

public void Heapsort (int[] a) {

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

Intarraylength=a.length;

Loop Build Heap

for (inti=0;i<arraylength-1;i++) {

Build a heap

Buildmaxheap (a,arraylength-1-i);

Swap heap top and last element

Swap (a,0,arraylength-1-i);

System.out.println (Arrays.tostring (a));

}

}

private void Swap (int[] data, Inti, INTJ) {

TODO auto-generated Method Stub

Inttmp=data[i];

DATA[I]=DATA[J];

data[j]=tmp;

}

Build a large top heap from 0 to lastindex for the data array

private void Buildmaxheap (int[] data, Intlastindex) {

TODO auto-generated Method Stub

Starting at the parent node of the lastindex node (the last node)

For (inti= (lastIndex-1)/2;i>=0;i--) {

K Save the node being judged

Intk=i;

If the child node of the current K-node exists

while (K*2+1<=lastindex) {

Index of the left child node of the K-node

intbiggerindex=2*k+1;

If Biggerindex is less than lastindex, that is, the right child node of the K node represented by biggerindex+1 exists

if (Biggerindex<lastindex) {

If the value of the right child node is large

if (Data[biggerindex]<data[biggerindex+1]) {

Biggerindex always records the index of a larger child node

biggerindex++;

}

}

If the value of the K-node is less than the value of its larger child nodes

if (Data[k]<data[biggerindex]) {

Exchange them

Swap (Data,k,biggerindex);

Assign the Biggerindex to K, start the next loop of the while loop, and re-guarantee that the value of the K-node is greater than the value of its left and right child nodes

K=biggerindex;

}else{

Break

}

}

}

}

}
5. Bubble sort

(1) The basic idea: in order to sort a group of numbers, the current is not yet ranked in the range of all the number, from top to bottom of the adjacent two numbers in turn to compare and adjust, so that the larger number to sink, smaller upward. That is, each time a comparison of two adjacent numbers finds that they are in the opposite order of order, they are interchanged.

(2) Example:

(3) Implementation in Java

public class Bubblesort {

Public Bubblesort () {

INTA[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};

Inttemp=0;

for (inti=0;i<a.length-1;i++) {

for (intj=0;j<a.length-1-i;j++) {

if (A[j]>a[j+1]) {

TEMP=A[J];

A[J]=A[J+1];

A[j+1]=temp;

}

}

}

for (inti=0;i<a.length;i++)

System.out.println (A[i]);

}

}
6. Quick Sort

(1) Basic idea: Select a datum element, usually select the first element or the last element, through a scan, the waiting sequence is divided into two parts, some smaller than the Datum element, part is greater than the datum element, when the datum element in its correct position after the order, Then the same method is used recursively to sort the two parts of the division.

(2) Example:

(3) Implementation in Java

public class QuickSort {

INTA[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};

Public QuickSort () {

Quick (a);

for (inti=0;i<a.length;i++)

System.out.println (A[i]);

}

public int getmiddle (int[] list, Intlow, Inthigh) {

Inttmp = List[low]; The first of the arrays as a middle axis

while (Low < high) {

while (Low < high && List[high] >= tmp) {

high--;

}

List[low] = List[high]; Less than mid-axis records moved to the low end

while (Low < high && List[low] <= tmp) {

low++;

}

List[high] = List[low]; A record larger than the middle axis moves to the high end

}

List[low] = tmp; Middle axis record to tail

Returnlow; Returns the position of the middle axis

}

public void _quicksort (int[] list, Intlow, Inthigh) {

if (Low < high) {

Intmiddle = Getmiddle (list, low, high); Divides a list array into a split

_quicksort (list, low, middle-1); Recursive ordering of low-word tables

_quicksort (list, middle + 1, high); Recursive ordering of high-character tables

}

}

public void Quick (int[] A2) {

if (A2.length > 0) {//See if the array is empty

_quicksort (A2, 0, A2.length-1);

}

}

}
7. Merge sort

(1) Basic sorting: Merge (merge) sorting method is to combine two (or more than two) ordered tables into a new ordered table, that is, to sort the sequence into a number of sub-sequences, each sub-sequence is ordered. Then the ordered subsequence is combined into a whole ordered sequence.

(2) Example:

(3) Implementation in Java

Importjava.util.Arrays;

public class Mergingsort {

INTA[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};

Public Mergingsort () {

Sort (a,0,a.length-1);

for (inti=0;i<a.length;i++)

System.out.println (A[i]);

}

public void sort (int[] data, intleft, Intright) {

TODO auto-generated Method Stub

if (left<right) {

Find the intermediate index

Intcenter= (Left+right)/2;

Recursive to the left array

Sort (data,left,center);

Recursive to the right array

Sort (data,center+1,right);

Merge

Merge (Data,left,center,right);

}

}

public void merge (int[] data, intleft, Intcenter, intright) {

TODO auto-generated Method Stub

Int[] tmparr=newint[data.length];

intmid=center+1;

Third records the index of an intermediate array

Intthird=left;

Inttmp=left;

while (Left<=center&&mid<=right) {

Take the smallest of the two arrays into the middle array

if (Data[left]<=data[mid]) {

Tmparr[third++]=data[left++];

}else{

Tmparr[third++]=data[mid++];

}

}

The remainder is placed in the middle array in turn

while (Mid<=right) {

Tmparr[third++]=data[mid++];

}

while (Left<=center) {

Tmparr[third++]=data[left++];

}

Copy the contents of the intermediate array back to the original array

while (Tmp<=right) {

Data[tmp]=tmparr[tmp++];

}

System.out.println (arrays.tostring (data));

}

}
8. Base Order

(1) The basic idea: to unify all the values to be compared (positive integers) to the same digit length, the number of the short number of the first complement 0. Then, start with the lowest bit and order one at a time. Thus, from the lowest bit to the highest order, the sequence becomes an ordered series.

(2) Example:

(3) Implementation in Java

Importjava.util.ArrayList;

Importjava.util.List;

public class Radixsort {

INTA[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,101,56,17,18,23,34,15,35,25,53,51};

Publicradixsort () {

Sort (a);

for (inti=0;i<a.length;i++)

System.out.println (A[i]);

}

public void sort (int[] array) {

First, the number of sorts is determined;

INTMAX=ARRAY[0];

for (inti=1;i<array.length;i++) {

if (Array[i]>max) {

Max=array[i];

}

}

inttime=0;

Determine the number of digits;

while (max>0) {

max/=10;

time++;

}

Set up 10 queues;

List<arraylist> queue=newarraylist<arraylist> ();

for (inti=0;i<10;i++) {

Arraylist<integer> queue1=newarraylist<integer> ();

Queue.add (queue1);

}

Time allocation and collection;

for (inti=0;i<time;i++) {

assigning array elements;

for (intj=0;j<array.length;j++) {

Get the number of time+1 digits;

intx=array[j]% (int) Math.pow (ten, i+1)/(int) Math.pow (n, i);

Arraylist<integer> queue2=queue.get (x);

Queue2.add (Array[j]);

Queue.set (x, queue2);

}

intcount=0;//element counter;

Collect queue elements;

for (intk=0;k<10;k++) {

while (Queue.get (k). Size () >0) {

Arraylist<integer> Queue3=queue.get (k);

Array[count]=queue3.get (0);

Queue3.remove (0);

count++;

}

}

}

}

}

8 Big sorting algorithms that Java programmers must master