七大排序经典排序算法

news2024/11/16 11:49:43

吾日三省吾身：高否？富否？帅否？答曰：否。滚去学习!!!(看完这篇文章先)

目前只有C和C++的功底，暂时还未开启新语言的学习，但是大同小异，语法都差不多。

目录：
一.排序定义
二.排序算法的评价指标(最后总结)
1.算法的稳定性
2.时间复杂度和空间复杂度
三.七大排序算法
1.冒泡排序
2.选择排序
3.插入排序
4.希尔排序
5.归并排序
6.快速排序
7.堆排序
稳定性及其复杂度总结

一.排序定义

排序(sort):排序就是重新排列表中的元素，使得元素满足按关键字有序的过程。

二.排序算法的评价指标(最后总结)

1.算法的稳定性

若待排序表中有两个元素R1和R2，其对应的关键字相同即k1= k2,且在排序前R1在R2的前面，若使用某一排序算法排序后，R1仍然在R2的前面，则称这个排序算法是稳定的，否则称排序算法是不稳定的。

意思就是两个相同的关键字在排序前后位置不变,排序前在前面那么排序前就在前面，后面就在后面。

如果排序前后两个数的位置不相同，那么此算法就是不稳定的。

2.时间复杂度和空间复杂度

三.七大排序算法

·排序算法分为内部排序和外部排序，内部排序的时候哦数据都存储在内存中，外部排序中由于数据过多而无法全部放入内存。

  1. 冒泡排序

冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端。冒泡排序还有一种优化算法，就是立一个 flag，当在一趟序列遍历中元素没有发生交换，则证明该序列已经有序。

冒泡排序算法步骤：

  1. 从数组的第一个元素开始，依次比较每对相邻的元素，如果前面的元素大于后面的元素，就交换它们的位置。

  1. 对数组中的每一对相邻元素重复步骤1，直到最后一个元素。此时，数组中最后一个元素应该是最大的元素。

  1. 针对除去已排序的最后一个元素的剩余元素，重复步骤1和步骤2，直到整个数组都被排序。

注意：

当输入的数据是正序这个时候排序最快

当输入的数据是反序这个时候排序最慢

C语言实现

#include <stdio.h>
void bubble_sort(int arr[], int len) {
        int i, j, temp;
        for (i = 0; i < len - 1; i++)
                for (j = 0; j < len - 1 - i; j++)
                        if (arr[j] > arr[j + 1]) {
                                temp = arr[j];
                                arr[j] = arr[j + 1];
                                arr[j + 1] = temp;
                        }
}
int main() {
        int arr[] = { 2, 4, 6, 8, 5, 7,9 , 1,3,10};
        int len = (int) sizeof(arr) / sizeof(*arr);
        bubble_sort(arr, len);
        int i;
        for (i = 0; i < len; i++)
                printf("%d ", arr[i]);
        return 0;
}

C++实现

#include <iostream>
using namespace std;
template<typename T> //整数或浮点数皆可使用,若要使用类(class)或结构体(struct)时必须重载大于(>)运算符
void bubble_sort(T arr[], int len) {
        int i, j;
        for (i = 0; i < len - 1; i++)
                for (j = 0; j < len - 1 - i; j++)
                        if (arr[j] > arr[j + 1])
                                swap(arr[j], arr[j + 1]);
}
int main() {
        int arr[] = {2, 4, 6, 8, 5, 7,9 , 1,3,10 };
        int len = (int) sizeof(arr) / sizeof(*arr);
        bubble_sort(arr, len);
        for (int i = 0; i < len; i++)
                cout << arr[i] << ' ';
        cout << endl;
        return 0;
}
时间复杂度：最坏情况：O(N^2)
      最好情况：O(N)
空间复杂度：O(1)

2.选择排序

选择排序（Selection Sort）是一种简单的排序算法。其基本思想是首先从未排序的元素中找到最小的元素，然后将其放到已排序的序列末尾，然后再从剩余未排序的元素中继续找到最小的元素，将其放到已排序的序列末尾，以此类推，直到所有元素都排好序。

