java算法-排序

排序算法

冒泡排序

• 比较前后相邻的二个数据，如果前面数据大于后面的数据，就将这二个数据交换
• 这样对数组的第 0 个数据到 N-1 个数据进行一次遍历后，最大的一个数据就“沉”到数组第 N-1 个位置
• N=N-1，如果 N 不为 0 就重复前面二步，否则排序完成

public static void bubbleSort1(int [] a, int n){
     int i, j;
     for(i=0; i<n; i++){
         //表示 n 次排序过程。
         for(j=1; j<n-i; j++){
             if(a[j-1] > a[j]){//前面的数字大于后面的数字就交换
                 //交换 a[j-1]和 a[j]
                 int temp;
                 temp = a[j-1];
                 a[j-1] = a[j];
                 a[j]=temp;
             }
         }
     }
}

插入排序

通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应的位置并插入.

类似于整扑克牌。在开始摸牌时，左手是空的，牌面朝下放在桌上。接着，一次从 桌上摸起一张牌，并将它插入到左手一把牌中的正确位置上。为了找到这张牌的正确位置，要将 它与手中已有的牌从右到左地进行比较。无论什么时候，左手中的牌都是排好序的。

public void sort(int arr[])
 {
     for(int i =1; i<arr.length;i++)
     {
         //插入的数
         int insertVal = arr[i];
         //被插入的位置(准备和前一个数比较)
         int index = i-1;
         //如果插入的数比被插入的数小
         while(index>=0&&insertVal<arr[index])
         {
             //将把 arr[index] 向后移动
             arr[index+1]=arr[index];
             //让 index 向前移动
             index--;
         }
         //把插入的数放入合适位置
         arr[index+1]=insertVal;
     }
 }

快速排序

选择一个关键值作为基准值。比基准值小的都在左边序列（一般是无序的）， 比基准值大的都在右边（一般是无序的）。一般选择序列的第一个元素。

一次循环：从后往前比较，用基准值和最后一个值比较，如果比基准值小的交换位置，如果没有 继续比较下一个，直到找到第一个比基准值小的值才交换。找到这个值之后，又从前往后开始比 较，如果有比基准值大的，交换位置，如果没有继续比较下一个，直到找到第一个比基准值大的 值才交换。直到从前往后的比较索引>从后往前比较的索引，结束第一次循环，此时，对于基准值 来说，左右两边就是有序的了。

public void sort(int[] a,int low,int high){
 int start = low;
 int end = high;
    int key = a[low]; 
 while(end>start){
 //从后往前比较
 while(end>start&&a[end]>=key) 
//如果没有比关键值小的，比较下一个，直到有比关键值小的交换位置，然后又从前往后比较
 end--;
 if(a[end]<=key){
 int temp = a[end];
 a[end] = a[start];
 a[start] = temp;
 }
 //从前往后比较
 while(end>start&&a[start]<=key)
//如果没有比关键值大的，比较下一个，直到有比关键值大的交换位置
 start++;
 if(a[start]>=key){
 int temp = a[start];
 a[start] = a[end];
 a[end] = temp;
 }
 //此时第一次循环比较结束，关键值的位置已经确定了。左边的值都比关键值小，右边的
值都比关键值大，但是两边的顺序还有可能是不一样的，进行下面的递归调用
 }
 //递归
 if(start>low) sort(a,low,start-1);//左边序列。第一个索引位置到关键值索引-1
 if(end<high) sort(a,end+1,high);//右边序列。从关键值索引+1 到最后一个
 }
 }

希尔排序

先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列 中的记录“基本有序”时，再对全体记录进行依次直接插入排序。

private void shellSort(int[] a) {
int dk = a.length/2; 
while( dk >= 1 ){ 
 ShellInsertSort(a, dk); 
 dk = dk/2;
}
}
private void ShellInsertSort(int[] a, int dk) {
//类似插入排序，只是插入排序增量是 1，这里增量是 dk,把 1 换成 dk 就可以了
for(int i=dk;i<a.length;i++){
if(a[i]<a[i-dk]){
int j;
int x=a[i];//x 为待插入元素
a[i]=a[i-dk];
for(j=i-dk; j>=0 && x<a[j];j=j-dk){
//通过循环，逐个后移一位找到要插入的位置。
a[j+dk]=a[j];
}
a[j+dk]=x;//插入
}
}
}

归并排序

归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列 分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

public class MergeSort {
    public static void main(String []args){
        int []arr = {9,8,7,6,5,4,3,2,1};
        sort(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void sort(int []arr){
        int []temp = new int[arr.length];//在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
        sort(arr,0,arr.length-1,temp);
    }
    private static void sort(int[] arr,int left,int right,int []temp){
        if(left<right){
            int mid = (left+right)/2;
            sort(arr,left,mid,temp);//左边归并排序，使得左子序列有序
            sort(arr,mid+1,right,temp);//右边归并排序，使得右子序列有序
            merge(arr,left,mid,right,temp);//将两个有序子数组合并操作
        }
    }
    private static void merge(int[] arr,int left,int mid,int right,int[] temp){
        int i = left;//左序列指针
        int j = mid+1;//右序列指针
        int t = 0;//临时数组指针
        while (i<=mid && j<=right){
            if(arr[i]<=arr[j]){
                temp[t++] = arr[i++];
            }else {
                temp[t++] = arr[j++];
            }
        }
        while(i<=mid){//将左边剩余元素填充进temp中
            temp[t++] = arr[i++];
        }
        while(j<=right){//将右序列剩余元素填充进temp中
            temp[t++] = arr[j++];
        }
        t = 0;
        //将temp中的元素全部拷贝到原数组中
        while(left <= right){
            arr[left++] = temp[t++];
        }
    }
}

基数排序

将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零。然后，从最低位 开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后,数列就变成一个有序序 列。

 public class radixSort {
inta[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,101,56,17,18,23,34,15,35,2
5,53,51};
public radixSort(){
sort(a);
for(inti=0;i<a.length;i++){
System.out.println(a[i]);
}
}
public void sort(int[] array){
//首先确定排序的趟数;
int max=array[0];
for(inti=1;i<array.length;i++){
if(array[i]>max){
    max=array[i];
}
}
int time=0;
//判断位数;
while(max>0){
max/=10;
time++;
}
//建立 10 个队列;
List<ArrayList> queue=newArrayList<ArrayList>();
for(int i=0;i<10;i++){
ArrayList<Integer>queue1=new ArrayList<Integer>();
queue.add(queue1);
}
//进行 time 次分配和收集;
for(int i=0;i<time;i++){
//分配数组元素;
for(intj=0;j<array.length;j++){
//得到数字的第 time+1 位数;
int x=array[j]%(int)Math.pow(10,i+1)/(int)Math.pow(10, i);
ArrayList<Integer>queue2=queue.get(x);
queue2.add(array[j]);
queue.set(x, queue2);
}
int count=0;//元素计数器;
//收集队列元素;
for(int k=0;k<10;k++){
while(queue.get(k).size()>0){
ArrayList<Integer>queue3=queue.get(k);
array[count]=queue3.get(0);
queue3.remove(0);
count++;
}
}
}
}
}

java算法-排序

原文：https://www.cnblogs.com/oyzy1999/p/14862746.html