四种排序算法+二分法查找算法

1 四种排序算法

①快速排序

/**
 * 快速排序（二分法排序）
 */
class QuickSort{
    /*
     * 交换并返回分界点
     */
    private int boundary(int[] array, int startIndex, int endIndex) {
        int standard = array[startIndex]; // 定义标准
        int leftIndex = startIndex; // 左指针
        int rightIndex = endIndex; // 右指针

        while(leftIndex < rightIndex) {
            while(leftIndex < rightIndex && array[rightIndex] >= standard) {
                rightIndex--;
            }
            array[leftIndex] = array[rightIndex];

            while(leftIndex < rightIndex && array[leftIndex] <= standard) {
                leftIndex++;
            }
            array[rightIndex] = array[leftIndex];
        }

        array[leftIndex] = standard;
        return leftIndex;
    }
    public void sort(int left, int right, int[] array) {
        if(left>=right) {
            return;
        }
        int boundary = boundary(array, left, right);

        sort(left, boundary-1, array);
        sort(boundary+1, right, array);
    }
}

②插入排序

class InsertSort {
    public void sort(int a[]) {
        for(int i=0;i<a.length;i++) {
            int insertVal = a[i];
            int index = i-1;
            while(index>=0 && insertVal<a[index]) {
                a[index+1] = a[index];
                index--;
            }
        }
    }   
}

③ 选择排序

• 找到最小的，和第一个位置交换
• 找到次小的，和第二个位置交换
• 以此类推，排序完成

class Select {
    public void sort(int a[]) {

        int temp=0;
        for(int i=0; i<a.length-1; i++) {
            int min = a[i];
            int minIndex = i;
            for(int j=i+1; j<a.length; j++) {
                if(min>a[j]) {
                    min = a[j];
                    minIndex=j;
                }
            }
            temp = a[i];
            a[i] = a[minIndex];
            a[minIndex]=temp;
        }

    }
}

④ 冒泡排序

class Bubble {
    public void sort(int a[]) {
        int temp = 0;
        for(int i =0; i<a.length-1; i++) {
            for (int j=0; j<a.length-i-1; j++) {
                if(a[j] > a[j+1] ) {
                    temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = temp;
                }
            }
        }
    }
}

2 二分查找算法

/**
 * 二分查找
 */
class BinaryFind{
    public void find(int leftIndex, int rightIndex, int val, int arr[]) {
        int midIndex  = (rightIndex + leftIndex) / 2;
        int midVal = arr[midIndex];

        if(rightIndex>=leftIndex) {
            if(midVal>val) {
                find(leftIndex, midIndex-1, val, arr);
            } else if(midVal < val) {
                find(midIndex+1, rightIndex, val, arr);
            } else if(midVal==val) {
                System.out.println("找到下标:" + midIndex);
            }
        }
    }
}