选择排序的算法步骤

  1. 遍历待排序的数组，从第一个元素开始

  1. 在未排序的元素中找到最小的元素，记录其下标

  1. 将最小的元素与第一个元素交换位置

  1. 接着在未排序的元素中继续寻找最小的元素，记录其下标

  1. 将最小的元素与第二个元素交换位置

  1. 重复步骤 4-5 直到所有元素都排序完成

C语言实现

void swap(int *a,int *b) //交换两个数
{
    int temp = *a;
    *a = *b;
    *b = temp;
}
void selection_sort(int arr[], int len)
{
    int i,j;

        for (i = 0 ; i < len - 1 ; i++)
    {
                int min = i;
                for (j = i + 1; j < len; j++)     //走访未排序的元素
                        if (arr[j] < arr[min])    //找到目前最小值
                                min = j;    //记录最小值
                swap(&arr[min], &arr[i]);    //做交換
        }
}

C++实现

template<typename T> 
void selection_sort(std::vector<T>& arr) {
        for (int i = 0; i < arr.size() - 1; i++) {
                int min = i;
                for (int j = i + 1; j < arr.size(); j++)
                        if (arr[j] < arr[min])
                                min = j;
                std::swap(arr[i], arr[min]);
        }
}

3.插入排序

插入排序（Insertion Sort）排序算法，其思想是从第二个元素开始依次将其插入到已经有序的序列中。

插入排序的算法步骤

1第二个元素开始，将该元素视为一个有序序列。

2将该元素与它前面的元素进行比较，如果前面的元素比它大，则交换位置。

3继续向前比较，直到该元素找到了合适的位置。

4对下一个元素重复上述过程，直到所有元素都排好序为止。

C语言实现

void insertion_sort(int arr[], int len){
        int i,j,key;
        for (i=1;i<len;i++){
                key = arr[i];
                j=i-1;
                while((j>=0) && (arr[j]>key)) {
                        arr[j+1] = arr[j];
                        j--;
                }
                arr[j+1] = key;
        }
}

C++实现

void insertion_sort(int arr[],int len){
        for(int i=1;i<len;i++){
                int key=arr[i];
                int j=i-1;
                while((j>=0) && (key<arr[j])){
                        arr[j+1]=arr[j];
                        j--;
                }
                arr[j+1]=key;
        }
}
时间复杂度：最坏情况下为O(N*N)，此时待排序列为逆序，或者说接近逆序
      最好情况下为O(N)，此时待排序列为升序，或者说接近升序。
空间复杂度：O(1)

4.希尔排序

希尔排序（Shell Sort）是插入排序的一种改进版本，也被称为“缩小增量排序”。它的基本思想是先将待排序的序列分割成若干个子序列，对每个子序列进行插入排序，然后逐步缩小子序列的长度，最终完成排序。

算法步骤

1.选择一个增量序列 t1，t2，……，tk，其中 ti > tj, t k = 1；

2.按增量序列个数 k，对序列进行 k 趟排序；

3.每趟排序，根据对应的增量 ti，将待排序列分割成若干长度为 m 的子序列，分别对各子表进行直接插 入排序。仅增量因子为 1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

C语言实现

void shell_sort(int arr[], int len) {
        int gap, i, j;
        int temp;
        for (gap = len >> 1; gap > 0; gap >>= 1)
                for (i = gap; i < len; i++) {
                        temp = arr[i];
                        for (j = i - gap; j >= 0 && arr[j] > temp; j -= gap)
                                arr[j + gap] = arr[j];
                        arr[j + gap] = temp;
                }
}

C++实现

template<typename T>
void shell_sort(T array[], int length) {
    int h = 1;
    while (h < length / 3) {
        h = 3 * h + 1;
    }
    while (h >= 1) {
        for (int i = h; i < length; i++) {
            for (int j = i; j >= h && array[j] < array[j - h]; j -= h) {
                std::swap(array[j], array[j - h]);
            }
        }
        h = h / 3;
    }
}
时间复杂度平均：O(N^1.3)
空间复杂度：O(1)

