跟着排序学时间复杂度

news2024/11/17 13:53:45

带着排序学时间/空间复杂度

排序和时间复杂度

  • 带着排序学时间/空间复杂度
      • 冒泡排序
      • 选择排序
          • 选择排序法2原理：
      • 插入排序
      • 希尔排序（缩小增量排序）
      • 堆排序
      • 快速排序
      • 归并排序
      • 不基于比较的排序
        • 计数排序
      • 桶排序
      • 稳定性

时间复杂度是打开数据结构大门的第一步，学会计算时间复杂度对我们编写程序提高程序运行效率有很大的帮助，如何计算时间复杂度，时间复杂度指的是一个变量被使用了多少次，统计使用次数。我们一般使用大O阶方法，随着问题规模的增大，其中n与f（n）增长速度基本相同。就拿我们最常用的选择排序，他的时间复杂度如何计算呢？
首先我们需要了解如何判定一段代码的时间复杂度：
一般我们计算时间复杂度都是以最坏的情况去考虑。

  1. 使用常数 1 来取代运行时间中所有的加分常数。

  2. 计算时间复杂度需要将个位数去除，只保留最高系数项，其他的数并去除。

  3. 如果去除其他系数后，最高项存在且不是1，则去除这个项目相乘的系数。

以上三步得到的就是大O阶的时间复杂度。

要认识空间复杂度，学习其计算方法,首先要明白空间复杂度到底是什么：空间复杂度是考虑程序运行时占用内存的大小，考虑在程序运行时产生对内存的影响，就像C语言计算的内存对齐，是一种内存的体现，而在计算过程中，也需要考虑到空间复杂度不能太大，对运行速率会有影响。

1.对一个算法在运行过程中占用内存空间大小的量度，记做S(n)=O(f(n))

2.空间复杂度只是一个预估的大小

冒泡排序

在初学阶段，最常使用的排序方法就是冒泡排序
冒泡排序基本原理：

  1. 将最大/最小的数据先进行排序
  2. 依次减小比较的数据量
  3. 直到数据有序
    代码块
public static void BubblingSort(int[] array){
    for (int i = 0; i < array.length-1; i++) {
        for (int j = 0; j < array.length-i-1; j++) {
            if(array[j]>array[j+1]){
                int temp = array[j];
                array[j] = array[j+1];
                array[j+1] = temp;
            }
        }
    }
}

计算时间复杂度：

需要计算数据被使用了几次，两个嵌套循环语句都循环，外侧循环n-1次，内侧循环n-i次，计算时间复杂度（n-1）*（n-i）>n^2-in+i-n
将1来取代所有的加分常数》n^2-2n+1
去除常数项，去除其他系数项，留下最高系数项，这里的 i 是常数项==》n^2
去除相乘系数项==》n^2
这样可以得到冒泡排序的时间复杂度：O(N^2)

接下来计算空间复杂度：

统计程序中创建的变量，只有i和j，并没有其他变量，所以得到空间复杂度：O（1）

在接下来的排序中经常会使用到交换两个数据，这里我单独将其提炼出来，以防大家看不懂

private static void swap(int[] array, int i, int j) {
    int temp = array[i];
    array[i] =  array[j];
    array[j] = temp;
}

选择排序

插入排序的基本原理(*￣︶￣)

  1. 保存需要插入的下标位置
  2. 便利下标以后的位置，找到最小下标位置
  3. 与第一步保存的下标，两个元素进行交换】
    代码块
public static void SelectSort(int[] array){
    for (int i = 0; i < array.length; i++) {
        int min = i;
        for (int j = i+1; j < array.length; j++) {
            min=array[j]<array[min]?j:min;
        }
        swap(array,i,min);
    }
}
选择排序法2原理：
  1. 使用两个数字代表最大值，最小值
  2. 遍历数组，将两个值找到
  3. 将最大值放在最右边，最小值放在最左边，以此类推
    注意：这里交换时可能会把下标的值改掉，所以这里如果最大值与最左边的相等时，就将最小值的下表赋值给最小值，就是提前把值进行交换。
