LeetCode(三)

1. 

   1. package com.model.array;
      
      /**
       * @Description:测试类
       * @Author: 张紫韩
       * @Crete 2021/8/29 14:45
       * 找到一个数组中出现次数大于N/2的数，如果有返回，么有则返回 -1；
       */
      public class ArrayDemo05 {
          public static void main(String[] args) {
              int[] arr={1,1,1,2,1,2,123,12,1};
              System.out.println(getN(arr));
      
          }
          public static int getN(int[] arr){
      //        一次删除数组中两个不相等的数，剩下最后一种数，在判断如果这种树在数组中出现次数大于N/2则返回这个数
      //        否则就是不存在
      //
      
              int candidate=0;
              int HP=0;
      //        一次删除两个不相等的数
              for (int i = 0; i < arr.length; i++) {
                  if (HP==0){
                      candidate=arr[i];
                      HP=1;
                  } else if (candidate==arr[i]){
                      HP++;
                  }else {
                      HP--;
                  }
              }
      
              if (HP==0) return -1;
              HP=0;
              for (int j : arr) {
                  if (candidate == j) {
                      HP++;
                  }
              }
              return HP>arr.length/2?candidate:-1;
          }
      }

      　
2. 

    

   1. package com.model.array;
      
      import java.util.*;
      
      /**
       * @Description:测试类
       * @Author: 张紫韩
       * @Crete 2021/8/29 15:16
       * 找出数组中出现次数 大于n/k的的数
       */
      public class ArrayDemo06 {
          public static void main(String[] args) {
              int[] arr = {1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 5, 5, 5, 5};
      
              ArrayList<Integer> list = getN(arr, 5);
              for (Integer num : list) {
                  System.out.println(num);
              }
          }
      
          public static ArrayList<Integer> getN(int[] arr, int k) {
      //        存放可能出现的次数大于 n/k 的数，key代表某个值，value代表出现的次数
              HashMap<Integer, Integer> map = new HashMap<>();
              for (int num : arr) {
                  if (map.containsKey(num)) {
                      map.replace(num, map.get(num) + 1);
                  } else {
      //                最多有 k-1 个数出现次数大于 N/k
                      if (map.size() < k - 1) {
                          map.put(num, 1);
                      } else {
      //                    遍历过程中不要对元素进行删除否则会使迭代失效，无法完成遍历过程
                          ArrayList<Integer> removeList = new ArrayList<>();
                          for (Integer key : map.keySet()) {
                              map.replace(key, map.get(key) - 1);
                              if (map.get(key) == 0) removeList.add(key);
                          }
                          for (Integer key : removeList) {
                              map.remove(key);
                          }
                      }
                  }
              }
      //
              ArrayList<Integer> list = new ArrayList<>();
              int count = 0;
              for (Integer key : map.keySet()) {
                  for (int num : arr) {
                      if (num == key) {
                          count++;
                      }
                  }
                  if (count > arr.length / k) {
                      list.add(key);
                  }
              }
              return list;
          }
      }

3. 

    

   1. package com.model.array;
      
      import java.util.Arrays;
      
      /**
       * @Description:测试类
       * @Author: 张紫韩
       * @Crete 2021/8/29 18:12
       * 给定一个数组，左侧有k 个 右侧有 n-k 个，交换这两部分
       */
      public class ArrayDemo07 {
          public static void main(String[] args) {
              int[] arr={1,2,3,4,5,6,7,8,9};
              System.out.println(Arrays.toString(swap(arr, 5)));
      
          }
          public static int[] swap(int[] arr,int k){
      //        1.将前k个元素逆序
      //        2.将后n-k个元素逆序
      //        3.整体逆序
              int left=0;
              int right= arr.length-1;
              int mid=k-1;
              reverse(arr, left, mid);
             reverse(arr, mid+1, right);
             reverse(arr, left, right);
             return arr;
          }
          public static void reverse(int[] arr,int left,int right){
              while (left<right){
                  int temp=arr[left];
                  arr[left]=arr[right];
                  arr[right]=temp;
                  left++;
                  right--;
              }
      
          }
      }

4.  

   

    

    

   1.