java 大小排列_Java排序之排序大综合

一、最近写了一些排序，于是和和大家分享一下：(默认都是从小到大排序)

二、冒泡排序

1、什么是冒泡排序：原理是临近的两个数比较大小，将较大的数往后移，这样遍历一趟数组以后，最大的数就排在的最后面(时间复杂的为O(N2))

重复上面步骤N次。

2、原理描述：data{44,77,55,33,66}

第一次运行：data{44,55,33,66,77}

第二次运行：data{44，33，55，66，77}

。。。。。。

第N次执行：data{33，44，55，66，77}

3、参考代码：

importjava.util.Arrays;/*** Description:冒泡排序

* Author: Hey

* Date: 2015/12/7*/

public classBubbleSort {public static voidmain(String[] args) {int[] data = {11, 66, 33, 44, 77, 55};for (int i = 0; i < data.length-1; i++) {for (int j = data.length - i; j > 0; j--) {if (data[i] > data[i + 1]) {

data[i]= data[i] ^ data[i + 1];

data[i+ 1] = data[i + 1] ^data[i];

data[i]= data[i] ^ data[i + 1];

}

}

}//for(int i=0;i

System.out.println(Arrays.toString(data));

}

}

三、选择排序

1、什么是选择排序：选择排序是选择数组中最小的数将该数移动到数组最前面，将其他元素往后移动，重复N次操作(时间复杂的(O(N2)))

2、原理：data{44,77,55,33,66}

第一次运行：data{33，44，77，55，66}

第二次运行：data{33，44，77，55，66}

。。。。。。。

第N次运行：data{33，44，55，66，77}

3、参考代码：

importjava.util.Arrays;/*** Description:选择排序

* Author: Hey

* Date: 2015/12/7*/

public classSelectionSort {public static voidmain(String [] args){int[] data = {11, 66, 33, 44, 77, 55};int minData=0;for(int i=0;i

minData=data[i];for(int j=i+1;j

data[j]=data[j]^minData;

minData=minData^data[j];

data[j]=data[j]^minData;

}

data[i]=minData;

}

}

System.out.print(Arrays.toString(data));

}

}

四、插入排序：

1、什么是插入排序：插入排序是将数组划分为两个部分：有序部分和无序部分，将无序部分插入有序部分，重复执行N-1次,默认数组第一项就是有序的(时间复杂的O(N2))

2、插入排序的原理：data{44,77,55,33,66}

第一次：data{44，77，55，33，66}

第二次：data{44，55，77，33，66}

。。。。

第N次：data{33，44，55，66，77}

3、参考代码

packagecn.edu.insertionsort;importjava.util.Arrays;/*** Description:插入排序

* Author: Hey

* Date: 2015/12/7*/

public classInsertSort {public static voidmain(String[]args){int[] data = {11, 66, 33, 44, 77, 55};inti;//int j;

for(i=1;i

for(j=i-1;j>0;j--){

if(data[i]

if(data[j]>data[i]);

data[i]=data[j];

data[j]=temp;

}else{

break;

}

}*/

if(data[i-1]>data[i]){int temp=data[i];int j=i;while(j>0&&data[i]

data[j]=data[j-1];

j--;

}

data[j]=temp;

}

}

System.out.print(Arrays.toString(data));

}

}

五、希尔排序

1、(历史)希尔排序是选择排序的进化版：插入排序算法对大致有序的数组效率比较高；

但是如果是反序，那么插入排序将会进行大量的移动复制，如果先让部分的局部有序，那么久能够减少移动的次数

(什么是希尔排序)先取一个小于n的整数d1作为第一个增量，把文件的全部记录分组。

所有距离为d1的倍数的记录放在同一个组中。先在各组内进行直接插入排序；然后，取第二个增量d2

