Java实现常用的排序算法

最新推荐文章于 2026-01-08 22:28:34 发布

原创最新推荐文章于 2026-01-08 22:28:34 发布 · 272 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #java #排序

Java 专栏收录该内容

2 篇文章

订阅专栏

这篇博客主要介绍了如何用Java实现两种经典的排序算法——冒泡排序和插入排序，详细解析了各自的实现过程。

常见排序算法（Java版）

1.冒泡排序

package Sort;

import java.util.Arrays;

public class BubbleSort {
    public static void main(String[] args) {
        int [] a =  {6, 3, 7, 2, 4, 9, 5, 8};
        bubbleSort(a);
        for (int i=0;i<A.length-1;i++) {
            System.out.print(A[i]);
        }        
        System.out.println();
    }
    public static int[] bubbleSort(int[] A) 
        for (int i=0;i<A.length-1;i++){
            for (int j=i+1;j<A.length;j++){
                if (A[i] > A[j]){
                    int tmp = A[i];
                    A[i] = A[j];
                    A[j] = tmp;
                }
            }
        }

    return A;
    }
}

3.插入排序

package Sort;

public class InsertionSort {
    public int[] insertionSort(int[] A, int n) {
        int i, j, temp;

        for(i = 1; i < n; i++){
            temp = A[i];
            //循环遍历已经排好序的部分，找出大于待排序数字的数字，交换位置
            for(j = i; j > 0 && A[j - 1] > temp; j-- ){
                A[j] = A[j - 1];
            }
            A[j] = temp;
        }

        return A;
    }
}
4.选择排序

package Sort;
//选择排序的主要思想是每次都从待排序的部分中找出最小的一个放到它应该在的位置，如最小的数字应该放在最左边。
public class SelectionSort {
    public int[] selectionSort(int[] A, int n) {
        // write code here
        for (int i = 0; i < n - 1; i++) {
            int index = i;
            int j;
            // 找出最小值得元素下标
            for (j = i + 1; j < n; j++) {
                if (A[j] < A[index]) {
                    index = j;
                }
            }
            int tmp = A[index];
            A[index] = A[i];
            A[i] = tmp;
        }
        return A;
    }
}
5. 归并排序

package Sort;

public class MergeSort {

    public static void main(String[] args) {
        int[] A =  {6, 3, 7, 2, 4, 9, 5, 8 };
        mergeSort(A, 5);
        for (int i = 0; i < A.length; i++) {
            System.out.println(A[i]);

        }
    }

    public static int[] mergeSort(int[] A, int n) {
        // write code here
        sort(A, 0, n - 1);
        return A;
    }

    public static void sort(int[] A, int left, int right) {
        if (left < right) {
            int mid = (left + right) / 2;
            sort(A, left, mid);
            sort(A, mid + 1, right);
            merge(A, left, mid, right);
        }
    }

    public static void merge(int[] A, int left, int mid, int right) {
        // 临时数组

        int n = right - left + 1;
        int[] tmpArr = new int[n];
        int l = left;
        int r = mid + 1;
        int t = 0;// 临时数组下标元素

        // 比较两子序列元素的大小
        while (l <= mid && r <= right) {
            if (A[l] < A[r]) {
                tmpArr[t++] = A[l++];
            } else {
                tmpArr[t++] = A[r++];
            }
        }

        // 剩余的加入临时数组
        while (l <= mid) {
            tmpArr[t++] = A[l++];
        }
        // 剩余的加入临时数组
        while (r <= right) {
            tmpArr[t++] = A[r++];
        }

        // 把临时数组元素放回原数组
        for (int i = 0; i < t; i++) {
            A[left + i] = tmpArr[i];
        }

    }
}

2.快速排序

package Sort;

import java.util.Arrays;

public class QuickSort {

    public static void main(String[] args) {
        int A[] = {6, 3, 7, 2, 4, 9, 5, 8 };
        quickSort(A, 0, 7);
        System.out.println(Arrays.toString(A));
    }

    public static void quickSort(int[] A, int left, int right) {

        if (left < right) {
            // 一次划分
            int mid = partion(A, left, right);
            quickSort(A, 0, mid - 1);
            quickSort(A, mid + 1, right);
        }
    }

    public static void swap(int[] A, int l, int r) {
        int tmp = A[l];
        A[l] = A[r];
        A[r] = tmp;

    }

    public static int partion(int[] a, int left, int right) {
        // 轴值，默认选取数组的第一个数字
        while (left < right) {
            while (left < right && a[left] <= a[right]) {
                right--;
            }
            if (left<right){
                swap(a, left, right);
            }
            while (left < right && a[left] <= a[right]) {
                left++;
            }
            if (left<right){
                swap(a, left, right);
            }
        }
        return left;
    }
}