java语言编写的基本排序算法

本文是将自己在学习过程中，编写的基本排序算法Java代码及算法的思想整理。

1．            插入排序

（1）      直接插入排序

/**

 * 功能：直接插入排序算法程序；复杂度为O(n²)，是稳定的排序算法。

 * 基本思想：顺序地把待排序的数据元素按其关键字值的大小插入到已排序的数据元素子集合的适当位置。

 */

packagecom.zyy.sorts;

public classDInsertSort {

public static void main(String[] args) {

           int str[]={25,3,9,6,8,18,46};

           //进行排序

           int str1[]=dInsert(str);

           //遍历(for循环增强)

           for(int s:str1){

                    System.out.print(s+"");

           }

          

           //遍历(for循环)

           /*for(int k=0;k<str.length;k++){

                    System.out.print(str[k]+"");

           }*/

          

           //迭代器不能直接遍历数组

}

public static int[] dInsert(int str[]){

           int temp;

           for(int i=0;i<str.length-1;i++){

                    temp=str[i+1];

                    int j=i;

           while(j>=0&&str[j]>temp){

                    str[j+1]=str[j];

                    j--;

           }

           str[j+1]=temp;

           }

           return str;

}

 

}

 

（2）      希尔排序

/**

 * 功能：实现希尔排序；时间复杂度为O(n(lbn)²)；是一种不稳定的排序算法。

 * 基本思想：把待排序的数据元素分成若干个小组，对同一小组内的数据元素用直接插入法排序，小组的个数逐次减少；

 * 当完成了所有数据元素都在一个组内的排序后，排序过程结束。希尔排序又称作缩小增量排序。

 */

packagecom.zyy.sorts;

public classXierSort {

public static void main(String[] args) {

           int str[]={52,23,56,45,12,36,15};

           int d[]={6,3,1};

           int d2[]=xier(str,d);

           //遍历

           /*for(int s:d2){

                    System.out.print(s+"");

           }*/

           for(int k=0;k<d2.length;k++){

                    System.out.print(d2[k]+"");

           }

 

}

//希尔排序

public static int[] xier(int str[],int d[]){

           int temp;int d1;

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

              d1=d[i];

                    for(int k=0;k<d1;k++){

                    //直接插入排序

                    for(intj=k;j<(str.length-d1);j=j+d1){

                             temp=str[j+d1];

                             int m=j;

                             while(m>=0&&str[m]>temp){

                                       str[m+d1]=str[m];

                                       m=m-d1;

                             }

                             str[m+d1]=temp;

                    }

            }

           }

           return str;

}

 

}

2. 选择排序法

（1）直接选择排序法

/**

 * 功能：实现直接选择排序；时间复杂度为O(n²);是不稳定的排序算法。

 * 基本思想：从待排序的数据元素集合中选取关键字最小的数据元素并将它与原始数据元素集合中* 的第一个数据元素交换位置，然后从不包括第一个位置上数据元素的集合中选取关键字最小的*  *数据元素，并将它与原始数据元素集合中的第二个数据元素交换位置，如此重复，指导数据元素* *集合中只剩一个元素为止。

 */

package com.zyy.sorts;

public class DSelectSort {

         publicstatic void main(String[] args) {

                   intarr[]={1,35,6,27,23};

                   //调用排序法

                   intd[]=dselect(arr);

                   for(ints:d){

                            System.out.print(s+"");

                   }

         }

        

         publicstatic int[] dselect(int arr[]){

                   inttemp;int min;

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

                            min=i;

                            for(intj=i+1;j<arr.length;j++){

                                     if(arr[min]>arr[j]){

                                               min=j;

                                     }

                            }

                      if(min!=i){

                                     temp=arr[i];

                                     arr[i]=arr[min];

                                     arr[min]=temp;

                            }

                   }

                   returnarr;

         }

 

}

3．  交换排序

（1）      冒泡

/**

 *功能：实现冒泡排序

 */

packagecom.zyy.sorts;

 

public classBubbleSort {

public static void main(String[] args) {

           int a[]={15,6,75,32,12};

           int arr[]=bubbleSort(a);

           for(int s:arr){

                    System.out.print(s+"");

           }

}

//冒泡排序

public static int[] bubbleSort(int arr[]){

           int temp;

           int flag=1;

           for(int i=0;i<arr.length-1;i++){

                    flag=0;

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

                             if(arr[j]>arr[j+1]){

                                       flag=1;

                                       temp=arr[j];

                                       arr[j]=arr[j+1];

                                       arr[j+1]=temp;

                             }

                    }

           }

           return arr;

}

 

}

（2）      快速排序法

packagecom.zyy.sorts;

 

public classQuickSort {

 

public static void main(String[] args) {             

           int a[]={15,6,75,32,12};

           int arr[]=quickSort(a,0,a.length-1);

           for(int s:arr){

                    System.out.print(s+"");

           }

}

public static int[] quickSort(int arr[],intlow,int high){

           int i=low, j=high;

           int temp=arr[i];

           while(i<j){

                    while(i<j&&temp<=arr[j])j--; //在数组的右端扫描

                    if(i<j){

                             arr[i]=arr[j];

                             arr[j]=temp;

                    }

                    while(i<j&&temp>arr[i])i++;

                    if(i<j){

                             arr[j]=arr[i];

                             j--;

                    }

           }

           arr[i]=temp;

           if(low<i) quickSort(arr,low,i-1);

           if(i<high)quickSort(arr,j+1,high);

           return arr;

}

 

}