常用排序算法

最新推荐文章于 2024-08-24 16:09:10 发布

_高远

最新推荐文章于 2024-08-24 16:09:10 发布

阅读量505

点赞数

分类专栏：算法文章标签：排序算法快排堆排序归并排序

本文链接：https://blog.csdn.net/wgyscsf/article/details/63252848

版权

算法专栏收录该内容

1 篇文章 0 订阅

订阅专栏

常用排序算法

分类结构图

复杂度

分类

交换冒泡排序

import  java.util.Arrays;
public class BubbleExchangeSort{
    public static void main(String[] args){
        int[] arr=new int[]{5,7,1,3,5,1,0,6};
        sort(arr);
        System.out.println(Arrays.toString(arr));
    }
    private static void sort(int[] arr){
        for(int i=0;i<arr.length-1;i++){
            for(int j=i+1;j<arr.length;j++){
                if(arr[j]<arr[i]){
                    int temp=arr[j];
                    arr[j]=arr[i];
                    arr[i]=temp;
                }
            }
        }
    }
}

交换快速排序

动画 http://v.youku.com/v_show/id_XMzMyODk4NTQ4.html

徒手写代码

第一次写出错地方：improt java.utils.arrays—>improt java.util.Arrays

sort(arr,0,arr.length);—->sort(arr,0,arr.length-1);

import java.util.Arrays;

public class QuickChangeSort{
    //切分算法
    private static int partition(int[] arr,int lo,int hi){
        int key=arr[lo];
        while(lo<hi){
            while(arr[hi]>=key&&lo<hi)
                hi--;
            arr[lo]=arr[hi];
            while(arr[lo]<=key&&lo<hi)
                lo++;
            arr[hi]=arr[lo];
        }
        arr[hi]=key;
        return hi;
    }   

    //排序算法
    private static void sort(int[] arr,int lo,int hi){
        //终止条件以及异常处理
        if(arr==null||lo>=hi)return;
        int index=partition(arr,lo,hi);
        sort(arr,lo,index-1);
        sort(arr,index+1,hi);
    }

    //test
    public static void main(String[] args){
        int[] arr=new int[]{5,4,8,6,7,9};
        sort(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));
    }

}

插入直接排序

思路：
- 第一步：从第二个元素开始一次加一，依次和前面所有元素比较。
- 第二步：若该元素小于比较的元素，前面的元素后移；接着比较前面的元素，接着后移。不满足“小于”的条件，将该元素插入到空下的位置。
- 重复一二步骤。

实现

import java.util.Arrays;
public class DircetInsertSort{
    public static void main(String[] args){
        int[] arr=new int[]{5,3,1,4,2,6,9};
        sort(arr);
        System.out.println(Arrays.toString(arr));
    }

    //直接插入排序
    private static void sort(int[] arr){
        //标记待比较的值
        int temp=0;
        for(int i=1;i<arr.length;i++){
            temp=arr[i];
            int j;
            for(j=i-1;j>=0;j--){
                //注意这个比较条件，和待比较数据比较
                if(temp<arr[j]){
                    //是所有大于待比较数据都要后移
                    arr[j+1]=arr[j];
                }else break;
            }
            arr[j+1]=temp;
        }
    }

}

插入希尔排序排序

import java.util.Arrays;
public class ShellInsertSort{
    public static void main(String[] agrs){
        int[] arr=new int[]{4,5,2,7,6,27,2,8,2,5};
        sort(arr);
        System.out.println(Arrays.toString(arr));
    }
    /*  0. 获取数组长度：int a=数组长度;
        1.a的一半为增量值。
        2. 以该增量为基数，对比数据，将小的数据交换到前面。遍历所有数据。
        3. 重复1、2步骤。终止条件：增量值小于1。
    */
    private static void sort(int[] arr){
        //获取初试增量值
        int incrementNum=arr.length/2;
        while(incrementNum>0){
            for(int i=0;i<arr.length;i++){
                for(int j=i+incrementNum;j<arr.length;j+=incrementNum){
                    if(arr[j]<arr[i]){
                        int temp=arr[i];
                        arr[i]=arr[j];
                        arr[j]=temp;
                    }
                }
            }
            incrementNum/=2;
        }
    }
}

选择简单排序

