03.二分、复杂度、动态数组、哈希表和有序表

于 2022-07-14 08:42:53 发布
阅读量500 收藏
点赞数
分类专栏： 算法笔记 文章标签： 算法 java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/M_Love_U/article/details/125776624
版权
本文深入探讨了二分查找在有序数组中的应用，包括寻找特定数值、大于等于或小于等于目标值的最左和最右位置。此外，介绍了时间复杂度的概念及其常见类型。接着，文章讲解了动态数组的扩容机制和时间复杂度分析。还讨论了哈希表和有序表在数据查找中的高效性。最后，简要阐述了Java中按值传递和按引用传递的区别。
摘要由CSDN通过智能技术生成

目录

二分、复杂度、动态数组、哈希表和有序表

一、二分法

  1. 有序数组中找到num
  2. 有序数组中找到>=num最左的位置
  3. 有序数组中找到<=num最右的位置
  4. 局部最小值问题

例1 有序数组中找到num

import java.util.Arrays;

public class BSExist {

   // arr保证有序
   public static boolean find(int[] arr, int num) {
      if (arr == null || arr.length == 0) {
         return false;
      }
      int L = 0;
      int R = arr.length - 1;
      while (L <= R) {
         int mid = (L + R) / 2; // 可能会溢出
         if (arr[mid] == num) {
            return true;
         } else if (arr[mid] < num) {
            L = mid + 1;
         } else {
            R = mid - 1;
         }
      }
      return false;
   }

   // for test
   public static boolean test(int[] sortedArr, int num) {
      for (int cur : sortedArr) {
         if (cur == num) {
            return true;
         }
      }
      return false;
   }

   // for test
   public static int[] generateRandomArray(int maxSize, int maxValue) {
      int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
      for (int i = 0; i < arr.length; i++) {
         arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
      }
      return arr;
   }

   public static void main(String[] args) {
      int testTime = 500000;
      int maxSize = 10;
      int maxValue = 100;
      boolean succeed = true;
      for (int i = 0; i < testTime; i++) {
         int[] arr = generateRandomArray(maxSize, maxValue);
         Arrays.sort(arr);
         int value = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
         if (test(arr, value) != find(arr, value)) {
            System.out.println("出错了！");
            succeed = false;
            break;
         }
      }
      System.out.println(succeed ? "Nice!" : "Fucking fucked!");
   }

}

例2 有序数组中找到>=num最左的位置

import java.util.Arrays;

public class BSNearLeft {

   // arr有序的，>=num 最左
   public static int mostLeftNoLessNumIndex(int[] arr, int num) {
      if (arr == null || arr.length == 0) {
         return -1;
      }
      int L = 0;
      int R = arr.length - 1;
      int ans = -1;
      while (L <= R) {
         int mid = (L + R) / 2; // 可能会溢出
         if (arr[mid] >= num) {
            ans = mid;
            R = mid - 1;
         } else {
            L = mid + 1;
         }
      }
      return ans;
   }

   // for test
   public static int test(int[] arr, int value) {
      for (int i = 0; i < arr.length; i++) {
         if (arr[i] >= value) {
            return i;
         }
      }
      return -1;
   }

   // for test
   public static int[] generateRandomArray(int maxSize, int maxValue) {
      int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
      for (int i = 0; i < arr.length; i++) {
         arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
      }
      return arr;
   }

   // for test
   public static void printArray(int[] arr) {
      if (arr == null) {
         return;
      }
      for (int i = 0; i < arr.length; i++) {
         System.out.print(arr[i] + " ");
      }
      System.out.println();
   }

   public static void main(String[] args) {
      int testTime = 500000;
      int maxSize = 10;
      int maxValue = 100;
      boolean succeed = true;
      for (int i = 0; i < testTime; i++) {
         int[] arr = generateRandomArray(maxSize, maxValue);
         Arrays.sort(arr);
         int value = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
         if (test(arr, value) != mostLeftNoLessNumIndex(arr, value)) {
            printArray(arr);
            System.out.println(value);
            System.out.println(test(arr, value));
            System.out.println(mostLeftNoLessNumIndex(arr, value));
            succeed = false;
            break;
         }
      }
      System.out.println(succeed ? "Nice!" : "Fucking fucked!");
   }

}

例3 有序数组中找到<=num最右的位置

import java.util.Arrays;

public class BSNearRight {

