Java实现冒泡排序，快速排序

定义

       排序就是重新排列表中的元素，使表中的元素满足按关键字有序的过程

稳定性

       若表中有两个相同的关键字A和B，经排序算法排序后，A和B的相对位置保持不变，则称这个算法是稳定的

插入排序

1. 直接插入排序

public class InsertSort {
    void sort(int[] A,int n){
        int i,j;
        for( i = 1; i <A.length; i++){
            if (A[i-1] > A[i]){
                int temp =A[i];
                for( j = i-1 ; j >= 0 && A[j] > temp; --j){
                    A[j+1] = A[j];
                }
                A[j+1]=temp;
            }
        }
    }
}

交换排序

1. 冒泡排序

• 按照关键字从小到大的排序
• 从后往前两两比较元素的值，若为逆序（A【j-1】>A【j】），则交换它们，直到序列比较完

public class BubbleSort {
    void sort(int[] A,int n){
        for(int i = 0; i < n-1 ; i++){
            boolean flag = false;
            for(int j = n-1; j> i;j--){
                if(A[j-1] > A[j]){
                    int temp = A[j-1];
                    A[j-1] = A[j];
                    A[j] = temp;
                    flag = true;
                }
            }
            if(flag == false){
                return ;
            }
            System.out.println(Arrays.toString(A));
        }
    }
}

2. 快速排序

public class QuickSort {
    public void sort(int a[],int low,int high){
        if(low < high){
            int pos = part(a,low, high);
            sort(a,low,pos-1);
            sort(a,pos+1,high);
        }
    }

    private int part(int[] a, int low, int high) {
        int pivot = a[low];//枢轴的位置
        while(low < high){
            while(low < high && pivot <= a[high]){
                high--;
            }
            a[low] = a[high];
            while(low < high && pivot >= a[low]) {
                low++;
            }
            a[high] = a[low];
        }
        a[low] = pivot;
        return low;
    }

}

选择排序

1. 简单选择排序

public class SelectSort {
    void SelectSort(int[] A,int n ){
        for(int i = 0; i < n-1;i++){
            int min = i;//记录最小元素的位置
            for (int j = i + 1; j < n; j++) {
                if(A[j] < A[min]){
                    min = j;//更新最小元素的位置
                }
            }
            if(min != i){
                int temp = A[i];
                A[i] = A[min];
                A[min] = temp;
                System.out.println(Arrays.toString(A));
            }
        }
    }
}