常见排序算法实现java

冒泡排序 （稳定）

public static void B(int nums[]){
        for(int i=nums.length-1;i>0;i--){
            for(int j=0;j<i;j++){
                if(nums[j]>nums[j+1]){
                    int temp=nums[j];
                    nums[j]=nums[j+1];
                    nums[j+1]=temp;
                }
            }
        }
    }

 归并排序 （稳定）

public static void guibing(int low,int high,int num[],int res[]){
        if(low<high){
            int mid=(low+high)/2;
            int l_res[]=new int[mid-low+1];
            int r_res[]=new int[high-mid];
            guibing(low,mid,num,l_res);
            guibing(mid+1,high,num,r_res);
            merge(l_res,r_res,res);
        }else{
            res[0]=num[low];
        }
    }
    public static void merge(int l_res[],int r_res[],int res[]){
        int i=0,j=0;
        while(i<l_res.length && j<r_res.length){
            if(l_res[i]>r_res[j]){
                res[i+j]=r_res[j];
                j++;
            }else{
                res[i+j]=l_res[i];
                i++;
            }
        }
        while(i<l_res.length){
            res[i+j]=l_res[i];
            i++;
        }
        while(j<r_res.length){
            res[i+j]=r_res[j];
            j++;
        }
    }

直接插入排序 （稳定）

public static void Insert(int nums[]){
        for(int i=1;i<nums.length;i++){
            int temp=nums[i],j=i-1;
            for(j=i-1;j>=0;j--){
                if(temp<nums[j])
                    nums[j+1]=nums[j];
                else
                    break;

            }
            nums[j+1]=temp;
        }
    }

堆排序  

//堆排序
    public static void Heap(int array[]){
        //从最后一个非叶子节点向前逐步建立堆
        for(int i=(array.length-2)/2;i>=0;i--){
            Adjustheap(array,i,array.length-1);
        }
        Print(array);
        //从后向前放置堆顶元素
        for(int i=array.length-1;i>0;i--){
            swap(array,0,i);
            Adjustheap(array,0,i-1);
        }
    }
    //模拟调整的过程
    public static void Adjustheap(int arr[],int start,int end){
        int dad = start;
        int son = dad * 2 + 1;
        while (son <= end) { //若子节点指标在范围内才做比较
            if (son + 1 <= end && arr[son] < arr[son + 1]) //先比较两个子节点大小，选择最大的
                son++;
            if (arr[dad] > arr[son]) //如果父节点大於子节点代表调整完毕，直接跳出函数
                return;
            else { //否则交换父子内容再继续子节点和孙节点比较
                swap(arr,dad, son);
                dad = son;
                son = dad * 2 + 1;
            }
        }
    }
    //交换元素
    public static void swap(int array[],int i,int j){
        int temp=array[i];
        array[i]=array[j];
        array[j]=temp;
    }

 

选择排序 

public static void Select(int nums[]){
        for(int i=0;i<nums.length;i++){
            int min=i;
            for(int j=i+1;j<nums.length;j++){
                if(nums[min]>nums[j])
                    min=j;
            }
            int temp=nums[min];
            nums[min]=nums[i];
            nums[i]=temp;
        }
    }

快速排序

 

void  Qsort(int nums[],int start,int end){
        if(start<end){
            int index=Partion(nums,start,end);
            Qsort(nums,start,index-1);
            Qsort(nums,index+1,end);
        }
    }
    int Partion(int nums[],int start,int end){
        int q=start;
        for(int i=start+1;i<=end;i++)
            if(nums[i]<nums[start])
                Swap(nums,i,++q);
        Swap(nums,start,q);
        return q;
    }
    void Swap(int nums[],int i,int j){
        if(i!=j){
            nums[i]^=nums[j];
            nums[j]^=nums[i];
            nums[i]^=nums[j];
        }
    }