堆排序，二分查找，快速排序

创建一个堆

    public static void main(String[] args) {
        int[] arr = new int[]{7,2,6,4,5};
        createHeap(arr, arr.length - 1);
    }

    /**
     * 构建堆
     * @param arr
     * @param lastIndex：最后一个叶子节点的下标
     */
    public static void createHeap (int[] arr, int lastIndex) {
        for (int i = (arr.length / 2) - 1; i >= 0; i--) {
            // 非叶子节点下标
            int top = i;
            while ((top * 2 + 1) <= lastIndex) { // 成立则说明top有 叶子节点

                int left = top * 2 + 1;

                // 节点左右比
                if (left < lastIndex) { // 小于才说明有右节点
                    int right = left + 1;
                    if (arr[left] < arr[right]) {
                        left++;
                    }
                }

                // 节点上下比
                if (arr[left] > arr[top]) {
                    // 交换非叶子节点元素的位置
                    swap(arr, left, top);
                    // 将元素下标赋值，便于之后的非叶子节点调整树结构
                    top = left;
                } else {
                    break;
                }

            }
        }
    }

    /**
     * 交换元素位置
     * @param arr
     * @param i
     * @param j
     */
    public static void swap (int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

二分查找算法

public class Test {
  public static void main(String[] args) {
      // 准备好一个有序的被查找数组
      int[] arr = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
      // 调用查找方法查找给定数组中5元素所在的索引值，并接收查找到的索引
      int index = getIndex(arr, 5);
      // 输出索引
      System.out.println("index:" + index);
  }

  public static int getIndex(int[] arr, int num) {
      // 定义变量，表示查找数组范围的最左侧，先从0索引开始
      int left = 0; 
      // 定义变量，表示查找数组范围的最右侧，先从最大索引开始
      int right = arr.length - 1;
      // 定义变量，表示查找范围的中间值
      int mid;
      while (left <= right) {
          // 中间索引 = (左侧  + 右侧) / 2
          // mid = (left + right) / 2; 
          // 为了提高效率，我们可以用位运算代替除以运算
          mid = (left + right) >>> 1 
          if (arr[mid] > num) {
              //如果中间元素大于要查找元素，则在中间元素的左侧去找正确元素，最右侧变为mid - 1
              right = mid - 1;
          } else if (arr[mid] < num) {
              //如果中间元素小于要查找元素，则在中间元素的右侧去找正确元素，最左侧变为mid + 1
              left = mid + 1;
          } else {
              // 如果不大不小，那么就正好是找到了，返回找到的索引
              return mid;
          }
      }
      // 当查找范围的最左侧和最右侧重叠后还没有找到元素，则返回-1表示没有找到
      return -1;
  }
}

快速排序

public class QuickSort {
    public static void main(String[] args) {
        int[] arr = {10, 3, 4, 4, 1, 2, 9, 5, 1, 1};
        split(arr, 0, arr.length-1);
        for (int i = 0; i < arr.length; i++) {
            System.out.printf(arr[i] + " ");
        }
    }

    public static void split(int[] arr, int start, int end) {
        if (start > end) {
            return;
        } else {
            int middle = sort(arr, start, end);
            split(arr, start, middle-1);
            split(arr, middle+1, end);
        }

    }

    public static int sort(int[] arr, int start, int end) {
        int base = arr[end];
        while (start < end) {
            while (start < end && arr[start] <= base) {
                start++;
            }
            if (start < end) {
                // start和end交换位置
                int temp = arr[start];
                arr[start] = arr[end];
                arr[end] = temp;
            }
            while (start < end && arr[end] >= base) {
                end --;
            }
            if (start < end) {
                // end和start交换位置
                int temp = arr[end];
                arr[end] = arr[start];
                arr[start] = temp;
            }
        }
        return start;
    }
}