排序算法解析以及面试遇到的算法

• 主要是记录一些常用算法的时间复杂度和一些常用算法

  • 冒泡排序

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

  • 选择排序

        public int[] select(int[] ints) {
            for (int i = 0; i < ints.length; i++) {
                int min = ints[i];
                int num = i;
                for (int j = i + 1; j < ints.length; j++) {
                    if (min > ints[j]) {
                        min = ints[j];
                        num = j;
                    }
                }
                ints[num] = ints[i];
                ints[i] = min;
            }
            return ints;
        }
    

  • 插入排序

        public int[] insert(int[] ints) {
            for (int i = 1; i < ints.length; i++) {
                for (int j = i; j > 0; j--) {
                    if (ints[j] < ints[j-1]){
                        int num = ints[j];
                        ints[j] = ints[j-1];
                        ints[j-1] = num;
                    }else {
                        break;
                    }
                }
            }
            return ints;
        }
    

  • 快速排序

    	public static void fastSort(int[] array, int left, int right) {
    	        if (left > right) {
    	            return;
    	        }
    	        // base中存放基准数
    	        int base = array[left];
    	        int l = left, r = right;
    	        while (l != r) {
    	            // 顺序很重要，先从右边开始往左找，直到找到比base值小的数
    	            while (array[r] >= base && l < r) {
    	                r--;
    	            }
    	            // 再从左往右边找，直到找到比base值大的数
    	            while (array[l] <= base && l < r) {
    	                l++;
    	            }
    	            // 上面的循环结束表示找到了位置或者(l>=r)了，交换两个数在数组中的位置
    	            if (l < r) {
    	                int tmp = array[l];
    	                array[l] = array[r];
    	                array[r] = tmp;
    	            }
    	        }
    	        // 将基准数放到中间的位置（基准数归位）
    	        array[left] = array[l];
    	        array[l] = base;
    	        // 递归，继续向基准的左右两边执行和上面同样的操作
    	        // l的索引处为上面已确定好的基准值的位置，无需再处理
    	        // 因为 l处的已经比较完毕了
    	        // 在l处 左边的比l小 右边的比l大
    	        fastSort(array, left, l - 1);
    	        fastSort(array, l + 1, right);
    	    }
    

  • 归并排序

    		public void mergeSort(int[] ints) {
    	        int[] tmp = new int[ints.length];
    	        merge(ints, 0, ints.length - 1, tmp);
    	    }
    	    private void merge(int[] ints, int low, int high, int[] tmp) {
    	        if (high - low < 1) {
    	            return;
    	        }
    	        int mid = (low + high) / 2;
    	        merge(ints, low, mid, tmp);
    	        merge(ints, mid + 1, high, tmp);
    	        for (int i = low; i <= mid; i++) {
    	            tmp[i] = ints[i];
    	        }
    	        for (int i = mid + 1; i <= high; i++) {
    	            tmp[i] = ints[i];
    	        }
    	        int left = low, right = mid + 1, result = low;
    	        while (left <= mid && right <= high) {
    	            if (tmp[left] < tmp[right]) {
    	                ints[result] = tmp[left];
    	                left++;
    	            } else {
    	                ints[result] = tmp[right];
    	                right++;
    	            }
    	            result++;
    	        }
    	        while (left <= mid) {
    	            ints[result++] = tmp[left++];
    	        }
    	        while (right <= high) {
    	            ints[result++] = tmp[right++];
    	        }
    	    }
    

• 参考链接

  • Java实现八大排序算法
  • 十大经典排序算法总结（Java实现+动画）

• 链表反转

  	class ListNode {
  	    int val;
  	    ListNode next;
  	
  	    ListNode() {
  	    }
  	
  	    ListNode(int val) {
  	        this.val = val;
  	    }
  	
  	    ListNode(int val, ListNode next) {
  	        this.val = val;
  	        this.next = next;
  	    }
  	}
  	
      public ListNode reverseList(ListNode head) {
          if (head == null) {
              return head;
          }
          ListNode pre = null, cur = head;
          while (cur != null) {
              ListNode next = cur.next;
              cur.next = pre;
              pre = cur;
              cur = next;
          }
          return pre;
  	}
  

• 如何在数组中快速找到重复次数为n的元素，例如【1，2，2，3，3，4，4，4，4，5，5，5，5，5，5】；如何找到重复次数大于等于4的元素；

      public void arrayHelper(int[] ints) {
          HashMap<Integer, Integer> hashMap = new HashMap<>(16);
          for (int anInt : ints) {
              if (hashMap.containsKey(anInt)) {
                  Integer integer = hashMap.get(anInt);
                  hashMap.put(anInt, integer + 1);
              } else {
                  hashMap.put(anInt, 1);
              }
          }
          // 下面是两种map根据value排序的方法 遍历相应map即可
          List<Map.Entry<Integer, Integer>> list = new ArrayList<>(hashMap.entrySet());
          Map<Integer, Integer> collect = list.stream().filter(entry -> entry.getValue() >= 4)
                  .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
          LinkedHashMap<Integer, Integer> collect1 = hashMap.entrySet().stream().sorted(Map.Entry.comparingByValue(Comparator.reverseOrder()))
                  .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getKey, (c1, c2) -> c1, LinkedHashMap::new));
      }
  

• 将字母相同顺序不同的字符串放到集合当中
  测试数据：“eat”, “tea”, “tan”, “ate”, “nat”, “bat”
  输出：[[eat, tea, ate], [bat], [tan, nat]]

      public List<List<String>> groupAnagrams(String[] strs) {
          Map<String, List<String>> map = new HashMap<>(16);
          for (String str : strs) {
              char[] chars = str.toCharArray();
              Arrays.sort(chars);
              String string = Arrays.toString(chars);
              if (map.containsKey(string)) {
                  map.get(string).add(str);
              } else {
                  map.put(string, new ArrayList<>());
                  map.get(string).add(str);
              }
          }
          return new ArrayList<>(map.values());
      }
  

• 合并多个区间【2，3】【4，9】【7，8】 最后区间为【2，9】

      public int[][] merge(int[][] intervals) {
          if (intervals.length == 0) {
              return intervals;
          }
          Arrays.sort(intervals, Comparator.comparingInt(a -> a[0]));
          List<int[]> list = new ArrayList<>();
          int[] ints = intervals[0];
          for (int i = 1; i < intervals.length; i++) {
              if (ints[1] < intervals[i][0]) {
                  list.add(ints);
                  ints = intervals[i];
              } else {
                  ints[1] = Math.max(ints[1], intervals[i][1]);
              }
          }
          list.add(ints);
          int[][] ints1 = new int[list.size()][2];
          for (int i = 0; i < list.size(); i++) {
              ints1[i] = list.get(i);
          }
          return ints1;
      }