java算法排序

好久以前整理的一些排序，现在发上来。只有一些代码，没有做思路解析，给大家复习看看，部分排序也用了迭代和递归来实现。对于算法类，我强烈推荐先了解思路，在自己敲，然后不懂在看别人的代码。
这里有一篇我认为不错的博客，对排序算法流程不是很了解的同学可以去看看https://www.cnblogs.com/itsharehome/p/11058010.html

交换

public staic void swap(int[] arr,int i,int min){
    int temp=arr[i];
    arr[i]=arr[j];
    arr[j]=temp;
}

选择排序

public  static void selectSort(int[] arr){
    for(int i=0;i<arr.length;i++){
        int min=i;
        for(int j=i+1;j< arr.length;j++){
            if(arr[min]>arr[j]){
                min=j;
            }
        }
        if(min!=i)
            swap(arr,i,min);
    }
}

插入排序

每当后面比前面小，就交换

public static void insertSort1(int[] arr){
    for(int i=1;i<arr.length;i++){
        int j=i;
        while(j>0&&arr[j]<arr[j-1]){
            swap(arr,j,j-1);
            j--;
        }
    }
}

当前面比后面小，记录，最后移动

public static void insertSort2(int[] arr){
    for(int i=1;i<arr.length;i++){
        int j=i;
        int temp=arr[j];
        while(j>0&&temp<arr[j]){
            j--;
        }
        for(int k=i;k>j;k--){
            arr[k]=arr[k-1];
        }
        arr[j]=temp;
    }
}

冒泡排序

public static void bubbleSort1(int[] arr){
    for(int i=arr.length-1;i>0;i--){
        for(int j=0;j<i;j++){
            if(arr[j]>arr[j+1]){
                swap(arr,j,j+1);
            }
        }
    }
}

优化后，如果已经有序了，就会结束排序过程

public static void bubbleSort2(int[] arr){
    for(int i=arr.leng-1;i>0;i--){
        boolean flag=true;
        for(int j=0;j<i;j++){
            if(arr[j]>arr[j+1]){
                flag=false;
                swap(arr,j,j+1);
            }
            if(flag)
                return;
        }
    }
}

堆排序

public static void heapSort(int[] arr){
    //创建大顶堆
    for(int i=arr.length/2;i>=0;i--){
      heapAdjust(arr,i,arr.length-1);  
    }
    //把最大的数放到最后，然后再建一次大顶堆
    for(int i=n-1;i>=0;i--){
        swap(arr,0,i);
        heapAdjust(arr,0,i-1);
    }
}
private static void heapAdjust(int[] arr,int parent,int n){
    int temp=arr[parent];
    int chlid=2*parent+1;
    while(child<=n){
        if(child+1<=n&&arr[child+1]){
            child++;
        }
        if(arr[child]<=temp)break;
        arr[parent]=arr[child];
        parent=child;
        child=2*parent+1;
    }
    arr[parent]=temp;
}

归并排序

//递归方法
public static void mergeSort(int[] arr,int left,int right){
        if(left<right){
            int mid=(left+right)/2;
            mergeSort(arr,left,mid);
            mergeSort(arr,mid+1,right);
            merge(arr,left,mid,right);
        }
    }
//迭代
public static void mergeSort(int[] arr){
        int n=arr.length;
        for(int i=1;i<n;i+=i){
            int left=0;
            int mid=left+i-1;
            int right=mid+i;
            while(right<n){
                merge(arr,left,mid,right);
                left=right+1;
                mid=left+i-1;
                right=mid+i;
            }
            if(left<n&&mid<n){
                merge(arr,left,mid,n-1);
            }
        }
    }
private  static void merge(int[] arr,int left,int mid,int right){
        int[] a=new int[right-left+1];
        int i=left;
        int j=mid+1;
        int k=0;
        while(i<=mid&&j<=right){
            if(arr[i]<arr[j]){
                a[k++]=arr[i++];
            }else{
                a[k++]=arr[j++];
            }
        }
        while(i<=mid)a[k++]=arr[i++];
        while(j<=right)a[k++]=arr[j++];
        for(i=0;i<k;i++){
            arr[left++]=a[i];
        }
    }

快速排序

//递归方法
public static void quickSort(int[] arr,int low, int high){
    if(arr.length<=0)return;
    if(low>=high)return;
    int left=low;
    int right=high;
    int temp=arr[left];
    while(left<right){
        while(left<right&&arr[right]>=temp){
            right--;
        }
        arr[left]=arr[right];
        while(left<right&&arr[left]<=temp){
            left++;
        }
        arr[right]=arr[left];
    }
    arr[left]=temp;
    quickSort(arr, low, left-1);
    quickSort(arr, left+1, high);
}

计数排序

    public static void countSort(int[] arr,int k){
        int[] C=new int[k+1];//构造C数组
        int length=arr.length,sum=0;//获取A数组大小用于构造B数组  
        int[] B=new int[length];//构造B数组
        for(int i=0;i<length;i++)
        {
            C[arr[i]]+=1;// 统计A中各元素个数，存入C数组
        }
        for(int i=0;i<k+1;i++)//修改C数组
        {
            sum+=C[i];
            C[i]=sum;
        }
        for(int i=length-1;i>=0;i--)//遍历A数组，构造B数组
        {

            B[C[arr[i]]-1]=arr[i];//将A中该元素放到排序后数组B中指定的位置
            C[arr[i]]--;//将C中该元素-1，方便存放下一个同样大小的元素
        }
    }