   // 在arr上，找满足<=value的最右位置
   public static int nearestIndex(int[] arr, int value) {
      int L = 0;
      int R = arr.length - 1;
      int index = -1; // 记录最右的对号
      while (L <= R) {
         int mid = L + ((R - L) >> 1);
         if (arr[mid] <= value) {
            index = mid;
            L = mid + 1;
         } else {
            R = mid - 1;
         }
      }
      return index;
   }

   // for test
   public static int test(int[] arr, int value) {
      for (int i = arr.length - 1; i >= 0; i--) {
         if (arr[i] <= value) {
            return i;
         }
      }
      return -1;
   }

   // for test
   public static int[] generateRandomArray(int maxSize, int maxValue) {
      int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
      for (int i = 0; i < arr.length; i++) {
         arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
      }
      return arr;
   }

   // for test
   public static void printArray(int[] arr) {
      if (arr == null) {
         return;
      }
      for (int i = 0; i < arr.length; i++) {
         System.out.print(arr[i] + " ");
      }
      System.out.println();
   }

   public static void main(String[] args) {
      int testTime = 500000;
      int maxSize = 10;
      int maxValue = 100;
      boolean succeed = true;
      for (int i = 0; i < testTime; i++) {
         int[] arr = generateRandomArray(maxSize, maxValue);
         Arrays.sort(arr);
         int value = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
         if (test(arr, value) != nearestIndex(arr, value)) {
            printArray(arr);
            System.out.println(value);
            System.out.println(test(arr, value));
            System.out.println(nearestIndex(arr, value));
            succeed = false;
            break;
         }
      }
      System.out.println(succeed ? "Nice!" : "Fucking fucked!");
   }

}

例4 局部最小值问题

无序数组，返回局部最小索引

  1. arr[0]<arr[1] : 0 为局部最小
  2. arr[N-1]<arr[N-2] : N-1 为局部最小
  3. arr[i-1]>arr[i]<arr[i+1] : i 为局部最小
public class BSAwesome {

   // arr 整体无序
   // arr 相邻的数不相等！
   public static int oneMinIndex(int[] arr) {
      if (arr == null || arr.length == 0) {
         return -1;
      }
      int N = arr.length;
      if (N == 1) {
         return 0;
      }
      if (arr[0] < arr[1]) {
         return 0;
      }
      if (arr[N - 1] < arr[N - 2]) {
         return N - 1;
      }
      int L = 0;
      int R = N - 1;
      // L...R 肯定有局部最小
      while (L < R - 1) {
         int mid = (L + R) / 2;
         if (arr[mid] < arr[mid - 1] && arr[mid] < arr[mid + 1]) {
            return mid;
         } else {
            if (arr[mid] > arr[mid - 1]) {
               R = mid - 1;
            } else {
               L = mid + 1;
            }
         }
      }
      return arr[L] < arr[R] ? L : R;
   }

   // 生成随机数组，且相邻数不相等
   public static int[] randomArray(int maxLen, int maxValue) {
      int len = (int) (Math.random() * maxLen);
      int[] arr = new int[len];
      if (len > 0) {
         arr[0] = (int) (Math.random() * maxValue);
         for (int i = 1; i < len; i++) {
            do {
               arr[i] = (int) (Math.random() * maxValue);
            } while (arr[i] == arr[i - 1]);
         }
      }
      return arr;
   }

   // 也用于测试
   public static boolean check(int[] arr, int minIndex) {
      if (arr.length == 0) {
         return minIndex == -1;
      }
      int left = minIndex - 1;
      int right = minIndex + 1;
      boolean leftBigger = left >= 0 ? arr[left] > arr[minIndex] : true;
      boolean rightBigger = right < arr.length ? arr[right] > arr[minIndex] : true;
      return leftBigger && rightBigger;
   }

   public static void printArray(int[] arr) {
      for (int num : arr) {
         System.out.print(num + " ");
      }
      System.out.println();
   }

   public static void main(String[] args) {
      int maxLen = 100;
      int maxValue = 200;
      int testTime = 1000000;
      System.out.println("测试开始");
      for (int i = 0; i < testTime; i++) {
         int[] arr = randomArray(maxLen, maxValue);
         int ans = oneMinIndex(arr);
         if (!check(arr, ans)) {
            printArray(arr);
            System.out.println(ans);
            break;
         }
      }
      System.out.println("测试结束");

   }

}

二、时间复杂度

1.时间复杂度的定义

时间复杂度（Time complexity）是一个函数，它定性描述该算法的运行频率。这是一个代表算法输入值的字符串的长度的函数. 时间复杂度常用大O表述，不包括这个函数的低阶项和首项系数。

2.常见时间复杂度列表