直至所取的增量

 =1(

<

…

2、关于增量的选取一般用3h+1的算数公式

3参考代码：

importjava.util.Arrays;/*** Description:希尔排序,希尔排序的之间的间隔是使用3h+1(运行个数)来定义的。

* h代表间隔(由于排序算法是基于插入算法的，当数组大小至少为3时，插入排序才比较有效)

* Author: Hey

* Date: 2015/12/7*/

public classHillSort {public static voidmain(String[]args){int[] data = {11, 66, 33, 44, 77, 55};//计算间隔

int length=data.length;int h=1;while(h<=length/3)

h=3*h+1;while(h>0){for(int i=h;ih-1&&data[j-h]>temp){

data[j]=data[j-h];

j-=h;

}

data[j]=temp;

}

h=(h-1)/3;

}

System.out.print(Arrays.toString(data));

}

}

六、快速排序

1、什么事快速排序：快速排序是在数组选择一个标准位(其实也就是在数组中选择一个数做参考)，将比标志位大的数右移，比标志位小的左移，让缩小范围继续比较

3、参考代码：

packagecn.edu.quicksort;importjava.util.Arrays;/*** Description:快速排序

* Author: Hey

* Date: 2015/12/7*/

public classQuickSort {int[] data = {11, 66, 33, 44, 77, 55};public void quickSort(int left, intright) {if ((right - left) <= 0)return;else{int pivot =data[right];int parttion=recQuickSort(left,right,pivot);

quickSort(left, parttion-1);

quickSort(parttion+ 1, right);

}

}public int recQuickSort(int left, int right, intpivot) {int leftPtr=left-1;int rightPtr=right;while (true) {while (data[++leftPtr] pivot) ;if (leftPtr >=rightPtr)break;elseswap(leftPtr, rightPtr);

}

swap(leftPtr, right);returnleftPtr;

}public void swap(int i, intj) {

data[i]= data[i] ^data[j];

data[j]= data[j] ^data[i];

data[i]= data[i] ^data[j];

}public static voidmain(String[] args) {

QuickSort q=newQuickSort();

q.quickSort(0,q.data.length-1);

System.out.print(Arrays.toString(q.data));

}

}

七：堆排序

1、什么事堆排序：堆排序(Heapsort)是指利用堆积树(堆)这种数据结构所设计的一种排序算法，它是选择排序的一种。

可以利用数组的特点快速定位指定索引的元素。堆分为大根堆和小根堆，是完全二叉树。大根堆的要求是每个节点的值都不大于其父节点的值，

即A[PARENT[i]] >= A[i]。在数组的非降序排序中，需要使用的就是大根堆，因为根据大根堆的要求可知，最大的值一定在堆顶。

2、参考代码：

packagecn.edu.heapsort;importjava.util.Arrays;/*** Description:堆排序

* Author: Hey

* Date: 2015/12/7*/

public classHeapSort {private intsize;privateNode[]nodes;private intelms;public HeapSort(intsize){

elms=0;this.nodes=newNode[size];

}public boolean insert(intvalue){if(elms>=value)return false;

Node node=newNode(value);

nodes[elms]=node;

trickUp(elms++);return true;

}publicNode remove(){

Node temp=nodes[0];

nodes[0]=nodes[--elms];

trickDown(0);returntemp;

}private void trickUp(intindex){int parent=(index-1)/2;

Node temp=nodes[index];while(index>0&&nodes[parent].value

nodes[index]=nodes[parent];

index=parent;

parent=(parent-1)/2;

}

nodes[index]=temp;

}private void trickDown(intindex){

Node temp=nodes[0];int largeChild=0;while(index

largeChild=maxNode(index);if(temp.value>nodes[largeChild].value)break;else{

nodes[index]=nodes[largeChild];

index=largeChild;

}

}

nodes[index]=temp;

}public static voidmain(String []args){

HeapSort h=new HeapSort(10);

h.insert(10);

h.insert(23);

h.insert(12);

h.insert(17);

h.insert(33);

h.print();

System.out.println(h.remove());

System.out.println(h.remove());

System.out.println(h.remove());

System.out.println(h.remove());

System.out.println(h.remove());

}private voidprint() {

System.out.println(Arrays.toString(nodes));

}private int maxNode(intparent){int left=parent*2+1;int right=parent*2+2;if (right

returnleft;

}private classNode{public intvalue;public Node(intvalue){this.value=value;

}

@OverridepublicString toString() {return "HeapSort{" +

"value=" + value +

'}';

}

}

}