public static void SelectSort2(int[] array){
    int left = 0;
    int right = array.length-1;
    while (left < right){
        int maxIndex = left;
        int minIndex = left;

        for (int i = left+1; i <= right; i++) {
            maxIndex = array[i]>array[maxIndex]?i:maxIndex;
            minIndex = array[i]<array[minIndex]?i:minIndex;
        }
        //这里可能将最大值换成minIndex的位置
        //言外之意就是，最大值位于left
        if(left == maxIndex){
            maxIndex = minIndex;
        }
        swap(array,left,minIndex);
        swap(array,right,maxIndex);
        left++;
        right--;
    }
}

时间复杂度

同样的，这里也使用了两个嵌套循环语句。外层循环n次，内层循环（n-1+n-2+n-3+……+n-i),由此可见是一个等差数列。带入公式=》sn=[n(1+n)]/2 ->(n-i+n-1)*(n)/2=2n^2 -2i - 2/2 =n^2 -i - i=n2->O(N2)
求出时间复杂度为：O(N^2)

计算空间复杂度：

这里也没有创建多余的其他变量，所以得到空间复杂度：O（1）

插入排序

插入排序基本原理

  1. 将当前元素记录为 temp
  2. 从当前元素的前一个元素进行遍历往前遍历 记录当前为 i ，则前一个元素 是i-1，将 j 设置为 i-1
  3. 如果当前元素比较后一个元素大，则进行赋值操作，否则退出循环 当前 temp 的元素比 j 小就将 j 的值赋值给 j+1;相当于将数据往后移动。
  4. 最后将刚刚开始保存的值填入j下标
public static void InsertSort(int[] array){
    for (int i = 1; i < array.length; i++) {
        int temp = array[i];
        int j = i-1;
        for (; j >=0 ; j--) {
            if(temp < array[j]){
                array[j+1] = array[j];
            }else {
                break;
            }
        }
        array[j+1] = temp;
    }
}

计算时间复杂度：

这里我们讨论最坏情况：两个嵌套循环中外层循环：n-1次 内层循环：1+2+3+……+n-1=>等差数列求和公式=（1+n）*(n-1)/2=(n^2 + 1 - 2n)/2,去除多余的部分得到时间复杂度：O(N^2)

空间复杂度：

每次进入循环会创建一个temp ，多次使用内存，使用了n-1次，所以得到空间复杂度：O（N）

希尔排序（缩小增量排序）

希尔排序原理：

  1. 将数组元素进行分组比较，分组元素gap个
  2. 使用插入排序进行排序
  3. 扩大分组元素进行比较
  4. 继续使用插入排序将分好的组进行元素
  5. 直到将组值元素扩大到整个数组
public static void ShellSort(int[] array){
    int gap = array.length;
    while (gap > 1){
        //调用额外方法
        gap /= 2;
        shellSort(array,gap);
    }
    //整体进行排序
    shellSort(array,1);
}
//下面的排序，相当于改写了插入排序
private static void shellSort(int[] array,int gap){
    for (int i = gap; i < array.length; i++) {
        int temp = array[i];
        int j = i-gap;
        for (; j >= 0 ; j-= gap) {
            if(array[j] > temp){
                array[j+gap] = array[j];
            }else {
                break;
            }
        }
        array[j+gap] = temp;
    }
}

时间复杂度：科学家提出的，经过大量运算得到希尔排序的时间复杂度,O(n1.25)~O(1.6*n1.25)
空间复杂度：O(1)

堆排序

大根堆排序原理（向下调整）：

  1. 比较子节点的最大值，得到子节点最大值
  2. 将子节点与父节点对比，如果子节点大于父节点，就进行交换
  3. 把子节点当成父节点进行下一轮比较
public static void heapSort(int[] array){
    createBigHeap(array);//创建一个大根堆
    int end = array.length-1;
    while (end>=0){
        swap(array,end,0);
        shiftDown(array,end,0);
        end--;
    }
}
private static void createBigHeap(int[] array){
    for (int i = (array.length-1)/2; i >=0 ; --i) {
        shiftDown(array,array.length,i);
    }
}
public static void shiftDown(int[] array,int len,int parent){
    int child = parent*2+1;
    while (child<len){
        if(child+1<len && array[child] < array[child+1]){
            child++;
        }
        if(array[child]>array[parent]){
            swap(array,child,parent);
            parent = child;
            child = parent*2+1;
        }else {
            break;
        }
    }
}

