Java

排序算法总结
1.冒泡排序
算法描述：
    在要排序的一组数中，先拿第一个数与其后所有的数做比较，遇到比它小的就做交换；然后拿第二
个数与其后的所有数做比较，遇到比它小的就交换；一直到最后两个数做比较，小的在前，大的在后。
优点：比较稳定
缺点：比较次数多
1,4,2,7,0,8,6,9,5,3
0,4,2,7,1,8,6,9,5,3
0,2,4,7,1,8,6,9,5,3
0,2,1,7,4,8,6,9,5,3
         .
         .
         .


示例代码：
//定义一个数组测试类
public class ArrayTest
{

/**
* 主函数
*/
public static void main(String[] args)
            {
                //实例化一个数组测试对象
ArrayTest at=new ArrayTest();
                //定义一个数组并初始化
        int []array={1,4,2,7,0,8,6,9,5,3};
                //循环实现遍历该数组
                for (int i = 0; i < array.length; i++)
                    {
    int t = array[i];
    System.out.print(t + "\t");
     }
                 //换行
        System.out.println();
                //调用排序方法
                array=at.maopaoCollate(array);
                 //遍历输出排序后的数组
                for (int i = 0; i < array.length; i++)
                    {
int t = array[i];
System.out.print(t + "\t");
             }
             }
          //定义冒泡排序的方法
         public int[] maopaoCollate(int []arr)
{
   for (int i = 0; i < arr.length-1; i++)
              {

       for (int j = i + 1; j < arr.length; j++)
        {
//如果前面的数较大，则交换位置
if (arr[i] > arr[j])
           {
     int temp = arr[i];
     arr[i] = arr[j];
     arr[j] = temp;
           }

        }

      }
                //返回排好序的数组
return arr;

  }
}
               
                   
2.希尔排序
算法描述：
     将一组数分成相同个数的几组，将每一组的第一个数比较，小的放前面，大的放后面，再比较第二个，第三个.....,一直到最后一个；
再将该数组分成更多的组，依照前面的方法进行比较。
优点：比较次数相对较少
缺点：不稳定，不易理解
1  4  2  7  0          8  6  9  5  3  //先分成两组，比较
1  4  2  5  0          8  6  9  7  3

1 4    2 7    0 8   6 9   5 3  //分成五组，比较
0 3    1 4    2 7   5 8   6 9

0   3   1   4   2   7   5   8   6   9//分成十组，比较
0   1   2   3   4   5   6   7   8   9
  
示例代码：
public class ArrayTest3 {

/**
* 主函数
*/
public static void main(String[] args)
{
//实例化一个数组测试对象
ArrayTest3 at=new ArrayTest3();
//定义一个数组并初始化
int []array={1,4,2,7,0,8,6,9,5,3};
//循环实现遍历该数组
        for (int i = 0; i < array.length; i++) {
int t = array[i];
System.out.print(t + "\t");
}
        //换行
    System.out.println();
    //调用希尔排序方法
array=at.shellCollate(array);
//循环实现遍历该数组，输出排序后的数组
        for (int i = 0; i < array.length; i++) {
int t = array[i];
System.out.print(t + "\t");
}

}
//定义希尔排序方法
public int[] shellCollate(int arr[])
{
//将数组分祖
for(int increment=arr.length/2;increment>0;increment/=2)
{
  //将分好组的数排序
  for(int i=increment;i<arr.length-1;i++)
   {
     int temp=arr[i];
     int j=0;
     for(j=i;j>=increment;j-=increment)
       {
//比较，如果前面的小于后面的，则交换
if(temp<arr[j-increment])
{
    arr[j]=arr[j-increment];
  }
    else
       break;
}
arr[j]=temp;
}
}

//返回排好序的数组
return arr;

     }

}