O ( 1 ) , O ( l o g N ) , O ( N ) , O ( N ∗ l o g N ) , O ( N 2 ) , O ( N 3 ) ， O ( k N ) , O ( n ! ) O(1),O(logN),O(N),O(N*logN),O(N^2),O(N^3)，O(k^N),O(n!) O(1),O(logN),O(N),O(N∗logN),O(N2),O(N3)，O(kN),O(n!)

三、动态数组

1.动态数组是什么？

ArrayList 动态扩容

2.动态数组的使用和扩容

3.动态数组的扩容与时间复杂度分析

数组查找 index 位置的时间复杂度是 O ( n ) O(n) O(n) ,我们思考扩容对时间复杂度的影响。计算知道扩容代价是 O ( n ) O(n) O(n) ，均摊到每一次操作就是 O ( 1 ) O(1) O(1) ，证明 ArrayList 和普通数组的时间复杂度一样都是常数级别的，但是比普通数组略慢一点。

四、哈希表和有序表

1.哈希表的使用

哈希表无论多少数据，增删改查的时间复杂度都是 O ( 1 ) O(1) O(1) ，但是这个 O ( 1 ) O(1) O(1) 的系数有些大。

哈希表的按值查询

2.有序表的使用

有序表无论多少数据，增删改查的时间复杂度都是 O ( l o g N ) O(logN) O(logN) 。

key 要可以比较，不然不能用，要自定义比较器

import java.util.HashMap;
import java.util.TreeMap;

public class TreeMap {

   // (K V)表
   public static void main(String[] args) {

      TreeMap<Integer, String> treeMap1 = new TreeMap<>();

      treeMap1.put(3, "我是3");
      treeMap1.put(0, "我是3");
      treeMap1.put(7, "我是3");
      treeMap1.put(2, "我是3");
      treeMap1.put(5, "我是3");
      treeMap1.put(9, "我是3");

      System.out.println(treeMap1.containsKey(7)); // true
      System.out.println(treeMap1.containsKey(6)); // false
      System.out.println(treeMap1.get(3)); // 我是3

      treeMap1.put(3, "他是3");
      System.out.println(treeMap1.get(3)); // 他是3

      treeMap1.remove(3);
      System.out.println(treeMap1.get(3)); // false

      System.out.println(treeMap1.firstKey()); // 0
      System.out.println(treeMap1.lastKey()); // 9
      // <=5 离5最近的key告诉我
      System.out.println(treeMap1.floorKey(5));
      // <=6 离6最近的key告诉我
      System.out.println(treeMap1.floorKey(6));
      // >=5 离5最近的key告诉我
      System.out.println(treeMap1.ceilingKey(5));
      // >=6 离6最近的key告诉我
      System.out.println(treeMap1.ceilingKey(6));

//    Node node3 = new Node(3);
//    Node node4 = new Node(4);
//    TreeMap<Node, String> treeMap2 = new TreeMap<>();
//    treeMap2.put(node3, "我是node3");
//    treeMap2.put(node4, "我是node4");

   }

}

五、Java中按值传递和按引用传递

1.按值传递

哈希表的按值传递（原生数据结构 Integer Double Float String Character）

内存消耗为真实长度

public class HashMap {
    // (K V)表
    public static void main(String[] args) {
        HashMap<String, String> map = new HashMap<>();
        
		map.put(1234567, "我是1234567");
        Integer a = 1234567;
        Integer b = 1234567;

        System.out.println(a == b); // false
        System.out.println(map.containsKey(a)); // true
        System.out.println(map.containsKey(b)); // true
    }
}

2.按引用传递

按引用传递（非原生数据结构 自定义 Node）

内存消耗为地址内存和

import java.util.HashMap;
import java.util.TreeMap;

public class HashMap {

   public static class Node {
      public int value;

      public Node(int v) {
         value = v;
      }
   }

   // (K V)表
   public static void main(String[] args) {
      Node node1 = new Node(1);
      Node node2 = new Node(1);
      HashMap<Node, String> map3 = new HashMap<>();
      map3.put(node1, "我进来了！");
      System.out.println(map3.containsKey(node1)); // true
      System.out.println(map3.containsKey(node2)); // false
   }

}

六、写在后面

欢迎关注，会经常记录一些算法学习中遇到的问题。

欢迎随时留言讨论，与君共勉，知无不答！