时间复杂度：

这里每次只需要比较单个节点值的大小，时间复杂度为logN，每次都需要循环n次，得到时间复杂度 n *logn,得到大O阶表示法O(NlogN)

空间复杂度：

该排序没有使用额外的空间所以得到的空间复杂度：O(1)

快速排序

快速排序原理：

  1. 在数组中取一个数字作为基准值
  2. 声明两个变量，右边找到比基准值小的就停下交换，左边类似
  3. 交换两个下标的值，循环进行，直到退出
  4. 此时两个变量相遇，将基准值和相遇的下标的值进行交换
public static void QuickSort(int[] array){
    quickSort(array,0,array.length-1);
}

private static void quickSort(int[] array,int start,int end){
    //递归退出条件
    if(end - start <= 0){
        return;
    }
    //优化,目的是为了减少递归，可随机数字，建议不要太小
    if(end - start <= 14){
        //插入排序
        InsertSort2(array,start,end);
        return;
    }
    int index = midThree(array,start,end);//基准
    //将基准值与开始值进行交换，因为一般会将第一个数字设置为基准值
    swap(array,index,start);
    int value = partition(array,start,end);//划分

    quickSort(array,start,value-1);
    quickSort(array,value+1,end);
}
//改写的插入排序
public static void InsertSort2(int[] array,int left,int right){
    for (int i = left; i <=right ; i++) {
        int temp = array[i];
        int j = i-1;
        for (; j >=0 ; j--) {
            if(temp < array[j]){
                array[j+1] = array[j];
            }else {
                break;
            }
        }
        array[j+1] = temp;
    }
}
//交换
public static int partition(int[] array,int left,int right){
    int temp = array[left];
    while (left<right){
        //加等号，遇到一样的数据跳过
        while (left < right && array[right] >= temp){
            right--;
        }
        array[left] = array[right];
        while ( left < right && array[left] <= temp){
            left++;
        }
        array[right] = array[left];
    }
    array[left] = temp;
    return left;
}
//快排的优化+均匀分割1.随机选取基准法 2.三树取中法
private static int midThree(int[] array,int left,int right){
    int min = array.length/2;
    if(array[left]<array[right]){
        if(array[min]<array[left]){
            return left;
        }else if(array[min]>array[right]){
            return right;
        }else {
            return min;
        }
    }else {
        //array[left]>array[right]
        if(array[min] > array[left]){
            return left;
        }else if(array[min] < array[right]){
            return right;
        }else {
            return min;
        }
    }
}

快速排序Hoare法

  1. 在数组中取一个数字作为基准值
  2. 声明两个变量，左边找到比基准大的值停下来，右边找到比基准大的停下来
  3. 交换两个下标的值，循环进行，直到退出
  4. 此时两个变量相遇，将基准值和相遇的下标的值进行交换
public static int quick2(int[] array,int left,int right){
    int temp = array[left];
    int i = left;//记录下标
    while (left<right){
        while (left <right && array[right]>=temp){
            right--;
        }
        while (left<right && array[left] <= temp){
            left++;
        }
        swap(array,left,right);
    }
    swap(array,left,i);//将基准移过去
    return left;
}

时间复杂度:

每次将数组分成两部分进行排序，所以得到logn，递归的时间复杂度为n，所以得到总的时间复杂度为（n*logN）

空间复杂度:

这里使用了递归，所以会消耗一定的空间，因为基准值的不同所以时间复杂度会有一定的波动：O(logN) ~ O(N)

不使用递归的快速排序

原理：

1.准备一个栈，用于存放基准的左边和右边

2.先将基准两边数组开始下标与结束下标依次入栈

3.在栈中取需要排序的数组长度，然后比较，再继续下一步

4.如果栈为空，说明已经排序成功了