5.归并排序

归并排序（Merge Sort）是一种分治算法，其基本思想是将待排序序列分成若干个子序列，分别进行排序，然后将子序列合并成一个有序序列。

归并排序算法步骤：

  1. 将待排序序列分成两个子序列，分别进行递归排序。

  1. 合并两个有序子序列，得到一个更长的有序序列。

  1. 重复上述过程，直到所有子序列都有序。

int min(int x, int y) {
    return x < y ? x : y;
}
void merge_sort(int arr[], int len) {
    int *a = arr;
    int *b = (int *) malloc(len * sizeof(int));
    int seg, start;
    for (seg = 1; seg < len; seg += seg) {
        for (start = 0; start < len; start += seg * 2) {
            int low = start, mid = min(start + seg, len), high = min(start + seg * 2, len);
            int k = low;
            int start1 = low, end1 = mid;
            int start2 = mid, end2 = high;
            while (start1 < end1 && start2 < end2)
                b[k++] = a[start1] < a[start2] ? a[start1++] : a[start2++];
            while (start1 < end1)
                b[k++] = a[start1++];
            while (start2 < end2)
                b[k++] = a[start2++];
        }
        int *temp = a;
        a = b;
        b = temp;
    }
    if (a != arr) {
        int i;
        for (i = 0; i < len; i++)
            b[i] = a[i];
        b = a;
    }
    free(b);
}

C++实现

template<typename T> 
void merge_sort(T arr[], int len) {
    T *a = arr;
    T *b = new T[len];
    for (int seg = 1; seg < len; seg += seg) {
        for (int start = 0; start < len; start += seg + seg) {
            int low = start, mid = min(start + seg, len), high = min(start + seg + seg, len);
            int k = low;
            int start1 = low, end1 = mid;
            int start2 = mid, end2 = high;
            while (start1 < end1 && start2 < end2)
                b[k++] = a[start1] < a[start2] ? a[start1++] : a[start2++];
            while (start1 < end1)
                b[k++] = a[start1++];
            while (start2 < end2)
                b[k++] = a[start2++];
        }
        T *temp = a;
        a = b;
        b = temp;
    }
    if (a != arr) {
        for (int i = 0; i < len; i++)
            b[i] = a[i];
        b = a;
    }
    delete[] b;
}

C++(递归版)

void Merge(vector<int> &Array, int front, int mid, int end) {
    // preconditions:
    // Array[front...mid] is sorted
    // Array[mid+1 ... end] is sorted
    // Copy Array[front ... mid] to LeftSubArray
    // Copy Array[mid+1 ... end] to RightSubArray
    vector<int> LeftSubArray(Array.begin() + front, Array.begin() + mid + 1);
    vector<int> RightSubArray(Array.begin() + mid + 1, Array.begin() + end + 1);
    int idxLeft = 0, idxRight = 0;
    LeftSubArray.insert(LeftSubArray.end(), numeric_limits<int>::max());
    RightSubArray.insert(RightSubArray.end(), numeric_limits<int>::max());
    // Pick min of LeftSubArray[idxLeft] and RightSubArray[idxRight], and put into Array[i]
    for (int i = front; i <= end; i++) {
        if (LeftSubArray[idxLeft] < RightSubArray[idxRight]) {
            Array[i] = LeftSubArray[idxLeft];
            idxLeft++;
        } else {
            Array[i] = RightSubArray[idxRight];
            idxRight++;
        }
    }
}

void MergeSort(vector<int> &Array, int front, int end) {
    if (front >= end)
        return;
    int mid = (front + end) / 2;
    MergeSort(Array, front, mid);
    MergeSort(Array, mid + 1, end);
    Merge(Array, front, mid, end);
}

6.快速排序

