堆排-元素去重-查找问题

堆排序与元素去重及查找问题

1、堆排序与元素去重

package com.m.sort;


import java.util.Arrays;
import java.util.Random;

public class Test2 {
    public static void main(String[] args) {
        Random random = new Random();
        int[] arr = new int[12];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = random.nextInt(10) + 10;
        }
        System.out.println("原数组:
" + Arrays.toString(arr));

        sort(arr);

        System.out.println("堆排序后的数组:
" + Arrays.toString(arr));

        int n = repeatElementInArray(arr);
        int[] newArr = new int[n];
        System.arraycopy(arr, 0, newArr, 0, n);
        /*
        public static void arraycopy(Object src,
                             int srcPos,
                             Object dest,
                             int destPos,
                             int length)
                             参数
                            src - 源数组。
                            srcPos - 源数组中的起始位置。
                            dest - 目标数组。
                            destPos - 目的地数据中的起始位置。
                            length - 要复制的数组元素的数量。
                            
               public class ArrayStoreException 
               extends RuntimeException
               抛出以表示尝试将错误类型的对象存储到对象数组中。 
               例如，以下代码生成一个ArrayStoreException ： 
               Object x[] = new String[3];
               x[0] = new Integer(0);
         */
        System.out.println("去重后的数组:
" + Arrays.toString(newArr));
    }

    /**
     * 数组去重
     *
     * @param arr
     * @return
     */
    public static int repeatElementInArray(int[] arr) {
        int n = arr.length;
        int index = 0;
        if (n < 0) {
            return index;
        }
        index = 1;
        for (int i = 1; i < n; i++) {
            if (arr[i] != arr[i - 1]) {
                arr[index] = arr[i];
                index++;
            }
        }
        return index;
    }

    /**
     * 堆排序
     *
     * @param arr
     */
    public static void sort(int[] arr) {
        for (int i = arr.length / 2 - 1; i >= 0; i--) {
            adjust(arr, i, arr.length);
        }
        for (int i = arr.length - 1; i > 0; i--) {
            swap(arr, 0, i);
            adjust(arr, 0, i);
        }
    }

    /**
     * 堆排序调整
     *
     * @param arr
     * @param i
     * @param length
     */
    public static void adjust(int[] arr, int i, int length) {
        int temp = arr[i];
        boolean flag = true;
        for (int j = i * 2 + 1; flag && j < length; j = j * 2 + 1) {
            if (j + 1 < length && arr[j] < arr[j + 1]) {
                j++;
            }
            if (arr[j] > temp) {
                arr[i] = arr[j];
                i = j;
            } else {
                flag = false;
            }
        }
        arr[i] = temp;
    }

    /**
     * 交换数组的a与b的值
     *
     * @param arr
     * @param a
     * @param b
     */
    public static void swap(int[] arr, int a, int b) {
        int t = arr[a];
        arr[a] = arr[b];
        arr[b] = t;
    }
}

ICU（综合性重症监护病房）CCU（冠心病重症监护室）两者的区别在于：一个是各类重症都可进入，一个是只冠心病重症。

ICU是英文Intensive Care Unit的缩写，意为重症加强护理病房。重症医学监护是随着医疗护理专业的发展、新型医疗设备的诞生和医院管理体制的改进而出现的一种集现代化医疗护理技术为一体的医疗组织管理形式。中小医院是一个病房，大医院是一个特别科室，把危重病人集中起来，在人力、物力和技术上给予最佳保障，以期得到良好的救治效果。

2、查找问题

package com.m.sort;


import java.util.Scanner;

//查找问题
public class Test2 {
    //    顺序查找法
    //    ⼆分查找法，前提是所查找的数组必须是有序的
    public static void main(String[] args) {
        test1();
    }

    //  顺序查找法
    public static void test() {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入一个数:");
        int n = scanner.nextInt();
        System.out.println((isExist(n) ? "存在" : "不存在"));
    }

    public static boolean isExist(int num) {
        boolean flag = false;
        int[] arr = {5, 4, 3, 2, 8};
        for (int i = 0; i < arr.length; i++) {
            if (num == arr[i]) {
                flag = true;
                break;
            }
        }
        return flag;
    }

    //  ⼆分查找法
    public static void test1() {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入一个数:");
        int n = scanner.nextInt();
        System.out.println((isExistByHalf(n) ? "存在" : "不存在"));
    }

    public static boolean isExistByHalf(int num) {
        boolean flag = false;
        int[] arr = {12, 5, 4, 3, 2, 1, -5};
        int low = 0;
        int high = arr.length - 1;
        while (low <= high) {
            int mid = (low + high) >>> 1;
            if (num < arr[mid]) {
                low = mid + 1;
            } else if (num > arr[mid]) {
                high = mid - 1;
            } else {
                flag = true;
                break;
            }
        }
        return flag;
    }
}