public static void QuickSort2(int[] array){
    Deque<Integer> stack = new LinkedList<>();
    int left = 0;
    int right = array.length-1;
    int pivot = partition(array,left,right);
    if(pivot > left+1){
        stack.push(left);
        stack.push(pivot-1);
    }
    if(pivot < right-1){
        stack.push(pivot+1);
        stack.push(right);
    }
    while (!stack.isEmpty()){
        right = stack.poll();
        left = stack.poll();
        pivot = partition(array,left,right);
        if(pivot >left+1){
            stack.push(left);
            stack.push(left+1);
        }
        if(pivot < right-1){
            stack.push(pivot+1);
            stack.push(right);
        }
    }
}

时间复杂度与空间复杂度与递归的快速排序一致。

归并排序

归并排序原理

1.取中间值将数组分为两组

2.将分好的数组继续向下分裂，直到数组长度为1

3.将两个相邻的数组进行排序

4.直到整合完所有数组

/**
  * 归并排序
  * 时间复杂度：O(n*logn)
  * 空间复杂度：O(N)
  * 稳定
  * @param array
  */
public static void mergeSort(int[] array){
    mergeSort(array,0,array.length-1);
}
private static void mergeSort(int[] array ,int left,int right){
    if(left >= right){
        return;
    }
    int mid = left+(right-left)/2;
    mergeSort(array,left,mid);
    mergeSort(array,mid+1,right);
    mergeSort(array,left,right,mid);
}

private static void mergeSort(int[] array, int start, int end, int mid) {
    int s1 = start;
    int s2 = mid+1;
    int[] tmp = new int[end - start+1];
    int k =0;
    while (s1 <= mid && s2 <= end){
        if(array[s1] <= array[s2]){
            tmp[k++] = array[s1++];
        }else {
            tmp[k++]=array[s2++];
        }
    }
    while (s1 <= mid){
        tmp[k++] = array[s1++];
    }
    while (s2<=end){
        tmp[k++] = array[s2++];
    }
    for (int i = 0; i < tmp.length ; i++) {
        array[i+start] = tmp[i];
    }
}

时间复杂度：

归并排序中，每次将数组分成两个，所以构成以2为底的logN次分割，然后又会分割N次，所以计算得到时间复杂度：O（NlogN）

空间复杂度：

在递归的过程中，不断的创建变量，一共递归N次，所以空间复杂度为：O（N）

非递归实现归并排序

思想：

1.每一个数字对于自身是有序的，先将gap设置为1

2.然后增加gap的量，不过要控制gap不能超过数组长度

3.使用left,right,mid分成两组数据一起排序，数组中数字相对有序

4.在进行下一组，直到gap等于数组长度

//归并排序的非递归实现
public static void mergeSort2(int[] array){
    int gap = 1;
    while (gap<array.length){
        for (int i = 0; i <array.length ; i+=gap*2) {
            int left = i;
            int mid = left+gap-1;
            //防止越界，下面也是如此
            if(mid>=array.length){
                mid = array.length-1;
            }
            int right = mid+gap;
            if(right>=array.length){
                right = array.length-1;
            }
            //调用排序范围的排序方法
       mergeSort(array,left,right,mid);
        }
        gap*=2;
    }
}

以上就是排序与时间复杂度和空间复杂度的学习，对于编写代码的时间和空间控制是需要自己有个底的，中间不乏有一些人说：牺牲空间，换取时间，或者牺牲时间，换取空间。

不基于比较的排序

计数排序

计数排序思想：

1.将数组中最大值和最小值分别提出来

2.固定数组长度

3.将下标和数字结合，找到数字所处的位置，并作为计数记录下来

如图：

在这里插入图片描述

接下来只需要将count数组进行打印/放回之前数组即可。

//虽然以上是针对0~9之间的数据，不过该排序也是针对变化幅度不大的数据进行排序，主要是看数据最大和最小值来确定计数数组的大小
public static void countSort(int[] array){
    //1.遍历数组找到最大值与最小值
    int max = array[0];
    int min = array[0];
    for (int i = 0; i <array.length ; i++) {
        max = max>array[i]?max:array[i];
        min = min<array[i]?min:array[i];
    }
    //根据范围定义计数数组的长度
    int len = max-min+1;
    int[] count = new int[len];
    for (int i = 0; i <array.length ; i++) {
        count[array[i]-min]++;
    }
    //遍历计数数组
    int index = 0;
    for (int i = 0; i < count.length; i++) {
        while (count[i]>0){
            array[index] = i+min;
            index++;
            count[i]--;
        }
    }
}