思路：每轮比较出最小的值的索引，然后和待比较值交换位置。接着比较下一个，一直进行即可。

    import java.util.Arrays;
    public class SimpleChooseSort{
        //简单选择算法
        private static void sort(int[] arr){
            int minIndex=0;
            for(int i=0;i<arr.length-1;i++){
                minIndex=i;
                for(int j=i+1;j<arr.length;j++){
                    // 这里是和arr[min]比较，不是和arr[i]比较
                    if(arr[j]<arr[minIndex]){
                        minIndex=j;
                    }
                }
                if(minIndex!=i){
                    int temp=arr[i];
                    arr[i]=arr[minIndex];
                    arr[minIndex]=temp;
                }
            }
        }
        public static void main(String[] args){
            int[] arr=new int[]{5,7,1,3,5,1,0,6};
            sort(arr);
            System.out.println(Arrays.toString(arr));
        }
    }

选择堆排序

    /*
     * 堆选择排序
     */
    public static void heapChooseSort(int[] array) {
        buildHeap(array);// 构建堆
        int n = array.length;
        int i = 0;
        for (i = n - 1; i >= 1; i--) {
            swap(array, 0, i);
            heapify(array, 0, i);
        }
    }

    public static void buildHeap(int[] array) {
        int n = array.length;// 数组中元素的个数
        for (int i = n / 2 - 1; i >= 0; i--)
            heapify(array, i, n);

    }

    public static void heapify(int[] A, int idx, int max) {
        int left = 2 * idx + 1;// 左孩子的下标（如果存在的话）
        int right = 2 * idx + 2;// 左孩子的下标（如果存在的话）
        int largest = 0;// 寻找3个节点中最大值节点的下标
        if (left < max && A[left] > A[idx])
            largest = left;
        else
            largest = idx;
        if (right < max && A[right] > A[largest])
            largest = right;
        if (largest != idx) {
            swap(A, largest, idx);
            heapify(A, largest, max);
        }

    }

    public static void swap(int[] array, int i, int j) {
        int temp = 0;
        temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

归并排序

    import java.util.Arrays;
    public class MergeSort{

        /*
         * 思路：以mid为分界线，左右两边依次比较，取小的放到临时数组中。直到所有全部处理完。再把临时数据放到arr[lo,hi]中。
         * 1. 在满足lo<hi的前提下，取左开始指针lp=lo，右指针rp=mid+1;
         * 2. 左右指针的值对比，取小的放到临时数组中，所对应指针加一，临时数组指针加一。
         * 3. 
         */
        private static void merge(int[] arr,int lo,int mid,int hi){
            //临时数组
            int[] tempArr=new int[hi-lo+1];
            //临时数组下标
            int index=0;
            //左右指针
            int lp=lo,rp=mid+1;
            while(lp<=mid&&rp<=hi){
                if(arr[lp]<arr[rp]){
                    tempArr[index++]=arr[lp++];
                }else{
                    tempArr[index++]=arr[rp++];
                }
            }

            while(lp<=mid)
                tempArr[index++]=arr[lp++];
            while(rp<=hi)
                tempArr[index++]=arr[rp++];

            //归并
            for(int i=0;i<tempArr.length;i++){
                arr[lo++]=tempArr[i];
            }
        }

        private static void sort(int[] arr,int lo,int hi){
            if(arr==null||lo>=hi)return;
            int mid=(lo+hi)/2;
            sort(arr,lo,mid);
            sort(arr,mid+1,hi);
            merge(arr,lo,mid,hi);
        }

        public static void main(String[] agrs){
            int[] arr=new int[]{4,5,2,7,6,27,2,8,2,5};
            sort(arr,0,arr.length-1);
            System.out.println(Arrays.toString(arr));
        }
    }

基数排序

/*
 * 基数排序法
 */
public static void radixSort(int[] number, int d) {
    int k = 0;
    int n = 1;
    int m = 1;
    int[][] temp = new int[number.length][number.length];
    int[] order = new int[number.length];
    while (m <= d) {
        for (int i = 0; i < number.length; i++) {
            int lsd = ((number[i] / n) % 10);
            temp[lsd][order[lsd]] = number[i];
            order[lsd]++;
        }
        for (int i = 0; i < d; i++) {
            if (order[i] != 0)
                for (int j = 0; j < order[i]; j++) {
                    number[k] = temp[i][j];
                    k++;
                }
            order[i] = 0;
        }
        n *= 10;
        k = 0;
        m++;
    }
}

_高远

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
常用排序算法

常用排序算法分类结构图复杂度分类交换冒泡排序import java.util.Arrays;public class BubbleExchangeSort{ public static void main(String[] args){ int[] arr=new int[]{5,7,1,3,5,1,0,6}; sort(arr); Sys
复制链接

扫一扫

专栏目录