8大基本算法

import java.util.*;

/**
 * @ClassName:
 * @Description:
 * @Author:
 * @Date: 2023/9/27 11:26
 */
public class Code {

    public static void main(String[] args) {

        int[] n = {60, 38, 5, 14, 7, 23, 89, 77, 88, 4, 35, 45, 67, 99, 87};

//        Arrays.sort(n);
//        Collections.reverse(Arrays.asList(n));
//        System.out.println(Arrays.toString(Heapsort(n)));
//        Comparator<Integer> tComparator = Comparator.reverseOrder();
//        Integer[] integers = Arrays.stream(n).boxed().sorted(tComparator).toArray(Integer[]::new);

//        System.out.println(Arrays.toString(countingSort(n)));
//        System.out.println(Arrays.toString(mergeSort(n, 0, n.length - 1)));
    }

    //1冒泡排序（交换排序）
    public static int[] babou(int[] num) {

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

    //2快速排序（交换排序）
    public static int[] kuaisu(int[] num, int low, int high) {
        if (low >= high) {
            return num;
        }
        int left = low;
        int right = high;

        int pivot = num[left];
        while (left < right) {
            while (left < right && num[right] > pivot)
                right--;
            num[left] = num[right];
            while (left < right && num[left] < pivot)
                left++;
            num[right] = num[left];
        }
        num[left] = pivot;
        kuaisu(num, low, left - 1);
        kuaisu(num, left + 1, high);


        return num;

    }

    //3直接插入排序（插入排序）
    public static int[] insertSort(int[] arr) {
        // 遍历所有数字
        for (int i = 1; i < arr.length - 1; i++) {
            // 当前数字比前一个数字小
            if (arr[i] < arr[i - 1]) {
                int j;
                // 把当前遍历的数字保存起来
                int temp = arr[i];
                for (j = i - 1; j >= 0 && arr[j] > temp; j--) {
                    // 前一个数字赋给后一个数字
                    arr[j + 1] = arr[j];
                }
                // 把临时变量赋给不满足条件的后一个元素
                arr[j + 1] = temp;
            }
        }
        return arr;
    }

    //4希尔排序（插入排序）
    public static int[] ShellSort(int[] arr) {
        //增量gap，并逐步缩小增量
        for (int gap = arr.length / 2; gap > 0; gap /= 2) {
            //从第gap个元素，逐个对其所在组进行直接插入排序操作
            for (int i = gap; i < arr.length; i++) {
                int j = i;
                while (j - gap >= 0 && arr[j] < arr[j - gap]) {
                    //插入排序采用交换法
                    swap(arr, j, j - gap);
                    j -= gap;
                }
            }
        }
        return arr;
    }
    public static void swap(int[] arr, int a, int b) {
        arr[a] = arr[a] + arr[b];
        arr[b] = arr[a] - arr[b];
        arr[a] = arr[a] - arr[b];
    }

    //5简单选择排序（选择排序）
    public static int[] xuanzepaixu(int[] num) {
        for (int i = 0; i < num.length; i++) {
            int min = i;
            //每次找到最小的
            for (int j = min + 1; j < num.length; j++) {
                if (num[min] > num[j]) {
                    min = j;
                }
            }
            //换一下顺序
            if (min != i) {
                int temp = num[min];
                num[min] = num[i];
                num[i] = temp;
            }
        }
        return num;
    }

    //6堆排序（选择排序）
    public static int[] Heapsort(int[] a) {
        for (int i = a.length - 1; i > 0; i--) {
            maxHeap(a, i);
            int temp = a[0];
            a[0] = a[i];
            a[i] = temp;
        }
        return a;
    }
    private static void maxHeap(int[] a, int n) {
        int child;
        for (int i = (n - 1) / 2; i >= 0; i--) {
            child = 2 * i + 1;
            if (child != n && a[child] < a[child + 1]) {
                child++;
            }
            if (a[i] < a[child]) {
                int temp = a[i];
                a[i] = a[child];
                a[child] = temp;
            }
        }

    }

    //7归并排序
    public static int[] mergeSort(int[] nums, int left, int right) {
        if (left < right) {
            int mid = left + (right - left) / 2;
            mergeSort(nums, left, mid);
            mergeSort(nums, mid + 1, right);
            merge(nums, left, mid, right);
        }

        return nums;
    }
    public static void merge(int[] nums, int left, int mid, int right) {
        int[] temp = new int[right - left + 1];
        int i = left;
        int j = mid + 1;
        int k = 0;

        while (i <= mid && j <= right) {
            if (nums[i] <= nums[j]) {
                temp[k++] = nums[i++];
            } else {
                temp[k++] = nums[j++];
            }
        }

        while (i <= mid) {
            temp[k++] = nums[i++];
        }

        while (j <= right) {
            temp[k++] = nums[j++];
        }

        System.arraycopy(temp, 0, nums, left, temp.length);
    }
    //8计数排序
    public static int[] countingSort(int[] arr) {
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }

        int[] count = new int[max + 1];
        for (int num : arr) {
            count[num]++;
        }

        for (int i = 1; i < count.length; i++) {
            count[i] += count[i - 1];
        }

        int[] sortedArr = new int[arr.length];
        for (int i = arr.length - 1; i >= 0; i--) {
            int num = arr[i];
            int index = count[num] - 1;
            sortedArr[index] = num;
            count[num]--;
        }

        return sortedArr;
    }


    //插入排序：直接插入、希尔排序
    //选择排序：简单选择、堆排序
    //交换排序：冒泡排序、快速排序
    //归并排序
    //计数排序


    public static int doma(int n) {
        if (n == 1 || n == 2) {
            return n;
        } else {
            return doma(n - 1) + doma(n - 2);
        }

    }
    public int binarySearch(int[] nums, int target) {
        int left = 0;
        int right = nums.length - 1;

        while (left <= right) {
            int mid = left + (right - left) / 2;

            if (nums[mid] == target) {
                return mid;
            } else if (nums[mid] > target) {
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        }

        return -1;
    }

}