快速排序（Quick Sort）是一种常用的排序算法，也是一种分治算法。其基本思想是选择一个基准元素，将待排序序列分成两个子序列，使得一个子序列中所有元素都比基准元素小，另一个子序列中所有元素都比基准元素大，然后递归地对子序列进行排序。

具体实现过程如下：

  1. 选择一个基准元素，一般选择第一个元素或者随机选择一个元素。

  1. 将序列中所有比基准元素小的元素放在基准元素的左边，所有比基准元素大的元素放在右边。

  1. 对基准元素的左右两边重复上述过程，直到每个子序列只剩下一个元素。

C语言实现

typedef struct _Range {
    int start, end;
} Range;

Range new_Range(int s, int e) {
    Range r;
    r.start = s;
    r.end = e;
    return r;
}

void swap(int *x, int *y) {
    int t = *x;
    *x = *y;
    *y = t;
}

void quick_sort(int arr[], const int len) {
    if (len <= 0)
        return; 
    Range r[len];
    int p = 0;
    r[p++] = new_Range(0, len - 1);
    while (p) {
        Range range = r[--p];
        if (range.start >= range.end)
            continue;
        int mid = arr[(range.start + range.end) / 2]; 
        int left = range.start, right = range.end;
        do {
            while (arr[left] < mid) ++left; 
            while (arr[right] > mid) --right; 
            if (left <= right) {
                swap(&arr[left], &arr[right]);
                left++;
                right--;               
            }
        } while (left <= right);
        if (range.start < right) r[p++] = new_Range(range.start, right);
        if (range.end > left) r[p++] = new_Range(left, range.end);
    }
}

C++实现

int Paritition1(int A[], int low, int high) {
   int pivot = A[low];
   while (low < high) {
     while (low < high && A[high] >= pivot) {
       --high;
     }
     A[low] = A[high];
     while (low < high && A[low] <= pivot) {
       ++low;
     }
     A[high] = A[low];
   }
   A[low] = pivot;
   return low;
 }

 void QuickSort(int A[], int low, int high) //快排母函数
 {
   if (low < high) {
     int pivot = Paritition1(A, low, high);
     QuickSort(A, low, pivot - 1);
     QuickSort(A, pivot + 1, high);
   }
 }

7.堆排序

堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。堆排序可以说是一种利用堆的概念来排序的选择排序。分为两种方法：

  1. 大顶堆：每个节点的值都大于或等于其子节点的值，在堆排序算法中用于升序排列；

  1. 小顶堆：每个节点的值都小于或等于其子节点的值，在堆排序算法中用于降序排列；

算法步骤

1创建一个堆 H[0……n-1]；

2把堆首（最大值）和堆尾互换；

3把堆的尺寸缩小 1，并调用 shift_down(0)，目的是把新的数组顶端数据调整到相应位置；

4重复步骤 2，直到堆的尺寸为 1。

C语言代码实现

#include <stdio.h>
#include <stdlib.h>

void swap(int *a, int *b) {
    int temp = *b;
    *b = *a;
    *a = temp;
}

void max_heapify(int arr[], int start, int end) {
    // 建立父節點指標和子節點指標
    int dad = start;
    int son = dad * 2 + 1;
    while (son <= end) { // 若子節點指標在範圍內才做比較
        if (son + 1 <= end && arr[son] < arr[son + 1]) // 先比較兩個子節點大小，選擇最大的
            son++;
        if (arr[dad] > arr[son]) //如果父節點大於子節點代表調整完畢，直接跳出函數
            return;
        else { // 否則交換父子內容再繼續子節點和孫節點比較
            swap(&arr[dad], &arr[son]);
            dad = son;
            son = dad * 2 + 1;
        }
    }
}

void heap_sort(int arr[], int len) {
    int i;
    // 初始化，i從最後一個父節點開始調整
    for (i = len / 2 - 1; i >= 0; i--)
        max_heapify(arr, i, len - 1);
    // 先將第一個元素和已排好元素前一位做交換，再重新調整，直到排序完畢
    for (i = len - 1; i > 0; i--) {
        swap(&arr[0], &arr[i]);
        max_heapify(arr, 0, i - 1);
    }
}

