数据结构常见 算法

package com.gang.test;

/**
 * @author GG
 * @description 各种排序算法·
 * @date 2022/11/13 19:12
 */
public class Search {
    public static void main(String[] args) {

/*        int[] arr = {5,6,7,8,9,9,11,12,22};
        int target = 9;
        int num = searchBin(arr,target,0,arr.length);
        System.out.println("查找出来的元素位置"+num);*/

        int[] arr = {20,30,10,6,5,9,44,12,6,100};
//        int[] ints = insertSort(arr);

//        int[] ints = shellSort(arr,9);

//        int[] ints = bubbleSort(arr);

//          System.out.println(partition(arr, 0, 9));
//        int[] ints = quickSort(arr, 0, 9);
        int[] ints = selectMinSort(arr);
        for (int i = 0; i < ints.length; i++) {
            System.out.println(arr[i]);
        }
    }
    //此种写法需要提前分配一个中间数组用于存复制的arr数组中的值
    public static int[] b = new int[10];
    /**
     * 二路归并排序主要采用分而治之的策略
     *
     * @param arr 待排序数组
     * @param low 低位指针
     * @param high 高位指针
     * @return 返回排好序的数组
     */
    public static int[] mergeSort(int[] arr,int low,int high){
        int mid;
        if(low < high){
            mid = (low+high)/2;
            mergeSort(arr,low,mid);
            mergeSort(arr,mid+1,high);
            merge(arr,low,mid,high);
        }
        return arr;
    }

    /**
     * 实施排序操作
     * @param arr
     * @param low
     * @param mid
     * @param high
     */
    public static void merge(int[] arr ,int low, int mid, int high) {
        int i,j,k;
        //将待排序数组中的值复制到中间数组b中
        for(k = 0; k < arr.length; k++){
            b[k] = arr[k];
        }
        //设定条件，根据指针指向的位置依次进行移动元素，直至跳出循环
        for (i = low, j = mid+1,k = i;i <= mid && j <= high; k++ ) {
            if(b[i] < b[j]){
                arr[k] = b[i++];
            }else{
                arr[k] = b[j++];
            }
        }
        while(i<= mid) {
            arr[k++] = b[i++];
        }
        while(j<= high) {
            arr[k++] = b[j++];
        }

    }


    /**
     *
     * @param arr
     * @return
     */
    public static int[] buildMaxHeap(int[] arr){
        return arr;
    }




    /**
     * 简单选择排序
     * @param arr 带排序数组
     * @return 排好序的数组
     * 升序排序
     */
    public static int[] selectMinSort(int[] arr){
        int min ,i,j,temp;
        for(i = 0;i < arr.length;i++){
            min = i;
            for(j = i+1;j < arr.length; j++){
                if(arr[j] < arr[min]){
                    min = j;
                }
            }
            if(min !=  i){
                temp = arr[min];
                arr[min] = arr[i];
                arr[i] = temp;
            }
        }
        return arr;
    }
    /**
     * 快速排序：快排中返回枢轴所在位置，一趟排序之后的元素
     * @param arr 待排序数组
     * @return 返回枢轴所在位置
     */
    public static int partition(int[] arr,int low,int high){

        int key = arr[low];
        while(low < high){
            while( low < high && arr[high] > key){
                high--;
            }
            arr[low] = arr[high];
            while(low < high && arr[low] < key){
                low++;
            }
            arr[high] = arr[low];
        }
        arr[low] = key;
        return low;
    }

    /**
     * 快速排序的递归实现
     * @param arr
     * @param low
     * @param high
     * @return
     */
    public static int[] quickSort(int[] arr,int low,int high){
        if(low < high){
            int pivotloc = partition(arr, low, high);
            quickSort(arr,pivotloc+1,high);
            quickSort(arr,low,pivotloc-1);

        }
        return arr;
    }
    /**
     * 冒泡排序
     * @param arr 待排序数组
     * @return 升序排序数组
     */
    public static int[] bubbleSort(int[] arr){
        int i,j,temp;
        for ( i = 0; i < arr.length; i++) {
            for( j = i;j<arr.length-1;j++){
                if(arr[j]>arr[j+1]){
                    temp = arr[j+1];
                    arr[j+1] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        return arr;
    }




    /**
     * 希尔排序
     * arr[0]不存元素，作为暂存元素位置
     * @param arr 待排序数组
     * @param n 数组中元素个数，用于计算增量的变化
     * @return 升序排列好的数组
     */
    public static int[] shellSort(int[] arr, int n){
        int d,i,j;
        //8  4  2  1
        for(d = n/2; d>0;d = d/2){
            for(i = d+1; i <= n; i++){
                if(arr[i-d] > arr[i]){
                    arr[0] = arr[i];
                    for(j = i-d; j > 0 && arr[j] > arr[0];j -=d){
                        arr[j+d] = arr[j];
                    }
                    arr[j+d] = arr[0];
                }

            }
        }
        return arr;
    }



    /**
     * 直接插入排序,未带入哨兵模式
     * @param arr 待排序数组
     * @return 升序排列好的数组
     */
    public static int[] insertSort(int[] arr){
        int j,i,temp;
        for( i = 1;i < arr.length; i++){
            if(arr[i]>=arr[i-1]){
                continue;
            }
            // arr[i] < arr[i-1]
            temp = arr[i];
            for(j = i-1;j>=0 && arr[j] > temp;j--){
                if(temp < arr[j]){
                    arr[j+1] = arr[j];
                }
            }
            arr[j+1] = temp;
        }
        return arr;
    }
    /**
     * //二分查找算法
     * @param arr 目标数组
     * @param target 查找目标
     * @param left  左指针
     * @param right 右指针
     * @return 查找位置，返回-1则查找失败
     */
    public  static int searchBin(int[] arr,int target,int left,int right){
        if(left>right){
            return -1;
        }else{
            int mid = (right+left)/2;
            if(arr[mid]==target){
                System.out.println("找到mid");
                return mid;
            }
            if(arr[mid] < target){
                return  searchBin(arr,target,mid+1,right);
            }
            if(arr[mid] > target){
                return  searchBin(arr,target,left,mid);
            }
        }
        return -1;
    }
}