欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

常用排序算法及Java实现

程序员文章站 2022-03-26 09:25:14
概述 在计算器科学与数学中,一个排序算法(英语:Sorting algorithm)是一种能将一串数据依照特定排序方式进行排列的一种算法。本文将总结几类常用的排序算法,包括冒泡排序、选择排序、插入排序、快速排序和归并排序。 算法原理及实现 1、冒泡排序 原理图 理解 通过重复地遍历要排序的列表,比较 ......

概述

在计算器科学与数学中,一个排序算法(英语:sorting algorithm)是一种能将一串数据依照特定排序方式进行排列的一种算法。本文将总结几类常用的排序算法,包括冒泡排序、选择排序、插入排序、快速排序和归并排序。


算法原理及实现

1、冒泡排序
  • 原理图

常用排序算法及Java实现

  • 理解

通过重复地遍历要排序的列表,比较每对相邻的项目,并在顺序错误的情况下交换它们。

  • java code
public class bubblesort {
  
    // logic to sort the elements
    public static void bubble_srt(int array[]) {
        int n = array.length;
        int k;
        for (int m = n; m >= 0; m--) {
            for (int i = 0; i < n - 1; i++) {
                k = i + 1;
                if (array[i] > array[k]) {
                    swapnumbers(i, k, array);
                }
            }
            printnumbers(array);
        }
    }
  
    private static void swapnumbers(int i, int j, int[] array) {
  
        int temp;
        temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
  
    private static void printnumbers(int[] input) {
          
        for (int i = 0; i < input.length; i++) {
            system.out.print(input[i] + ", ");
        }
        system.out.println("\n");
    }
  
    public static void main(string[] args) {
        int[] input = { 4, 2, 9, 6, 23, 12, 34, 0, 1 };
        bubble_srt(input);
    }
}

2、选择排序
  • 原理图

常用排序算法及Java实现

  • 理解

内部循环查找下一个最小(或最大)值,外部循环将该值放入其适当的位置。

  • java code
public class selectionsort {
 
    public static int[] doselectionsort(int[] arr){
         
        for (int i = 0; i < arr.length - 1; i++)
        {
            int index = i;
            for (int j = i + 1; j < arr.length; j++)
                if (arr[j] < arr[index]) 
                    index = j;
      
            int smallernumber = arr[index];  
            arr[index] = arr[i];
            arr[i] = smallernumber;
        }
        return arr;
    }
     
    public static void main(string a[]){
         
        int[] arr1 = {10,34,2,56,7,67,88,42};
        int[] arr2 = doselectionsort(arr1);
        for(int i:arr2){
            system.out.print(i);
            system.out.print(", ");
        }
    }
}

3、插入排序
  • 原理图

常用排序算法及Java实现

  • 理解

每一步将一个待排序的记录,插入到前面已经排好序的有序序列中去,直到插完所有元素为止。

  • java code
public class insertionsort {
 
    public static void main(string a[]){
        int[] arr1 = {10,34,2,56,7,67,88,42};
        int[] arr2 = doinsertionsort(arr1);
        for(int i:arr2){
            system.out.print(i);
            system.out.print(", ");
        }
    }
     
    public static int[] doinsertionsort(int[] input){
         
        int temp;
        for (int i = 1; i < input.length; i++) {
            for(int j = i ; j > 0 ; j--){
                if(input[j] < input[j-1]){
                    temp = input[j];
                    input[j] = input[j-1];
                    input[j-1] = temp;
                }
            }
        }
        return input;
    }
}

4、快速排序
  • 原理图

常用排序算法及Java实现

  • 理解

将原问题分解为若干个规模更小,但结构与原问题相似的子问题,递归地解这些子问题,然后将这些子问题的解组合为原问题的解。

  • java code
public class quicksort {
     
    private int array[];
    private int length;
 
    public void sort(int[] inputarr) {
         
        if (inputarr == null || inputarr.length == 0) {
            return;
        }
        this.array = inputarr;
        length = inputarr.length;
        quicksort(0, length - 1);
    }
 
    private void quicksort(int lowerindex, int higherindex) {
         
        int i = lowerindex;
        int j = higherindex;
        // calculate pivot number, i am taking pivot as middle index number
        int pivot = array[lowerindex+(higherindex-lowerindex)/2];
        // divide into two arrays
        while (i <= j) {
            /**
             * in each iteration, we will identify a number from left side which 
             * is greater then the pivot value, and also we will identify a number 
             * from right side which is less then the pivot value. once the search 
             * is done, then we exchange both numbers.
             */
            while (array[i] < pivot) {
                i++;
            }
            while (array[j] > pivot) {
                j--;
            }
            if (i <= j) {
                exchangenumbers(i, j);
                //move index to next position on both sides
                i++;
                j--;
            }
        }
        // call quicksort() method recursively
        if (lowerindex < j)
            quicksort(lowerindex, j);
        if (i < higherindex)
            quicksort(i, higherindex);
    }
 
    private void exchangenumbers(int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
     
    public static void main(string a[]){
         
        myquicksort sorter = new myquicksort();
        int[] input = {24,2,45,20,56,75,2,56,99,53,12};
        sorter.sort(input);
        for(int i:input){
            system.out.print(i);
            system.out.print(" ");
        }
    }
}

5、归并排序
  • 原理图

常用排序算法及Java实现

  • 理解

将待排序的数列分成若干个长度为1的子数列,然后将这些数列两两合并;得到若干个长度为2的有序数列,再将这些数列两两合并;得到若干个长度为4的有序数列,再将它们两两合并;直接合并成一个数列为止。

  • java code
public class mergesort {
     
    private int[] array;
    private int[] tempmergarr;
    private int length;
 
    public static void main(string a[]){
         
        int[] inputarr = {45,23,11,89,77,98,4,28,65,43};
        mymergesort mms = new mymergesort();
        mms.sort(inputarr);
        for(int i:inputarr){
            system.out.print(i);
            system.out.print(" ");
        }
    }
     
    public void sort(int inputarr[]) {
        this.array = inputarr;
        this.length = inputarr.length;
        this.tempmergarr = new int[length];
        domergesort(0, length - 1);
    }
 
    private void domergesort(int lowerindex, int higherindex) {
         
        if (lowerindex < higherindex) {
            int middle = lowerindex + (higherindex - lowerindex) / 2;
            // below step sorts the left side of the array
            domergesort(lowerindex, middle);
            // below step sorts the right side of the array
            domergesort(middle + 1, higherindex);
            // now merge both sides
            mergeparts(lowerindex, middle, higherindex);
        }
    }
 
    private void mergeparts(int lowerindex, int middle, int higherindex) {
 
        for (int i = lowerindex; i <= higherindex; i++) {
            tempmergarr[i] = array[i];
        }
        int i = lowerindex;
        int j = middle + 1;
        int k = lowerindex;
        while (i <= middle && j <= higherindex) {
            if (tempmergarr[i] <= tempmergarr[j]) {
                array[k] = tempmergarr[i];
                i++;
            } else {
                array[k] = tempmergarr[j];
                j++;
            }
            k++;
        }
        while (i <= middle) {
            array[k] = tempmergarr[i];
            k++;
            i++;
        }
    }
}

参考链接

java sorting algorithms