典型排序算法java代码

package com.company;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
	int[] arr = {3,5,8,2,6,7,1};
	BubbleSorted(arr);
//    QuickSorted(arr,0,6);
//        InsertionSorted(arr);
//        SelectionSorted(arr, 0, 6);
    }
    public static void BubbleSorted(int[] arr){
//        基本思路：外层循环控制着起泡的趟数n-1，从数组的末尾开始比较，如果是逆序则交换，一趟起泡后，将最小值存到数组的最开始，
// 每次起泡后确定数组的最小值
        int i,j;
        int len = arr.length;
        boolean res = true;
        for(i = 0;i<len-1;i++){
            for(j = len-1;j>=i+1;j--){
                if(arr[j]<arr[j-1]) {
                    int temp = arr[j];
                    arr[j] = arr[j-1];
                    arr[j-1] = temp;
                    res = false;
                }
            }
        }
        for(int k:arr){
            System.out.print(k);
        }
    }
    public static void QuickSorted(int[] arr,int left,int right){
        int i;
        if(left<right){
            int pivotpos = Partition(arr,left,right);
            QuickSorted(arr,left,pivotpos-1);
            QuickSorted(arr,pivotpos+1,right);
        }

    }

    private static int Partition(int[] arr, int low, int high) {
//        两边相向检查，发现逆序交换
        int pivot = arr[low];
        int i = low+1;
        int j = high;
        while(i<j){
            while (i<j&&pivot<arr[j])j--;
            while(i<j&&pivot>arr[i])i++;
            if(i<j){
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
                i++;
                j--;
            }
        }
        arr[low] = arr[i];
        arr[i] = pivot;
        return i;
    }
    public static void InsertionSorted(int[] arr){
//        基本思路：将数组分为有序数组和无序数组两个部分，一开始时有序数组中只含有arr[0]，然后对无序数组中的元素插入到有序数组中，条件是无序数组中的元素
//        小于有序数组中的最后一个元素,然后遍历有序数组中的元素,找到要插入的位置
        int i,j;
        for(i = 1;i<arr.length;i++){
            if(arr[i]<arr[i-1]){
                int temp = arr[i];
                for(j = i-1;j>=0&&arr[j]>temp;j--){
                    arr[j+1] = arr[j];
                }
                arr[j+1] = temp;
            }
        }
        for(i = 0;i<arr.length;i++) {
            System.out.println(arr[i]);
        }
    }
    public static void SelectionSorted(int[] arr,int left,int high){
//        每次在数组中找到最小的元素存到有序数组中，逐步扩大有序表
        int temp;
        int i,j;
        int k;
        for(i = left;i<high;i++) {
            k = i;
            for (j = i + 1; j <= high; j++)
                if (arr[j] < arr[k])
                    k = j;
            if (k != i) {
                temp = arr[k];
                arr[k] = arr[i];
                arr[i] = temp;
            }
        }
        for(i = 0;i<arr.length;i++) {
            System.out.println(arr[i]);
        }
    }
    public static void Merge(int[] arr1,int[] arr2,int left,int mid,int right){
//        二路归并，将两个有序表合并为一个有序表
        int i = left;
        int j = mid+1;
        int k = left;
        while (i<=mid&&j<=right){
            if(arr1[i]<arr1[j])
                arr2[k++] = arr1[i++];
            else
                arr2[k++] = arr1[j++];
        }
        while(i<=mid){
            arr2[k++] = arr1[i++];
        }
        while (j<=right){
            arr2[k++] = arr1[j++];
        }
    }
}

根据殷人昆版的数据结构编写的代码