java的排序算法自己整理

以下内容是自己编写并整理，转载请标明来处：http://www.cnblogs.com/pony1223/

简单选择排序：

 

package cn.mdj.test;

public class SelectSort {

public static void sort(int array[]){

int len = array.length;

int temp; //临时变量

int index; //最小元素索引

for(int i=0;i<len;i++){

index = i;//假设第一个元素最小

for(int j=i+1;j<len;j++){//将当前的最小元素与后面元素比较，获取最小的元素

if(array[j]<array[index]){

index = j;//交换索引，索引永远指向最小的那个元素

}

}

 

//与后面元素遍历完后，看是否需要进行交换

if(index != i){

temp = array[index];

array[index] = array[i];

array[i] = temp;

}

}

}

public static void main(String[] args) {

int[] array = new int[]{1,3,2,6,4,8,5,7,9};

sort(array);

for(int i=0;i<array.length;i++){

System.out.print(array[i]+"、");

}

}

}

 

 

简单插入排序：

 

package cn.mdj.test;

public class InsertSort {

public static void sort(int[] array){

int len = array.length;

for(int i=1;i<len;i++){

int temp = array[i]; //保存要插入的元素

int j=0; //有序区，内首先有一个元素

//对有序区开始排序，从有序区的后面开始比较大小进行交换

for(j=i-1;j>-1&&temp < array[j];j--){

//如果待插入的元素比其小，则它前面的元素要后移

array[j+1] = array[j];

}

//直到，temp比前面的元素大，即停止，此时的j即该元素的位置，但因j--，所以位置还有要回填1

array[j+1]=temp;

}

}

public static void main(String[] args) {

int[] array = new int[]{1,3,2,6,4,8,5,7,9};

sort(array);

for(int i=0;i<array.length;i++){

System.out.print(array[i]+"、");

}

 

}

}

简单冒泡排序：

 

package cn.mdj.test;

public class BubbleSort {

    public static void sort(int[] array){

     int len = array.length;

     for(int i=0;i<len;i++){

     for(int j=i+1;j<len;j++){

     if(array[i]>array[j]){

     int temp = array[i];

     array[i]=array[j];

     array[j]= temp;

     }

     }}}

堆排序：

 

public class HeapSort {

public static void sort(int[] array){

int len = array.length;

//建立大顶堆

buildMaxHeap(array,len);

for(int i=len-1;i>0;i--){

int temp = array[i];

array[i] = array[0];

array[0] = temp;

MaxHeapify(array,1,i);

}

}

public static void buildMaxHeap(int[] arr,int len){

//从中间元素开始，调整使其变成大顶堆

for(int i=len/2;i>0;i--){

MaxHeapify(arr,i,len);

}

}

public static void MaxHeapify(int[] arr,int index,int len){

int left = 2*index; //当前索引的左孩子

int right = left+1;  //当前索引的右孩子

int lagest; //用于储存最大索引

 //如果左叶子节点索引小于堆大小，比较当前值和左叶子节点的值，取值大的索引值 

if(left <= len&&arr[left-1]>arr[index-1]){

lagest = left;

}else{

lagest = index;

}

//如果右叶子节点索引小于堆大小，比较右叶子节点和之前比较得出的较大值，取大的索引值 

if(right<=len&&arr[right-1]>arr[lagest-1]){

lagest = right;

}

//交换位置，并继续递归调用该方法调整位置。 

if(lagest != index){

int temp = arr[index-1];

arr[index-1] = arr[lagest-1];

arr[lagest-1] = temp;

MaxHeapify(arr,lagest,len);

}

 

}

public static void main(String[] args) {

int[] array = new int[]{1,3,2,6,4,8,5,7,9};

sort(array);

for(int i=0;i<array.length;i++){

System.out.print(array[i]+"、");

}

}

 

}

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

希尔排序：

 

package cn.mdj.test;

public class ShellSort {

public static void sort(int[] array){

int len = array.length;

int h = 1;

while(h<=len/3){ //当分区的区间没有超过len数据的长度，即 继续按照固定增量法，增加

   h =  h*3 + 1; //初始增量，最后得到h为划分的合理区间

}

while(h>0){ //直到h=1;为止

   for(int i=h;i<len;i++){ //和插入排序类似，从分区域的第二个元素开始，所以是i=h;；

//只所以是i++;是因为控制的是外面的，都要分区

   int temp = array[i]; //保存第二个元素

   int j = array[i-h];//有序区中的一个元素

   //开始对有序区中的元素进行排序，从后往前，即从i-h,

   for(j=i-h;j>-1&&temp<array[j];j=j-h){ //注意是j-h

   //往后移动

   array[j+h] = array[j];

   }

   array[j+h] = temp;

   }

   h = (h-1)/3; //不断缩小区间，直到为1

   }

}

public static void main(String[] args) {

int[] array = new int[]{1,3,2,6,4,8,5,7,9};

sort(array);

for(int i=0;i<array.length;i++){

System.out.print(array[i]+"、");

}

}

}

 

 

 

 

 

 

 

 

快速排序：

package cn.mdj.test;

public class QuickSort {

public static void sort(int[] array){

int len = array.length;

quickSort(array,0,len-1);

}

public static void quickSort(int arr[],int l,int r){

//l 左  r 右

int left = l;

int right = r;

int jizhunzhi = arr[left]; 

while(left < right){ //左 没有超过 右的时候

while(left<right&&jizhunzhi<arr[right]){

right--;

}

if(left<right){ //否则当 jizhunzhi>arr[right] 时候，说明要开始交换了

arr[left] = arr[right];

left++;//开始移动到下一个位置

}

//同样，右边完成后，左边要开始了

while(left<right&&jizhunzhi>arr[left]){

left++;

}

if(left<right){//否则 jizhunzhi<arr[left] 

arr[right] = arr[left];

right--;

}

}

//最后直到left = right 停止，那么第一元素，也就是我们假设的jizhunzhi的位置也就确定好了

arr[left] = jizhunzhi;

if(l<left) quickSort(arr,l,right-1);

if(left<r) quickSort(arr,right+1,r);

}

public static void main(String[] args) {

int[] array = new int[]{1,13,2,6,4,8,5,7,9};

sort(array);

for(int i=0;i<array.length;i++){

System.out.print(array[i]+"、");

}

}

}

 

转载于:https://www.cnblogs.com/pony1223/archive/2012/06/24/2560176.html