分块排序算法 java_十大经典排序算法最强总结(含JAVA代码实现)

转载自:https://www.cnblogs.com/guoyaohua/p/8600214.html

0、排序算法说明

0.1 排序的定义

对一序列对象根据某个关键字进行排序。

0.2 术语说明

稳定:如果a原本在b前面,而a=b,排序之后a仍然在b的前面;

不稳定:如果a原本在b的前面,而a=b,排序之后a可能会出现在b的后面;

内排序:所有排序操作都在内存中完成;

外排序:由于数据太大,因此把数据放在磁盘中,而排序通过磁盘和内存的数据传输才能进行;

时间复杂度: 一个算法执行所耗费的时间。

空间复杂度:运行完一个程序所需内存的大小。

0.3 算法总结

a3fc52757186f7fd7173f0748611bc14.png

图片名词解释:

n: 数据规模

k: “桶”的个数

In-place: 占用常数内存,不占用额外内存

Out-place: 占用额外内存

0.5 算法分类

cdf8e164c51f1f25009679b876863496.png

0.6 比较和非比较的区别

常见的快速排序、归并排序、堆排序、冒泡排序等属于比较排序。在排序的最终结果里,元素之间的次序依赖于它们之间的比较。每个数都必须和其他数进行比较,才能确定自己的位置。

在冒泡排序之类的排序中,问题规模为n,又因为需要比较n次,所以平均时间复杂度为O(n²)。在归并排序、快速排序之类的排序中,问题规模通过分治法消减为logN次,所以时间复杂度平均O(nlogn)。

比较排序的优势是,适用于各种规模的数据,也不在乎数据的分布,都能进行排序。可以说,比较排序适用于一切需要排序的情况。

计数排序、基数排序、桶排序则属于非比较排序。非比较排序是通过确定每个元素之前,应该有多少个元素来排序。针对数组arr,计算arr[i]之前有多少个元素,则唯一确定了arr[i]在排序后数组中的位置。

非比较排序只要确定每个元素之前的已有的元素个数即可,所有一次遍历即可解决。算法时间复杂度O(n)。

非比较排序时间复杂度底,但由于非比较排序需要占用空间来确定唯一位置。所以对数据规模和数据分布有一定的要求。

1、冒泡排序(Bubble Sort)

冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列,一次比较两个元素,如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

1.1 算法描述

比较相邻的元素。如果第一个比第二个大,就交换它们两个;

对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对,这样在最后的元素应该会是最大的数;

针对所有的元素重复以上的步骤,除了最后一个;

重复步骤1~3,直到排序完成。

1.2 动图演示

9a152a7e13500cf688efd8e5297f9f6e.png

1.3 代码实现

48304ba5e6f9fe08f3fa1abda7d326ab.png

1   /**

2 * 冒泡排序

3 *

4 * @param array

5 * @return

6 */

7 public static int[] bubbleSort(int[] array) {

8 if (array.length == 0)

9 return array;

10 for (int i = 0; i < array.length; i++)

11 for (int j = 0; j < array.length - 1 - i; j++)

12 if (array[j + 1] < array[j]) {

13 int temp = array[j + 1];

14 array[j + 1] = array[j];

15 array[j] = temp;

16 }

17 return array;

18 }

48304ba5e6f9fe08f3fa1abda7d326ab.png

1.4 算法分析

最佳情况:T(n) = O(n)   最差情况:T(n) = O(n2)   平均情况:T(n) = O(n2)

2、选择排序(Selection Sort)

表现最稳定的排序算法之一,因为无论什么数据进去都是O(n2)的时间复杂度,所以用到它的时候,数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。理论上讲,选择排序可能也是平时排序一般人想到的最多的排序方法了吧。

选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理:首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。以此类推,直到所有元素均排序完毕。

2.1 算法描述

n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下:

初始状态:无序区为R[1..n],有序区为空;