int main() {
    int arr[] = { 3, 5, 3, 0, 8, 6, 1, 5, 8, 6, 2, 4, 9, 4, 7, 0, 1, 8, 9, 7, 3, 1, 2, 5, 9, 7, 4, 0, 2, 6 };
    int len = (int) sizeof(arr) / sizeof(*arr);
    heap_sort(arr, len);
    int i;
    for (i = 0; i < len; i++)
        printf("%d ", arr[i]);
    printf("\n");
    return 0;
}

C++实现

#include <iostream>
#include <algorithm>
using namespace std;

void max_heapify(int arr[], int start, int end) {
    //建立父节点和字节点
    int dad = start;
    int son = dad * 2 + 1;
    while (son <= end) { 
        if (son + 1 <= end && arr[son] < arr[son + 1]) // 比较两个子节点大小，选择大的
            son++;
        if (arr[dad] > arr[son]) // 如果父节点大于子节点代表完整，退出函数
            return;
        else { 
            swap(arr[dad], arr[son]);
            dad = son;
            son = dad * 2 + 1;
        }
    }
}

void heap_sort(int arr[], int len) {
   
    for (int i = len / 2 - 1; i >= 0; i--)
        max_heapify(arr, i, len - 1);
    for (int i = len - 1; i > 0; i--) {
        swap(arr[0], arr[i]);
        max_heapify(arr, 0, i - 1);
    }
}

int main() {
    int arr[] = { 3, 5, 3, 0, 8, 6, 1, 5, 8, 6, 2, 4, 9, 4, 7, 0, 1, 8, 9, 7, 3, 1, 2, 5, 9, 7, 4, 0, 2, 6 };
    int len = (int) sizeof(arr) / sizeof(*arr);
    heap_sort(arr, len);
    for (int i = 0; i < len; i++)
        cout << arr[i] << ' ';
    cout << endl;
    return 0;
}

稳定性以及复杂度

大话数据结构关于排序算法的的总结：

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

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

相关文章

fuzz测试之libfuzzer使用小结

fuzz测试之libfuzzer使用小结

fuzz测试之libfuzzer使用小结背景基本原理使用方法主调DEMO参考资料背景 项目中&#xff0c;为测试算法的鲁棒性&#xff0c;经常会用到fuzz测试进行压力测试。fuzz测试是一种模糊测试方法&#xff0c;本质是通过灌入各种变异的随机数据&#xff0c;去遍历不同函数分支&#xf…
阅读更多...
蓝桥杯训练day1

蓝桥杯训练day1

前缀和差分1.前缀和(1)3956. 截断数组(2)795. 前缀和(3)796. 子矩阵的和(4)1230. K倍区间(5)99. 激光炸弹2.差分(1)797. 差分(2)差分矩阵(3)3729. 改变数组元素(4)100. 增减序列1.前缀和 (1)3956. 截断数组 方法1&#xff1a;暴力 先用两个数组分别保存前缀和&#xff0c;后缀…
阅读更多...
如何快速、全面、深入地掌握一门编程语言

如何快速、全面、深入地掌握一门编程语言

思考路线 如何快速&#xff1f; 什么样的Demo才能让人觉得你掌握了它&#xff1f; 空 判断&#xff1a;构造一个可以判断所有空的 is_empty 函数 for 循环&#xff1a;i 和 集合迭代两种 时间获取&#xff1a;年/月/日 时分秒 时间戳与时间格式互转 休眠时间函数 字符串处理…
阅读更多...
对比学习MoCo损失函数infoNCE理解（附代码）

对比学习MoCo损失函数infoNCE理解（附代码）

MoCo loss计算采用的损失函数是InfoNCE&#xff1a; ​​ 下面是MoCo的伪代码&#xff0c;MoCo这个loss的实现就是基于cross entropy loss。 将k作为q的正样本&#xff0c;因为k与q是来自同一张图像的不同视图&#xff1b;将queue作为q的负样本&#xff0c;因为queue中含有大量…
阅读更多...
【Python学习笔记】44.Python3 MongoDB和urllib