计数排序的时间复杂度：

首先遍历了一次数组找到最大值与最小值（n），接下来遍历一次数组将数字计数（n），然后遍历了一次计数数组将值填入数组之中（max-min+1）。

所以计算得到时间复杂度：O（N）+(范围)

空间复杂度：

除了数组长度，额外申请一个计数数组长度为（max - min+1）

得到空间复杂度：（范围）

桶排序

桶排序原理：

1.申请一个10个队列

2.将数组最低位（个位）按照队列下标依次入队

3.从0~9的顺序从前往后出队列放入数组

4.按第二低位（十位）按照队列下标依次入队

5.和第二步一样，直到放完数组中的最高树的位，依次出队，则排序完成。

如图：

在这里插入图片描述

/**
   * 桶排序（基数排序）
   * 时间复杂度：O(N)+(范围)
   * 空间复杂度：O(范围)
   * 不稳定
   * @param array
   */
public static void countSort2(int[] array) {
    int maxDigit = getMaxDigit(array);
    radixSort(array,maxDigit);
}

private static void radixSort(int[] array, int maxDigit) {
    int mod = 10 ;
    int dev = 1;
    for (int i = 0; i <maxDigit ; i++,dev *=10,mod *=10) {
        int[][] counter = new int[mod*2][0];
        for (int j = 0; j < array.length; j++) {
            int bucket = ((array[j]%mod)/dev)+mod;
            counter[bucket] = arrayAppend(counter[bucket],array[j]);
        }
        int pos = 0;
        for(int[] bucket:counter){
            for (int value:bucket) {
                array[pos++] = value;
            }
        }
    }
}

private static int[] arrayAppend(int[] array, int value) {
    array = Arrays.copyOf(array,array.length+1);
    array[array.length-1] = value;
    return array;
}

//获取最高位数
private static int getMaxDigit(int[] array) {
    int maxValue = array[0];
    for (int num:array) {
        maxValue = maxValue>num?maxValue:num;
    }
    int length = 0;
    for (int i = maxValue; i != 0 ; i/=10) {
        length++;
    }
    return length;
}
}

时间复杂度：

遍历数组找到最大的数字N次，遍历数组记录数字N次。得到时间复杂度为O（N）

空间复杂度：

申请了N个空间来存放数组的元素，空间复杂度为O（N）

稳定性

当然，排序中不仅有时间复杂度和空间复杂度的一些特性，还有稳定性，稳定性是一个排序中较为重要的一部分。

稳定性：指一个排序中，如果遇到两个相同的元素时，在排序后与排序前，他们的相对位置不变，则代表这个排序是稳定的，反之，则不稳定。

在以上的排序中，只有3个排序是稳定的：冒泡排序，插入排序，归并排序。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/509439.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

从0搭建Vue3组件库(十二):引入现代前端测试框架 Vitest

从0搭建Vue3组件库(十二):引入现代前端测试框架 Vitest

Vitest 是个高性能的前端单元测试框架,它的用法其实和 Jest 差不多,但是它的性能要优于 Jest 不少,还提供了很好的 ESM 支持,同时对于使用 vite 作为构建工具的项目来说有一个好处就是可以公用同一个配置文件vite.config.js。因此本项目将会使用 Vitest 作为测试框架。 安装 …
阅读更多...
FS2956A 8V~120V降压5V2A4.2V3A恒压芯片

FS2956A 8V~120V降压5V2A4.2V3A恒压芯片

FS2956A 内置MOS 100V开关降压型DC-DC转换器&#xff0c;FS2956A 8-100V用于电动车 滑板车 液晶仪表 5V-USB充电IC方案2A 概述&#xff1a; FS2956A 是一款支持宽电压输入的开关降压型DC-DC&#xff0c;芯片内置100V/5A功率MOS&#xff0c;最高输入电压90V。FS2956A 具有低待…
阅读更多...
初识滴滴交易策略之一：交易市场

初识滴滴交易策略之一：交易市场

