java的几种常用的排序

• 排序

排序是将一群数据，依指定的顺序进行排列的过程

排序的分类

1.内部排序

指将需要处理的所有数据都加载到内部存储器中进行排序，包括（ 交换式排序法， 选择式排序法和 插入式排序法）

2.外部排序

数据量过大，无法全部加载到内存中，需要借助外部存储进行排序，包括（ 合并排序法和 直接合并排序法）

• 交换式排序

1.冒泡排序法（Bubble sort）

2.快速排序法（Quick sort）

• 选择式排序

1.选择排序法（Selection sort）

2.堆排序法（Heap sort）

• 插入式排序

1.插入式排序法（Insertion sort）

2.谢尔排序法（Shell sort）

3.二叉式排序法（Binary-tree sort）

//快速排序
class QuickSort{
    public void sort(int [] a, int low, int high )
    {
       int pos;
       if (low<high)
       {
           pos = FindPos(a, low, high);
           sort(a, low, pos-1);
           sort(a, pos+1, high);
       }
    }
    public int FindPos(int [] a, int low, int high)
    {
       int val = a[low];
       while (low<high)
       {
           while (low<high && a[high]>=val)
              --high;
           a[low] = a[high];
           while (low<high && a[low]<=val)
              ++low;
           a[high] = a[low];
       }
       a[low] = val;
       return low;
    }
}

//插入排序
class InsertSort{
    public void sort(int arr[]){
       for(int i=1;i<arr.length;i++)
       {
           int insertVal=arr[i];
           //insertVal准备和前一个数比较
           int index=i-1;
           while(index>=0&&insertVal<arr[index])
           {
              //将把arr[index]向后移动
              arr[index+1]=arr[index];
              //让index向前移一位
              index--;
           }
           arr[index+1]=insertVal;
       }
    }
}

//选择排序
class Select{
    public void sort(int arr[]){
       int temp=0;
       //认为第一个最小
       for(int j=0;j<arr.length-1;j++)
       {
           int min=arr[j];
           //记录最小数的下标
           int minIndex=j;
           for(int k=j+1;k<arr.length;k++)
           {
              if(min>arr[k])
              {
                  //修改最小
                  min=arr[k];
                  minIndex=k;
              }
           }
           //当退出for就找到这次的最小值
           temp=arr[j];
           arr[j]=arr[minIndex];
           arr[minIndex]=temp;
       }
    }
}

//冒泡排序
class Bubble{
    public void sort(int arr[]){
       int temp=0;
       //排序
       //外层循环，它决定一共走几趟
       for(int i=0;i<arr.length-1;i++)
       {
           //内层循环，开始逐个比较，如果发现前一个数比后一个书则交换
           for(int j=0;j<arr.length-1-i;j++)
           {
              if(arr[j]>arr[j+1])
              {
                  //换位
                  temp=arr[j];
                  arr[j]=arr[j+1];
                  arr[j+1]=temp;
              }
           }
       }
    }
}