【Python学习笔记】44.Python3 MongoDB和urllib

前言 本章介绍Python的MongoDB和urllib。 Python MongoDB MongoDB 是目前最流行的 NoSQL 数据库之一&#xff0c;使用的数据类型 BSON&#xff08;类似 JSON&#xff09;。 PyMongo Python 要连接 MongoDB 需要 MongoDB 驱动&#xff0c;这里我们使用 PyMongo 驱动来连接。…
阅读更多...
Ansys Zemax / SPEOS | 光源文件转换器

Ansys Zemax / SPEOS | 光源文件转换器

本文解释了如何在 SPEOS 与 Zemax 之间转换二进制光源文件。 下载 联系工作人员获取附件 简介 在本文中&#xff0c;为用户提供了一组Python代码&#xff0c;用于在Zemax和SPEOS之间转换源文件。 有些光源&#xff0c;如 .IES 文件&#xff0c;可在 SPEOS 和 Zemax 中进行…
阅读更多...
计算机网络 | 谈谈TCP的流量控制与拥塞控制

计算机网络 | 谈谈TCP的流量控制与拥塞控制

文章目录一、TCP的流量控制1、利用滑动窗口实现流量控制【⭐⭐⭐】2、如何破解【死锁】局面❓二、TCP的拥塞控制1、拥塞控制的一般原理① 解决网络拥塞的误区② 拥塞控制与流量控制的关系【重点理解✔】2、TCP的拥塞控制方法① 接收窗口【rwnd】与拥塞窗口【cwnd】② 慢开始和拥…
阅读更多...
BPE（Byte-Pair Encoding）简介

BPE（Byte-Pair Encoding）简介

文章目录BPE简介Vocabulary构建Encoding and DecodingBPE简介 BPE是一种数据压缩算法的简单形式&#xff0c;数据中最常见的连续字节对被替换成该数据中不存在的字节。BPE的主要目标就是使用最少的token数目来表示一个corpus 在 A New Algorithm for Data Compression中首次提…
阅读更多...
Spring IOC 容器 Bean 加载过程

Spring IOC 容器 Bean 加载过程

Spring IOC 容器 Bean 加载过程 Spring 对于我们所有的类对象进行了统一抽象&#xff0c;抽象为 BeanDefinition &#xff0c;即 Bean 的定义&#xff0c;其中定义了类的全限定类名、加载机制、初始化方式、作用域等信息&#xff0c;用于对我们要自动装配的类进行生成。 Sprin…
阅读更多...
新版本 | 异步复制、交易日历、自定义状态函数......请查收！

新版本 | 异步复制、交易日历、自定义状态函数......请查收！

大家好~DolphinDB 最新版本近日已经发布&#xff0c;本次的 V2.00.9 与 V1.30.21 新版本推出了很多新功能&#xff0c;并对数据库做了全方位提升&#xff0c;是迄今为止新增功能最多的一次更新。新特性一览我们先来看一看新特性包含哪些方面&#xff1a;1、数据库针对数据安全和…
阅读更多...
管理.模型.SWOT

管理.模型.SWOT

1. SWOT 在企业战略规划中&#xff0c;通过辨析企业自身的竞争优势&#xff08;Strengths&#xff09;、劣势&#xff08;Weaknesses&#xff09;和外部环境为企业带来的机会&#xff08;Opportunities&#xff09;和威胁&#xff08; Threats&#xff09;&#xff0c;企业可制…
阅读更多...
Interview系列 - 05 Java|Iterator迭代器|集合继承体系|Set List Map接口特性|List实现类区别

Interview系列 - 05 Java|Iterator迭代器|集合继承体系|Set List Map接口特性|List实现类区别