第i趟排序(i=1,2,3…n-1)开始时,当前有序区和无序区分别为R[1..i-1]和R(i..n)。该趟排序从当前无序区中-选出关键字最小的记录 R[k],将它与无序区的第1个记录R交换,使R[1..i]和R[i+1..n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区;

n-1趟结束,数组有序化了。

2.2 动图演示

c7322fccb46e3cc0ea3c107781d1e880.png

2.3 代码实现

48304ba5e6f9fe08f3fa1abda7d326ab.png

/**

* 选择排序

* @param array

* @return

*/

public static int[] selectionSort(int[] array) {

if (array.length == 0)

return array;

for (int i = 0; i < array.length; i++) {

int minIndex = i;

for (int j = i; j < array.length; j++) {

if (array[j] < array[minIndex]) //找到最小的数

minIndex = j; //将最小数的索引保存

}

int temp = array[minIndex];

array[minIndex] = array[i];

array[i] = temp;

}

return array;

}

48304ba5e6f9fe08f3fa1abda7d326ab.png

2.4 算法分析

最佳情况:T(n) = O(n2)  最差情况:T(n) = O(n2)  平均情况:T(n) = O(n2)

3、插入排序(Insertion Sort)

插入排序(Insertion-Sort)的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。插入排序在实现上,通常采用in-place排序(即只需用到O(1)的额外空间的排序),因而在从后向前扫描过程中,需要反复把已排序元素逐步向后挪位,为最新元素提供插入空间。

3.1 算法描述

一般来说,插入排序都采用in-place在数组上实现。具体算法描述如下:

从第一个元素开始,该元素可以认为已经被排序;

取出下一个元素,在已经排序的元素序列中从后向前扫描;

如果该元素(已排序)大于新元素,将该元素移到下一位置;

重复步骤3,直到找到已排序的元素小于或者等于新元素的位置;

将新元素插入到该位置后;

重复步骤2~5。

3.2 动图演示

6d867acd56e40fb32975f9e91d041fa9.png

3.2 代码实现

48304ba5e6f9fe08f3fa1abda7d326ab.png

/**

* 插入排序

* @param array

* @return

*/

public static int[] insertionSort(int[] array) {

if (array.length == 0)

return array;

int current;

for (int i = 0; i < array.length - 1; i++) {

current = array[i + 1];

int preIndex = i;

while (preIndex >= 0 && current < array[preIndex]) {

array[preIndex + 1] = array[preIndex];

preIndex--;

}

array[preIndex + 1] = current;

}

return array;

}

48304ba5e6f9fe08f3fa1abda7d326ab.png

3.4 算法分析

最佳情况:T(n) = O(n)   最坏情况:T(n) = O(n2)   平均情况:T(n) = O(n2)

4、希尔排序(Shell Sort)

希尔排序是希尔(Donald Shell)于1959年提出的一种排序算法。希尔排序也是一种插入排序,它是简单插入排序经过改进之后的一个更高效的版本,也称为缩小增量排序,同时该算法是冲破O(n2)的第一批算法之一。它与插入排序的不同之处在于,它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。

希尔排序是把记录按下表的一定增量分组,对每组使用直接插入排序算法排序;随着增量逐渐减少,每组包含的关键词越来越多,当增量减至1时,整个文件恰被分成一组,算法便终止。

4.1 算法描述

我们来看下希尔排序的基本步骤,在此我们选择增量gap=length/2,缩小增量继续以gap = gap/2的方式,这种增量选择我们可以用一个序列来表示,{n/2,(n/2)/2...1},称为增量序列。希尔排序的增量序列的选择与证明是个数学难题,我们选择的这个增量序列是比较常用的,也是希尔建议的增量,称为希尔增量,但其实这个增量序列不是最优的。此处我们做示例使用希尔增量。

先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序,具体算法描述:

选择一个增量序列t1,t2,…,tk,其中ti>tj,tk=1;

按增量序列个数k,对序列进行k 趟排序;

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

4.2 过程演示

afa8217d0366b1dd6d521c1432cd371e.png

4.3 代码实现

48304ba5e6f9fe08f3fa1abda7d326ab.png

/**

* 希尔排序

*

* @param array

* @return

*/

public static int[] ShellSort(int[] array) {

int len = array.length;

int temp, gap = len / 2;

while (gap > 0) {

for (int i = gap; i < len; i++) {

temp = array[i];

int preIndex = i - gap;

while (preIndex >= 0 && array[preIndex] > temp) {

array[preIndex + gap] = array[preIndex];

preIndex -= gap;

}

array[preIndex + gap] = temp;

}

gap /= 2;

}

return array;

}

48304ba5e6f9fe08f3fa1abda7d326ab.png

4.4 算法分析

最佳情况:T(n) = O(nlog2 n)  最坏情况:T(n) = O(nlog2 n)  平均情况:T(n) =O(nlog2n)

5、归并排序(Merge Sort)

和选择排序一样,归并排序的性能不受输入数据的影响,但表现比选择排序好的多,因为始终都是O(n log n)的时间复杂度。代价是需要额外的内存空间。

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。归并排序是一种稳定的排序方法。将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使子序列段间有序。若将两个有序表合并成一个有序表,称为2-路归并。

5.1 算法描述

把长度为n的输入序列分成两个长度为n/2的子序列;

对这两个子序列分别采用归并排序;

将两个排序好的子序列合并成一个最终的排序序列。

5.2 动图演示

2f9f62d486be19b87a3f37f13eb75786.png

5.3 代码实现

48304ba5e6f9fe08f3fa1abda7d326ab.png

/**

* 归并排序

*

* @param array

* @return

*/

public static int[] MergeSort(int[] array) {

if (array.length < 2) return array;

int mid = array.length / 2;

int[] left = Arrays.copyOfRange(array, 0, mid);

int[] right = Arrays.copyOfRange(array, mid, array.length);

return merge(MergeSort(left), MergeSort(right));

}

/**

* 归并排序——将两段排序好的数组结合成一个排序数组

*

* @param left

* @param right

* @return

*/

public static int[] merge(int[] left, int[] right) {

int[] result = new int[left.length + right.length];

for (int index = 0, i = 0, j = 0; index < result.length; index++) {

if (i >= left.length)

result[index] = right[j++];

else if (j >= right.length)

result[index] = left[i++];

else if (left[i] > right[j])

result[index] = right[j++];

else

result[index] = left[i++];

}

return result;

}

48304ba5e6f9fe08f3fa1abda7d326ab.png

5. 4 算法分析

最佳情况:T(n) = O(n)  最差情况:T(n) = O(nlogn)  平均情况:T(n) = O(nlogn)

6、快速排序(Quick Sort)

快速排序的基本思想:通过一趟排序将待排记录分隔成独立的两部分,其中一部分记录的关键字均比另一部分的关键字小,则可分别对这两部分记录继续进行排序,以达到整个序列有序。

6.1 算法描述

快速排序使用分治法来把一个串(list)分为两个子串(sub-lists)。具体算法描述如下:

从数列中挑出一个元素,称为 “基准”(pivot);

重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面(相同的数可以到任一边)。在这个分区退出之后,该基准就处于数列的中间位置。这个称为分区(partition)操作;

递归地(recursive)把小于基准值元素的子数列和大于基准值元素的子数列排序。

5.2 动图演示

eaca66d26efe27519e8c462d3a7d4593.png

5.3 代码实现

48304ba5e6f9fe08f3fa1abda7d326ab.png

/**

* 快速排序方法

* @param array

* @param start

* @param end

* @return

*/

public static int[] QuickSort(int[] array, int start, int end) {

if (array.length < 1 || start < 0 || end >= array.length || start > end) return null;

int smallIndex = partition(array, start, end);

if (smallIndex > start)

QuickSort(array, start, smallIndex - 1);

if (smallIndex < end)

QuickSort(array, smallIndex + 1, end);

return array;

}

/**

* 快速排序算法——partition

* @param array

* @param start

* @param end

* @return

*/

public static int partition(int[] array, int start, int end) {

int pivot = (int) (start + Math.random() * (end - start + 1));

int smallIndex = start - 1;

swap(array, pivot, end);

for (int i = start; i <= end; i++)

if (array[i] <= array[end]) {

smallIndex++;

if (i > smallIndex)

swap(array, i, smallIndex);

}

return smallIndex;

}

/**

* 交换数组内两个元素

* @param array

* @param i

* @param j

*/

public static void swap(int[] array, int i, int j) {

int temp = array[i];

array[i] = array[j];

array[j] = temp;

}

48304ba5e6f9fe08f3fa1abda7d326ab.png

5.4 算法分析

最佳情况:T(n) = O(nlogn)   最差情况:T(n) = O(n2)   平均情况:T(n) = O(nlogn)

7、堆排序(Heap Sort)

堆排序(Heapsort)是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构,并同时满足堆积的性质:即子结点的键值或索引总是小于(或者大于)它的父节点。

7.1 算法描述

将初始待排序关键字序列(R1,R2….Rn)构建成大顶堆,此堆为初始的无序区;

将堆顶元素R[1]与最后一个元素R[n]交换,此时得到新的无序区(R1,R2,……Rn-1)和新的有序区(Rn),且满足R[1,2…n-1]<=R[n];

由于交换后新的堆顶R[1]可能违反堆的性质,因此需要对当前无序区(R1,R2,……Rn-1)调整为新堆,然后再次将R[1]与无序区最后一个元素交换,得到新的无序区(R1,R2….Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1,则整个排序过程完成。

7.2 动图演示

93824bbcbb3c16dbfd58a0e64d2c7c3c.png

7.3 代码实现

注意:这里用到了完全二叉树的部分性质:详情见《数据结构二叉树知识点总结》

48304ba5e6f9fe08f3fa1abda7d326ab.png

//声明全局变量,用于记录数组array的长度;

static int len;

/**

* 堆排序算法

*

* @param array

* @return

*/

public static int[] HeapSort(int[] array) {

len = array.length;

if (len < 1) return array;

//1.构建一个最大堆

buildMaxHeap(array);

//2.循环将堆首位(最大值)与末位交换,然后在重新调整最大堆

while (len > 0) {

swap(array, 0, len - 1);

len--;

adjustHeap(array, 0);

}

return array;

}

/**

* 建立最大堆

*

* @param array

*/

public static void buildMaxHeap(int[] array) {

//从最后一个非叶子节点开始向上构造最大堆

for (int i = (len/2 - 1); i >= 0; i--) { //感谢 @让我发会呆 网友的提醒,此处应该为 i = (len/2 - 1)

adjustHeap(array, i);

}

}

/**

* 调整使之成为最大堆

*

* @param array

* @param i

*/

public static void adjustHeap(int[] array, int i) {

int maxIndex = i;

//如果有左子树,且左子树大于父节点,则将最大指针指向左子树

if (i * 2 < len && array[i * 2] > array[maxIndex])

maxIndex = i * 2;

//如果有右子树,且右子树大于父节点,则将最大指针指向右子树

if (i * 2 + 1 < len && array[i * 2 + 1] > array[maxIndex])

maxIndex = i * 2 + 1;

//如果父节点不是最大值,则将父节点与最大值交换,并且递归调整与父节点交换的位置。

if (maxIndex != i) {

swap(array, maxIndex, i);

adjustHeap(array, maxIndex);

}

}

48304ba5e6f9fe08f3fa1abda7d326ab.png

7.4 算法分析

最佳情况:T(n) = O(nlogn) 最差情况:T(n) = O(nlogn) 平均情况:T(n) = O(nlogn)

8、计数排序(Counting Sort)

计数排序的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。 作为一种线性时间复杂度的排序,计数排序要求输入的数据必须是有确定范围的整数。

计数排序(Counting sort)是一种稳定的排序算法。计数排序使用一个额外的数组C,其中第i个元素是待排序数组A中值等于i的元素的个数。然后根据数组C来将A中的元素排到正确的位置。它只能对整数进行排序。

8.1 算法描述

找出待排序的数组中最大和最小的元素;

统计数组中每个值为i的元素出现的次数,存入数组C的第i项;

对所有的计数累加(从C中的第一个元素开始,每一项和前一项相加);

反向填充目标数组:将每个元素i放在新数组的第C(i)项,每放一个元素就将C(i)减去1。

8.2 动图演示

25fdb31acd81f931cd443cb932140ab9.png

8.3 代码实现

48304ba5e6f9fe08f3fa1abda7d326ab.png

/**

* 计数排序

*

* @param array

* @return

*/

public static int[] CountingSort(int[] array) {

if (array.length == 0) return array;

int bias, min = array[0], max = array[0];

for (int i = 1; i < array.length; i++) {

if (array[i] > max)

max = array[i];

if (array[i] < min)

min = array[i];

}

bias = 0 - min;

int[] bucket = new int[max - min + 1];

Arrays.fill(bucket, 0);

for (int i = 0; i < array.length; i++) {

bucket[array[i] + bias]++;

}

int index = 0, i = 0;

while (index < array.length) {

if (bucket[i] != 0) {

array[index] = i - bias;

bucket[i]--;

index++;

} else

i++;

}

return array;

}

48304ba5e6f9fe08f3fa1abda7d326ab.png

8.4 算法分析

当输入的元素是n 个0到k之间的整数时,它的运行时间是 O(n + k)。计数排序不是比较排序,排序的速度快于任何比较排序算法。由于用来计数的数组C的长度取决于待排序数组中数据的范围(等于待排序数组的最大值与最小值的差加上1),这使得计数排序对于数据范围很大的数组,需要大量时间和内存。

最佳情况:T(n) = O(n+k)  最差情况:T(n) = O(n+k)  平均情况:T(n) = O(n+k)

9、桶排序(Bucket Sort)

桶排序是计数排序的升级版。它利用了函数的映射关系,高效与否的关键就在于这个映射函数的确定。

桶排序 (Bucket sort)的工作的原理:假设输入数据服从均匀分布,将数据分到有限数量的桶里,每个桶再分别排序(有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排

9.1 算法描述

人为设置一个BucketSize,作为每个桶所能放置多少个不同数值(例如当BucketSize==5时,该桶可以存放{1,2,3,4,5}这几种数字,但是容量不限,即可以存放100个3);

遍历输入数据,并且把数据一个一个放到对应的桶里去;

对每个不是空的桶进行排序,可以使用其它排序方法,也可以递归使用桶排序;

从不是空的桶里把排好序的数据拼接起来。

注意,如果递归使用桶排序为各个桶排序,则当桶数量为1时要手动减小BucketSize增加下一循环桶的数量,否则会陷入死循环,导致内存溢出。

9.2 图片演示

10985616f3ad0efb2433ed2c232a3bf6.png

9.3 代码实现

48304ba5e6f9fe08f3fa1abda7d326ab.png

/**

* 桶排序

*

* @param array

* @param bucketSize

* @return

*/

public static ArrayList BucketSort(ArrayList array, int bucketSize) {

if (array == null || array.size() < 2)

return array;

int max = array.get(0), min = array.get(0);

// 找到最大值最小值

for (int i = 0; i < array.size(); i++) {

if (array.get(i) > max)

max = array.get(i);

if (array.get(i) < min)

min = array.get(i);

}

int bucketCount = (max - min) / bucketSize + 1;

ArrayList> bucketArr = new ArrayList<>(bucketCount);

ArrayList resultArr = new ArrayList<>();

for (int i = 0; i < bucketCount; i++) {

bucketArr.add(new ArrayList());

}

for (int i = 0; i < array.size(); i++) {

bucketArr.get((array.get(i) - min) / bucketSize).add(array.get(i));

}

for (int i = 0; i < bucketCount; i++) {

if (bucketSize == 1) { // 如果带排序数组中有重复数字时 感谢 @见风任然是风 朋友指出错误

for (int j = 0; j < bucketArr.get(i).size(); j++)

resultArr.add(bucketArr.get(i).get(j));

} else {

if (bucketCount == 1)

bucketSize--;

ArrayList temp = BucketSort(bucketArr.get(i), bucketSize);

for (int j = 0; j < temp.size(); j++)

resultArr.add(temp.get(j));

}

}

return resultArr;

}

48304ba5e6f9fe08f3fa1abda7d326ab.png

9.4 算法分析

桶排序最好情况下使用线性时间O(n),桶排序的时间复杂度,取决与对各个桶之间数据进行排序的时间复杂度,因为其它部分的时间复杂度都为O(n)。很显然,桶划分的越小,各个桶之间的数据越少,排序所用的时间也会越少。但相应的空间消耗就会增大。

最佳情况:T(n) = O(n+k)   最差情况:T(n) = O(n+k)   平均情况:T(n) = O(n2)

10、基数排序(Radix Sort)

基数排序也是非比较的排序算法,对每一位进行排序,从最低位开始排序,复杂度为O(kn),为数组长度,k为数组中的数的最大的位数;

基数排序是按照低位先排序,然后收集;再按照高位排序,然后再收集;依次类推,直到最高位。有时候有些属性是有优先级顺序的,先按低优先级排序,再按高优先级排序。最后的次序就是高优先级高的在前,高优先级相同的低优先级高的在前。基数排序基于分别排序,分别收集,所以是稳定的。

10.1 算法描述

取得数组中的最大数,并取得位数;

arr为原始数组,从最低位开始取每个位组成radix数组;

对radix进行计数排序(利用计数排序适用于小范围数的特点);

10.2 动图演示

88cb17eb223c8838182dcaff3dfcde17.png

10.3 代码实现

48304ba5e6f9fe08f3fa1abda7d326ab.png

/**

* 基数排序

* @param array

* @return

*/

public static int[] RadixSort(int[] array) {

if (array == null || array.length < 2)

return array;

// 1.先算出最大数的位数;

int max = array[0];

for (int i = 1; i < array.length; i++) {

max = Math.max(max, array[i]);

}

int maxDigit = 0;

while (max != 0) {

max /= 10;

maxDigit++;

}

int mod = 10, div = 1;

ArrayList> bucketList = new ArrayList>();

for (int i = 0; i < 10; i++)

bucketList.add(new ArrayList());

for (int i = 0; i < maxDigit; i++, mod *= 10, div *= 10) {

for (int j = 0; j < array.length; j++) {

int num = (array[j] % mod) / div;

bucketList.get(num).add(array[j]);

}

int index = 0;

for (int j = 0; j < bucketList.size(); j++) {

for (int k = 0; k < bucketList.get(j).size(); k++)

array[index++] = bucketList.get(j).get(k);

bucketList.get(j).clear();

}

}

return array;

}

48304ba5e6f9fe08f3fa1abda7d326ab.png

10.4 算法分析

最佳情况:T(n) = O(n * k)   最差情况:T(n) = O(n * k)   平均情况:T(n) = O(n * k)

基数排序有两种方法:

MSD 从高位开始进行排序 LSD 从低位开始进行排序

基数排序 vs 计数排序 vs 桶排序

这三种排序算法都利用了桶的概念,但对桶的使用方法上有明显差异:

基数排序:根据键值的每位数字来分配桶

计数排序:每个桶只存储单一键值

桶排序:每个桶存储一定范围的数值

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

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

synchronized锁升级_synchronized详解以及锁的膨胀升级过程

点击上方"码之初"关注&#xff0c;选择"设为星标"与精品技术文章不期而遇来源&#xff1a;www.cnblogs.com/cxiaocai/p/12189848.html架构之路远且艰辛&#xff0c;但是学习的脚步始终不能停止&#xff0c;今天聊一聊synchronized。synchronized是jvm内部的…

改变php二维数组的值_php如何修改二维数组中的值?

php修改二维数组中值的方法&#xff1a;1、通过【for($i 0; $i < count(Array()); $i)】语句修改&#xff1b;2、通过foreach($users as &$user)语句修改。php修改二维数组中值的方法&#xff1a;1、二维数组可以通过for($i 0; $i < count(Array()); $i)这种形式…

jlabel字怎么变化_怎样才能把字写好?详解最科学的练字方法及步骤

一&#xff1a;正确的学习之路1&#xff1a;临帖从古到今&#xff0c;临帖是学习书法最基本的方法&#xff0c;没有一个书法家是没有临过帖的。2&#xff1a;专注专注学一个书法家的字&#xff0c;专心致志&#xff0c;认真临写&#xff0c;持之以恒&#xff0c;直到形同神似。…

找不到具有指定id_JAVA如何整合es指定字段不分词搜索?

一、问题在做一个需求的时候&#xff0c;需要按照电话号码查询用户关系&#xff0c;所以我这边先讲相关信息同步到es&#xff0c;但是电话号码是加密的&#xff0c;所以显示的字符串是杂乱的&#xff0c;既有字母&#xff0c;又有斜杠等号等字符&#xff0c;在进行分词查询的时…

vant 项目_vueCli4+vant+router+vuex+移动端适配

教程的开始 各位同学请先安装node、npm、vuecli4 巴拉巴拉...废话不多说立即开始随便找个地方 cmd&#xff0c;powerShell也可以 命令行走起1. 创建vue项目 随便起个名字就叫my-vue吧&#xff0c;傻瓜式回车键就行&#xff0c;也可以根据自己的喜好选择eslint。vue create my-v…

电路结构原理_精密半波、全波整流电路结构原理图解

利用二极管(开关器件)的单向导电特性&#xff0c;和放大器的优良放大性能相结合&#xff0c;可做到对输入交变信号(尤其是小幅度的电压信号)进行精密的整流&#xff0c;由此构成精密半波整流电路。若由此再添加简单电路&#xff0c;即可构成精密全波整流电路。二极管的导通压降…

vlookup两个条件匹配_vlookup,你还是只会基础的单条件查找?

很多数据分析师在简历上都会说自己熟悉excel&#xff0c;但熟练使用excel必须要掌握的核心函数vlookup首当其冲&#xff0c;其次是sumifs、match、index等等。就算熟悉vlookup&#xff0c;很多人也只会基础的单条件查找&#xff0c;其实在工作中能用到vlookup的地方有很多&…

matlab 绘制符号函数,DAY8 MATLAB学习笔记—simulink入门、MATLAB符号函数的图形绘制...

如何打开simulink&#xff1a;启动simulink&#xff1a;先打开MATLAB软件界面第一步打开simulink第二步在command windows输入 simulink然后enter&#xff0c;等待有很多模块库第三步&#xff1a;常用的simulink库打开以后会看到simulink library browser这个界面最常用的就是s…

后盾网php多少钱_商标转让做公证花多少钱-购店网

当别人对您的商标感兴趣&#xff0c;或者您想买属于自己的商标时&#xff0c;转让商标是个好主意。但不了解商标转让流程的朋友&#xff0c;可能会担心自己对商标公证书的作用缺乏了解。所以今天我们给大家介绍一下什么是商标转让公证的用途&#xff0c;具体什么是商标公证。想…

MATLAB求线性代数的参数范围,MATLAB科学计算04(线性代数问题求解一)

文章目录特殊矩阵矩阵的基本概念求解线性方程组直接求解判定求解特殊矩阵零矩阵、1矩阵及单位矩阵生成nxn方阵&#xff1a;Azeros(n), Bones(n), Ceye(n)生成mxn矩阵&#xff1a;Azeros(m,n), Bones(m,n), Ceye(m,n)生成和矩阵B同样位数的矩阵&#xff1a;Azeros(size(B))**生成…

wsl 重启_漫谈在Windows Server 2019中安装使用WSL

熟悉IT历史的朋友一定不会忘记98蓝屏事件&#xff1a;时任微软CEO的比尔盖茨和助理 Chris Capossela在1998年春季计算机分销商展会&#xff08;COMDEX &#xff09;现场演示Windows 98的“即插即用”&#xff08;plug-and-play&#xff09;新特性时&#xff0c;经历了演示计算机…

uniapp 输入框防抖节流_拉动一下控制台大小,后台请求数量爆炸,竟是没做好防抖与节流...

点击上方☝Java编程技术乐园&#xff0c;轻松关注&#xff01;及时获取有趣有料的技术文章文章很好&#xff0c;耐心阅读&#xff0c;记得点赞和关注哦~前言最近有个朋友在面试过程中遇到一个问题&#xff1a;什么是防抖和节流&#xff1f;糟了&#xff0c;这可触碰到我的知识盲…

linux matlab runtime,linux 环境 MATLAB Runtime 安装

安装 MUTsigcv 软件时需要用到MATLAB环境&#xff0c;安装过程如下&#xff1a;环境下载&#xff1a;https://ww2.mathworks.cn/products/compiler/matlab-runtime.html安装帮助&#xff1a;https://ww2.mathworks.cn/help/compiler/install-the-matlab-runtime.html下载安装软…

智能车辆手册 pdf_SIMULINK在虚拟车辆开发方面的应用

获得pdf全文&#xff0c;朋友圈集赞30个好书推荐&#xff1a;1. Radar: 《雷达手册》<推荐理由&#xff1a;中译本在原著的基础上增加了缩略语词汇总表等5个附录&#xff0c;便于读者查阅。原著是集合当今世界雷达各方面造诣最深的专家、学者编撰而成的&#xff0c;受到全世…

无限极 php算法,无限极分类算法,对你一定有帮助

无限级分类是开发中常见的情况,也经常会在面试&#xff0c;主考官问到&#xff0c;笔试中遇到&#xff0c;因此本文对常见的无限极分类算法进行总结归纳&#xff0c;其实大多数就是迭代与递归。1.循环迭代实现$arr [1>[id>1,name>父1,father>NULL],2>[id>2,…

查看队列深度_不为人知的网络编程(十一):从底层入手,深度分析TCP连接耗时的秘密...

“ 本文作者张彦飞&#xff0c;原题“聊聊TCP连接耗时的那些事儿”&#xff0c;本次收录已征得作者同意&#xff0c;转载请联系作者。即时通讯网收录时有少许改动。本文已同步发布于52im社区&#xff1a;http://www.52im.net/thread-3265-1-1.html(1、引言对于基于互联网的通信…

几级工作台做石头高墙_创造与魔法:建筑新手入门攻略,家园建材怎么做

hello大家好&#xff0c;又见面啦&#xff0c;我是创造与魔法郁金香建筑团的建筑师&#xff0c;九梨梨众所周知&#xff0c;我是一个热衷于出各类建筑案例的人&#xff0c;玩创魔两年多&#xff0c;做了好几十个不同款式的家园吧。其实创魔这个游戏&#xff0c;建筑只是其中一个…

oracle vitu,Supply Chain Management (SCM) a Manufacturing | Oracle Česká Republika

Nebyly nalezeny ždn vsledkyVašemu vyhledvn neodpovdaj ždn vsledky.Abyste našli to, co hledte, doporučujeme vyzkoušet nsledujc postup:Zkontrolujte pravopis vašich klčovch slov ve vyhledvn.Použijte synonyma pro klčov slovo, kter jste zadali, napřk…

两步路轨迹文件位置_最新Uber ATG的轨迹预测方法LiRaNet介绍

arXiv今年10月刚刚上传论文“LiRaNet: End-to-End Trajectory Prediction using Spatio-Temporal Radar Fusion“。其特色在于&#xff0c;除了激光雷达和HD Map之外&#xff0c;该轨迹预测方法采用了雷达传感器的信息。雷达和激光雷达融合是有挑战性的&#xff0c;因为前者的低…

linux查看目录下 开头,Linux下ls如何看到.开头的文件

Linux下ls查看到.开头的文件方法&#xff1a;ls -aLinux操作系统是UNIX操作系统的一种克隆系统&#xff0c;它诞生于1991 年的10 月5 日(这是第一次正式向外公布的时间)。以后借助于Internet网络&#xff0c;并通过全世界各地计算机爱好者的共同努力&#xff0c;已成为今天世界…