初识系列前言 滴滴作为一家共享出行公司&#xff0c;利用信息技术构建了实时的、智能的在线交易市场&#xff0c;在这个庞大运转的市场之中&#xff0c;滴滴秉承着用户价值至上的宗旨&#xff0c;不断通过技术提升来实现更高效的运转效率和更贴心的用户体验。 为了使得大家能够…
阅读更多...
蚂蚁实时低代码研发和流批一体的应用实践

蚂蚁实时低代码研发和流批一体的应用实践

摘要&#xff1a;本文整理自蚂蚁实时数仓架构师马年圣&#xff0c;在 Flink Forward Asia 2022 流批一体专场的分享。本篇内容主要分为四个部分&#xff1a; 1. 实时应用场景与研发体系 2. 低代码研发 3. 流批一体 4. 规划展望 Tips&#xff1a;点击「阅读原文」查看原文视频&a…
阅读更多...
KingbaseES V8R6备份恢复系列之 -- system-Id不匹配备份故障

KingbaseES V8R6备份恢复系列之 -- system-Id不匹配备份故障

​ KingbaseES V8R6备份恢复案例之---system-Id不匹配备份故障 案例说明&#xff1a; 在KingbaseES V8R6执行备份时&#xff0c;在sys_log日志中出现system-id不一致的故障并伴随有归档失败&#xff0c;故障如下图所示&#xff1a; 适用版本&#xff1a; KingbaseES V8R6 一、问…
阅读更多...
React 学习笔记

React 学习笔记

文章目录 React 简介React 特点React 学习前提React 第一个实例 React 简介 React 是一个用于构建用户界面的 JAVASCRIPT 库。 React主要用于构建UI&#xff0c;很多人认为 React 是 MVC 中的 V&#xff08;视图&#xff09;。 React 起源于 Facebook 的内部项目&#xff0c;用…
阅读更多...
Flink窗口

Flink窗口

目录 窗口 Flink “存储桶” 窗口分类 按照驱动类型分类 按照窗口分配数据的规则分类 滚动窗口 滑动窗口 会话窗口 全局窗口 窗口的生命周期 窗口 窗口&#xff1a;将无限数据切割成有限的“数据块”进行处理&#xff0c;以便更高效地处理无界流 在处理无界数据流时…
阅读更多...
3.1 掌握绘图基础语法与常用参数

3.1 掌握绘图基础语法与常用参数

3.1 掌握绘图基础语法与常用参数 3.1.1 掌握pyplot基础语法1.创建画布与创建子图2.添加画布内容3.保存与展示图形 3.1.2 设置pyplot的动态rc参数线条常用的rc参数 Matplotlib库介绍 Matplotlib是Python中最常用的可视化工具之一&#xff0c;可以非常方便地创建海量类型的2D图表…
阅读更多...
实验二十、压控电压源二阶 LPF 幅频特性的研究

实验二十、压控电压源二阶 LPF 幅频特性的研究

一、题目 研究压控电压源二阶低通滤波电路品质因数 Q Q Q 对频率特性的影响。 二、仿真电路 电路如图1所示。集成运放采用 LM324AJ&#xff0c;其电源电压为 15V。 图 1 压控电压源二阶低通滤波电路幅频特性的测试 图1\,\,压控电压源二阶低通滤波电路幅频特性的测试 图1压控…
阅读更多...
记录一次重装系统配置工作环境

记录一次重装系统配置工作环境

128G固态换大硬盘&#xff0c;偷懒不想重装系统&#xff0c;利用diskgenius迁移系统&#xff0c;热迁移和PE都没能成功迁移&#xff0c;还不小心删掉了机械盘的所有分区。利用diskgenius搜索分区&#xff0c;恢复文件&#xff0c;勉强把一些数据文件保存下来了。但是软件又得重…
阅读更多...
DOM是什么（DOM的节点类型）

DOM是什么（DOM的节点类型）

学到DOM时&#xff0c;看到关于文档&#xff08;结构树&#xff09;、节点&#xff08;node&#xff09;、和DOM提供的一些方法获取&#xff08;找到&#xff09;所需的节点、还有DOM属性&#xff0c;我很混乱&#xff0c;我无法弄清节点的关系层级属性和方法的关系&#xff0c…
阅读更多...
SQL常用语句总结

SQL常用语句总结