文章目录01. 迭代器 Iterator 是什么&#xff1f;02. 迭代器 Iterator 有什么特点&#xff1f;03. 迭代器 Iterator 怎么使用&#xff1f;04. 如何边遍历边移除 Collection 中的元素&#xff1f;05. Iterator 和 ListIterator 有什么区别&#xff1f;06. 数组和集合的区别&…
阅读更多...
Alist ——本地网盘管理器

Alist ——本地网盘管理器

Alist ——本地网盘管理器 一、下载工具 Alist https://github.com/alist-org/alist二、启动登录 进入下载好的文件中&#xff0c;在地址栏输入cmd进入命令行启动 进入命令行输入 alist start启动 记住密码&#xff0c;和端口进入浏览器 输入 &#xff1a;127.0.0.1:5244用…
阅读更多...
java final关键字 详解

java final关键字 详解

概述&#xff1a;作用&#xff1a;细节&#xff1a;演示&#xff1a;总结&#xff1a;一、概述 : final [ˈ faɪnl]&#xff0c;最终的&#xff0c;最后的&#xff0c;决定性的&#xff0c;不可改变的。final作为Java中的一个关键字可以用来修饰类&#xff0c;方法&#xff0c…
阅读更多...
【程序人生】从土木专员到网易测试工程师，薪资翻3倍，他经历了什么？

【程序人生】从土木专员到网易测试工程师，薪资翻3倍，他经历了什么？

转行对于很多人来说&#xff0c;是一件艰难而又纠结的事情&#xff0c;或许缺乏勇气&#xff0c;或许缺乏魄力&#xff0c;或许内心深处不愿打破平衡。可对于我来说&#xff0c;转行是一件不可不为的事情&#xff0c;因为那意味着新的方向、新的希望。我是学工程管理的&#xf…
阅读更多...
京东测试进阶之路：初入测试碎碎念篇

京东测试进阶之路：初入测试碎碎念篇

1、基本的测试用例设计方法 基本的测试用例设计方法&#xff08;边界值分析、等价类划分等&#xff09;。 业务和场景的积累&#xff0c;了解测试需求以及易出现的bug的地方。 多维角度设计测试用例&#xff08;用户、业务流程、异常场景、代码逻辑&#xff09;。 2、需求分析 …
阅读更多...
idea自带maven位置、maven全局环境变量配置，安装jar到本地 mac

idea自带maven位置、maven全局环境变量配置，安装jar到本地 mac

声明&#xff1a;本教程为mac版教程&#xff0c;Windows请路过 idea自带maven3配置全局环境变量 mac电脑maven3位置/Applications/IntelliJ\ IDEA.app/Contents/plugins/maven/lib/maven3配置全局变量,编~/.profile文件&#xff08;没有则新建&#xff09; export MAVEN/App…
阅读更多...
JVM-JMM内存模型（happens-before、volatile）

JVM-JMM内存模型（happens-before、volatile）

前言 由于计算机的存储设备与处理器的运算速度有几个数量级的差距所以现代计算机系统都不得不加入一层读写速度尽可能接近处理器运算速度的高速缓存(Cache)来作为内存与处理器之间的缓冲。 将运算需要使用到的数据复制到缓存中&#xff0c;让运算能快速进行&#xff0c;当运算…
阅读更多...
Day895.MySql误删数据还原方案 -MySQL实战

Day895.MySql误删数据还原方案 -MySQL实战

MySql误删数据还原方案 Hi&#xff0c;我是阿昌&#xff0c;今天学习记录的是关于MySql误删数据还原方案的内容。 传统的高可用架构是不能预防误删数据的&#xff0c;因为主库的一个 drop table 命令&#xff0c;会通过 binlog 传给所有从库和级联从库&#xff0c;进而导致整…
阅读更多...
研报精选230220

研报精选230220

目录 【行业230220国信证券】银行业行业专题&#xff1a;经济复苏中的优质中小银行【行业230220国信证券】汽车行业周报&#xff08;2023年第7周&#xff09;&#xff1a;吉利将发布新品牌“银河” &#xff0c;2022年宇通纯电动客车获欧洲销量冠军【行业230220开源证券】商贸零…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023