Java咩
关注
专栏目录
chazhao.rar_4 3 2 1_哈希表 查找_有序表查找
09-24
常见的有序表查找算法有二分查找（也称折半查找），它适用于非递减的有序数组。二分查找通过比较目标值与中间元素，将搜索范围不断缩小至找到目标元素或者确定元素不存在。这种算法的时间复杂度为O(log n)，显著优于...
算法基础01-复杂度、排序、二分、异或
weixin_42503072的博客
01-28 630
文章目录1 时间复杂度、空间复杂度、排序、异或运算1.1 时间复杂度1.1.1 排序操作1.1.1.1 选择排序1.1.1.2 冒泡排序1.1.1.3 插入排序1.2 空间复杂度1.3 常数项时间复杂度1.4 算法最优解1.5 常见时间复杂度1.6 算法和数据结构脉络1.7 认识对数器1.8 认识二分法1.9 认识异或运算 1 时间复杂度、空间复杂度、排序、异或运算 1.1 时间复杂度 常数时间操作： 算数运算：+ - * / 位运算：>>（带符号右移动）、 >>>（不带
二分法查找（有序数组）
枯叶的博客
09-24 1068
对有序数组进行二分法查找的速率要远远高于遍历。 下面是Java语言实现的二分查找发: public class BinarySearch { public static void main (String args[]){ int a[] ={1,2,5,8,9,13,25,36,54,61}; //数组必须有序 System.out.print...
常见排序算法及其对应的时间复杂度、空间复杂度
YUBANGSHUANGYUER的博客
03-04 6018
常见排序算法及其对应的时间复杂度、空间复杂度： 排序算法经过长时间演变，大体可以分为两类：内排序和外排序。在排序过程中，全部记录存放在内存，则成为内排序；如果排序过程中需要使用外存，则称为外排序，本文讲的都属于内排序。 内排序有可以分为以下几类： （1）插入排序：直接插入排序、二分法插入排序、希尔排序 （2）选择排序：直接选择排序、堆排序 （3）交换排序：冒泡排序、快速排序 （4）归并排序 （5）基数排序 一、插入排序 •思想：每步将一个待排序的...
二分查找有序数组时间复杂度O(logN)
sunny_daily的博客
07-30 816
package argritech.search; /* * 二分查找有序数组(从小到大)，时间复杂度为O(logN) * 寻找数据value，返回数组下标 */ public class BinarySearch implements SearchInterface{ @Override public int find(int value, int[] array) { // TODO Auto-generated method stub return findDemo(value,.
数组各种排序算法和复杂度分析
weixin_30367169的博客
01-08 635
Java排序算法 1）分类： 插入排序（直接插入排序、希尔排序） 交换排序（冒泡排序、快速排序） 选择排序（直接选择排序、堆排序） 归并排序 分配排序（箱排序、基数排序） 所需辅助空间最多：归并排序 所需辅助空间最少：堆排序 平均速度最快：快速排序 不稳定：快速排序，希尔排序，堆排序。 2）选择排序算法的时候要考虑 数据的规模、 ...
Python版数据结构与算法-查找算法源代码，含顺序搜索、二分查找、哈希表搜索、树(图)数据查找源代码
02-16
二分查找适用于有序的列表或数组。它首先将目标值与中间元素比较，如果目标值等于中间元素，则查找结束；若目标值小于中间元素，那么在左半部分继续查找；反之，在右半部分查找。每一步都将搜索范围减半，因此平均...
binary_hash.rar_二分查找
07-15
二分查找和哈希表是两种在计算机科学中广泛使用的数据结构和算法，它们在查找、插入和删除操作上有着不同的效率和应用场景。下面将详细解释这两种方法。 首先，我们来了解一下二分查找。二分查找，也称为折半查找，...
哈希表及其查找算法.doc
05-06
哈希表，又称散列表，是一种高效的数据结构，它通过特定的哈希函数将数据映射到一个固定大小的数组中，从而实现快速查找。哈希表的核心在于解决数据的存储和查找问题，尤其适用于大数据量的情况。哈希函数的质量直接...
二分查找算法和索引查找算法的实现
最新发布
09-17
二分查找算法和索引查找算法是两种在计算机科学中广泛应用的高效搜索策略，尤其在处理大规模有序数据时。在本篇文章中，我们将深入探讨这两种算法的原理、实现及应用场景。 首先，我们来讨论二分查找算法。二分查找...
选择排序 冒泡排序 二分查找法（有序的数组）
app10011的博客
08-05 195
冒泡排序 每次比较，选取一个最大的，放在右边 public static void bubbleSort(int[] arr){ for (int i = 0; i <arr.length-1; i++) { // 5个数 比较4次就可以 for (int j = 0; j < arr.length-1-...
对于有序数组的，使用二分查找，会了吗？
haishark的博客
03-29 1573
#define _CRT_SECURE_NO_WARNINGS 1 #include int binary_search(int arr[], int key, int left, int right) { int mid = 0; while(left <= right) { mid = left - ((left - right)>>1); if(arr[mid] > key
有序升序数组的二分查找
shuangweiyebai的博客
10-18 1094
有序升序数组的二分查找 //有序升序数组二分查找 #include<stdio.h> #include<windows.h> //控制台显示 int BinSearch(int arr[],int num, int x) { int left = 0; int right = num - 1; while (left<=right) //条件判定 { int mid = (left + right) / 2; //先与中间数字进行对比 if (x
数据结构十大排序算法+二分查找（左程云 左神版 全文2W字+ word很大，你忍一下~~）
qq_55996124的博客
07-25 4223
这是我在b站上2021最新左神数据结构算法全家桶这个视频上学习的排序算法，感觉挺不错的 在这里和大家分享一下 1. 选择排序 1.1 选择排序的思想 参考左神画的图： （1）从头（下标0位置）遍历一遍数组找到最小值，和下标位0位置上的数据交换，此时0位置的数据就固定是最小值了 （2）从下标1位置开始（0位置已经固定就不用考虑了）再次遍历一遍数组，找到最小值，和下标为1位置上的数据交换，此时1位置的数据也就固定了 （3）从下标2位置开始（0、1位置都已经固定）再次遍历一遍数组，找到最小值，和下标
有序数组之二分查找
Richard_Cai
07-10 4358
数据结构与算法是程序深入设计需要理解的知识。关于数据结构和算法就从最简单的部分开始了。来看第一个问题:数组的二分查找。      数组是我们常见的数据结构，在程序设计中应用广泛。关于数组的操作通常是：查找、插入、删除。二分查找是我们常用的一种查找方式，效率比较高。提到二分查找，最原始的方式是线性查找。线性查找就是直接在有序数组的基础上直接从左向右方向进行查找，当在数组中找到一个比一个待查数据大时就退
复杂度与冒泡排序、二分查找
smell201611010513的博客
04-17 960
总结： 时间复杂度：衡量算法快慢的标准刻度 在CPU单位时间运行指令数恒定的情况下，求算法运行指令数和数据规模n的关系 F(n) 不求甚解 大O渐进法： 1)只保留最高次项 2）最高次项的系数化为1 时间复杂度不是绝对意义上的快慢，运行时间的变化趋势。 常见的时间复杂度： O(1) O(log(n)) O(n) O(n*log(n)) O(n^2) 特殊的时间复杂度： 二分查找 递归...
二分查找--数字在排序数组中出现的次数
小R同学
03-07 727
统计一个数字在排序数组中出现的次数。看到有序数组，第一反应就应该是二分查找，复杂度为O(logn),比从头到尾扫描复杂度O（n）效率高。分别用二分查找法第一次和最后一次出现的数字的下标，相减即可、class Solution { public: int GetNumberOfK(vector&lt;int&gt; data ,int k) { int number=0; ...
二分查找的时间复杂度分析
热门推荐
qingmengwuhen1的博客
04-16 1万+
总共有n个元素。第1次折半：还剩n/2个元素第2次折半：还剩n/4个元素第3次折半：还剩n/8个元素……第k次折半：还剩n/2^k个元素最坏的情况下，最后还剩1个元素，令n/2^k = 1。得k=logn。时间复杂度O(logn)...
有序数组和无序数组的增删查改时间复杂度分析
qq_36470686的博客
09-25 4638
有序数组： 添加数据： 查找插入位置用二分查找是O(log2n)。但是数组的插入操作为了保证有序性需要将插入位置后的元素全部后移一位，这需要O(n)。所以总的时间复杂度是O(n)。（ O(log2n)+O(n)=O(n) ） 删除数据：  使用二分查找找到删除位置，再把删除位置后的所有元素前移一位。 总时间复杂度:O(logn)+O(n)=O(n) 查找数据： 二分法查找数据...
二分搜索(对有序数组有效)
qq_40783277的博客
11-15 523
二分搜索(对有序数组有效) 以下内容来自wiki 定义： 二分搜索（英语：binary search），也称折半搜索（英语：half-interval search）[1]、对数搜索（英语：logarithmic search）[2]，是一种在有序数组中查找某一特定元素的搜索算法。搜索过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜索过程结束；如果某一特定元素大于或者小于中间元素，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值