一&#xff0c;简介 1.1 数据库是用来存放数据的&#xff0c;对数据库的操作需要用到SQL语句 1.2 数据库种类有也非常多&#xff1a; 关系型数据库&#xff1a; Oracle、DB2、Microsoft SQL Server、Microsoft Access、MySQL、SQLite 非关系型数据库&#xff1a; NoSql、Cl…
阅读更多...
Vue Cli 之 环境变量和模式

Vue Cli 之 环境变量和模式

一、环境变量 ​ 我们在使用 Vue-cli 创建的Vue项目中&#xff0c;可以在构建和运行时为项目设置环境变量&#xff0c;这些环境变量会根据环境&#xff08;模式&#xff09;的不同&#xff0c;而自动注入到项目中&#xff0c;也就是说我们可以根据环境不同&#xff0c;设置不同…
阅读更多...
二进制单节点搭建 Kubernetes v1.20

二进制单节点搭建 Kubernetes v1.20

目录 第一章.操作系统初始化配置 1.1.安装环境部署 1.2.部署 docker引擎 第二章.部署 etcd 集群 2.1.ETCD简述 2.2.准备签发证书环境 在 master01 节点上操作 2.3. 生成Etcd证书​​​​​​​ 2.4.在 node01 节点上操作 在 node02 节点上操作 2.5.部署 Master 组件…
阅读更多...
SpringBoot ( 四 ) 接值

SpringBoot ( 四 ) 接值

2.5.接值 通过方法的参数来接收请求传来值 请求时传值的方式有三种方式 : URL?namevalueform表单Ajax 异步传值 接收传来的值有三类 : 单一值对象数组 2.5.0.传值 2.5.0.1.URL?传值 URL?标识1值1&标识2值2 URL后面使用 ? 连接参数, 每组参数使用 连接标识与值, 多…
阅读更多...
10.过滤器

10.过滤器

过滤器是做文本格式化的&#xff0c;只能用在 插值表达式 与 v-bind 上&#xff0c;在vue3中已经被弃用了&#xff0c;这里我简单记录一下并写一下在vue3的替代方法 目录 1 基本使用 1.1 vue2中的写法 1.2 vue3的替代 2 私有过滤器与全局过滤器 2.1 vue2的写法 2.2…
阅读更多...
shell脚本----数组

shell脚本----数组

文章目录 一、数组定义的方法二、数组的操作2.1 数组的输出2.2 删除数组2.3 数组切片2.4 数组的替换2.5 判断数组中是否有空值2.6 追加函数2.7 向函数传入参数 一、数组定义的方法 数组定义的规则 数组中的每个元素分分隔符一定为空格隔开每个元素都拥有与其对应的下标&#…
阅读更多...
Kubesphere流水线实现蓝绿发布

Kubesphere流水线实现蓝绿发布

Kubesphere流水线实现蓝绿发布 1. Gitlab仓库准备 1.1 创建仓库 新建空白项目,名字随便取 greenweb复制克隆地址 http://192.168.31.199/deploy/greenweb.git1.2 初始化并上传代码 克隆并初始化代码仓库 mkdir git cd git git clone http://192.168.31.199/deploy/green…
阅读更多...
AIMD 为什么收敛(tcp reno/cubic 为什么好)

AIMD 为什么收敛(tcp reno/cubic 为什么好)

TCP 拥塞控制目标是缓解并解除网络拥塞&#xff0c;让所有流量公平共享带宽&#xff0c;合在一起就是公平收敛。 AIMD(几乎所有与拥塞控制相关的协议或算法都有 AIMD 的影子&#xff0c;包括 RoCE&#xff0c;BBRv2) 为什么收敛&#xff1f;我一般会给出下面的老图&#xff1a;…
阅读更多...
1区（TOP）极速送审，5月SCI/SSCI/EI刊源表已更新，

1区（TOP）极速送审，5月SCI/SSCI/EI刊源表已更新，

2023年5月SCI/SSCI/EI期刊目录更新 5月我处新增多本1-2区高分区新刊&#xff0c;包括计算机、医学、环境、化学、材料、生物、工程、社科领域&#xff0c;新刊版面极速送审~ 以下是本月重点期刊推荐&#xff0c;可作参考&#xff1a; 计算机类新刊&#xff1a; 1区计算机科…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023