几种排序算法java版本

最新推荐文章于 2025-05-14 18:26:37 发布

Fatal Error

最新推荐文章于 2025-05-14 18:26:37 发布

阅读量482

点赞数 1

CC 4.0 BY-SA版权

分类专栏：数据结构与算法

本文链接：https://blog.youkuaiyun.com/gf0515/article/details/81064172

数据结构与算法专栏收录该内容

1 篇文章

订阅专栏

本文详细介绍了五种经典的排序算法：冒泡排序、插入排序、归并排序、快速排序和改进的插入排序。每种算法都附有详细的代码实现，帮助读者深入理解算法的工作原理和应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

很早以前的代码了，今天发在这里备份一下，也供有需要的朋友参考。

1. 排序中的数值交换

/**
     * 交换数组中的两个值的位置
     * @param datas
* @param ind1
     * @param ind2
     */
    private static void swap(int[] datas, int ind1, int ind2){
        try{
            int temp = datas[ind1];
            datas[ind1] = datas[ind2];
            datas[ind2] = temp;
        }catch (Exception ex){
            System.out.println(ex.getMessage());
        }
    }

2. 冒泡排序

/**
     * 冒泡排序
     * @param datas
     * @return
     */
    public static void Bubble(int[] datas){
        int end = datas.length - 1;
        for(int i = 0; i < end;i++){
            boolean flag = true;
            for(int j = 0; j < end - i; j++){
                if(datas[j] > datas[j + 1]){
                    swap(datas, j , j + 1);
                    flag = false;
                }
            }

            if(flag) break;
        }
    }

3. 插入排序

/**
     * 插入排序
     * @param datas
     */
    public static void insert(int[] datas){
        for(int i = 1; i < datas.length; i++){
            for(int j = i; j > 0;j--){
                if(datas[j] < datas[j - 1]){
                    swap(datas, j, j - 1);
                }
            }
        }
    }

4. 归并排序

// *************** 归并排序 **************************//
    public static void sort(int[] datas, int left, int right, int[] temp){
        if(left < right){
            int mid = (left + right) >> 1;
            sort(datas, left, mid, temp);
            sort(datas, mid + 1, right, temp);
            merge(datas, left, mid, right, temp);
        }
    }


    public static void merge(int[] datas, int left, int mid, int right, int[] temp){
        int i = left;
        int j = mid + 1;
        int t = 0;
        while(i <= mid && j <= right){
            if(datas[i] < datas[j]){
                temp[t++] = datas[i++];
            }else {
                temp[t++] = datas[j++];
            }
        }

        while(i <= mid){
            // 左侧剩余数据
            temp[t++] = datas[i++];
        }

        while(j <= right){
            // 右侧剩余数据
            temp[t++] = datas[j++];
        }

        // 将临时数组中的数据拷贝到原数组中
        t = 0;
        while(left <= right){
            datas[left++] = temp[t++];
        }
    }
    // *************************************************//

5. 快速排序

public static void fast(int[] datas, int left, int right){
        if(left >= right) return;
        if(datas.length < 10){
            insertPos(datas, left, right);
            return;
        }

        int l = left;
        int r =right;
        int val = datas[left];
        int mid = (left + right) >> 1;
        int ind = left;
        if((datas[left] - datas[mid]) * ( datas[right] - datas[mid]) < 0){
            ind = mid;
            val = datas[mid];
        }else if((datas[left] - datas[right]) * (datas[mid] - datas[right]) < 0){
            ind = right;
            val = datas[right];
        }

        if(left != ind) {
            swap(datas, left, ind);
        }

        while (l < r){
            // 右侧开始找比val小的值
            while(datas[r] >= val && l < r){
                r--;
            }
            // 左侧开始找比val大的值
            while(datas[l] <= val && l < r){
                l++;
            }
            // 交换位置
            if(l < r){
                swap(datas, l, r);
            }
        }

        swap(datas, left, l);
        fast(datas, left, l - 1);
        fast(datas, l + 1, right);
    }

/**
     * 插入排序, 对数组指定数据段排序
     * @param datas
     */
    public static void insertPos(int[] datas, int left, int right){
        if(left < right){
            for(int i = left + 1; i < right; i++){
                for(int j = i; j > left;j--){
                    if(datas[j] < datas[j - 1]){
                        swap(datas, j, j - 1);
                    }
                }
            }
        }

    }