XJTUSE-数据结构-homework1

任务 1

题目：

排序算法设计：

需要写Selection、Shell、Quicksort 和 Mergesort四种排序算法，书上讲述比较全面而且不需要进行额外的优化，下面我简要地按照自己的理解讲述。

Selection（选择排序）：

关键代码：

for (int i=0;i< arr.length;i++){  int temp = i;  for (int j=i;j<arr.length;j++){  if (less(arr[j],arr[temp])){  temp = j;  }  }

通过两个循环完成排序。其中第一个循环是选择次数，第二个循环保证较大/较小的元素可以往前交换。

Shell（希尔排序）：

关键代码：

int temp = 1;  while (temp*3<len){  temp = temp*3;  }  for (int gap = temp;gap>0;gap /= 3){  for (int i=gap;i<len;i++){  for (int j= i;j>=gap&&less(arr[j],arr[j-gap]);j-=gap){  exchange(arr,j,j-gap);  }  }  }

希尔排序相当于多次有间隔的选择排序，从间隔较大的开始，起到了局部的排序，减少了排序的平均时间，再到间隔为1的，保证了该排序算法的有效性。

可以注意到，该间隔为3以及3的倍数，这会导致长度为2的排序失效，因此需要考虑长度为2的特殊情况。

我添加了以下代码：

if (len<3){  new Selection().sort(arr);  return;  
}  

保证了Shell排序算法无论输入数组长度为何值都是正确的。

Quicksort（快速排序算法）：

快速排序通过“随机”选择一个数，交换，比较，再交换，最后子数组递归，保证了排序的准确性，而且相较于前面的排序算法，该算法时间复杂度大大提升至O（nlogn）。具体代码在附录可见。

Mergesort（归并排序）：

这是经典的空间换取时间的排序算法。

关键方法如下：

private void mergeSort(Comparable[] arr,Comparable[] temArr, int left,int right)；  
private void merge(Comparable[] arr,Comparable[] temArr, int leftPos,int rightPos,int rightEnd)；

其中mergeSort反复递归，merge是用来合并两个子数组成为一个有序的父数组。

通过当子数组长度为1为边界条件保证了排序的准确性。

接下来就是测试编写的四种排序算法的正确性，我参考老师提供的SortTest编写了Test类，随机选择数据量，多次运行，其isSorted结果均为true。

以下为测试结果：

这是Insertion测试：  
数据量为100,验证结果为：true  
数据量为1000,验证结果为：true  
数据量为10000,验证结果为：true  
这是Shell测试：  
数据量为100,验证结果为：true  
数据量为1000,验证结果为：true  
数据量为10000,验证结果为：true  
这是Quicksort测试：  
数据量为100,验证结果为：true  
数据量为1000,验证结果为：true  
数据量为10000,验证结果为：true  
这是Selection测试：  
数据量为100,验证结果为：true  
数据量为1000,验证结果为：true  
数据量为10000,验证结果为：true  
这是Mergesort测试：  
数据量为100,验证结果为：true  
数据量为1000,验证结果为：true  
数据量为10000,验证结果为：true

任务2

题目：

将老师提供的SortTest进行了如下更改：

1.根据数据改变了数据量数组；

2.输出文字进行改变

测试结果（时间单位为ns）如下：

这是Insertion测试：  
数据量2^8,5次平均1322680.0000  数据量2^9,5次平均1468760.0000  数据量2^10,5次平均2458300.0000  数据量2^11,5次平均4726600.0000  数据量2^12,5次平均18527580.0000  数据量2^13,5次平均74433980.0000  数据量2^14,5次平均357883060.0000  数据量2^15,5次平均1593175460.0000  数据量2^16,5次平均6490592300.0000  这是Shell测试：  
数据量2^8,5次平均153680.0000  数据量2^9,5次平均311600.0000  数据量2^10,5次平均405260.0000  数据量2^11,5次平均352040.0000  数据量2^12,5次平均841920.0000  数据量2^13,5次平均1360680.0000  数据量2^14,5次平均2785880.0000  数据量2^15,5次平均7956360.0000  数据量2^16,5次平均20619880.0000  这是Quicksort测试：  
数据量2^8,5次平均225160.0000  数据量2^9,5次平均118000.0000  数据量2^10,5次平均241120.0000  数据量2^11,5次平均473040.0000  数据量2^12,5次平均759900.0000  数据量2^13,5次平均1666420.0000  数据量2^14,5次平均6832760.0000  数据量2^15,5次平均4231260.0000  数据量2^16,5次平均9369600.0000  这是Selection测试：  
数据量2^8,5次平均599240.0000  数据量2^9,5次平均783020.0000  数据量2^10,5次平均2269340.0000  数据量2^11,5次平均2438100.0000  数据量2^12,5次平均8725240.0000  数据量2^13,5次平均33024260.0000  数据量2^14,5次平均141893780.0000  数据量2^15,5次平均701216720.0000  数据量2^16,5次平均3065605780.0000  这是Mergesort测试：  
数据量2^8,5次平均145160.0000  数据量2^9,5次平均71820.0000  数据量2^10,5次平均154580.0000  数据量2^11,5次平均343920.0000  数据量2^12,5次平均729580.0000  数据量2^13,5次平均1674500.0000  数据量2^14,5次平均14065500.0000  数据量2^15,5次平均29093740.0000  数据量2^16,5次平均21794940.0000

（数据具有随机性，下面的图像与上面数据不符合）

画出的图像如下：

总结：

       1.所有算法的运行时间随着数据量的增大均体现出增长的趋势，但是增长的速度不同，可以看出Insertion和Selection算法的增长速度相似，Shell，Quicksort, Mergesort 增长速度相似，而且前两个算法增长速度大于后三个算法速度。

       2.从运行时间的绝对值来讲，出现了两个拐点，第一个拐点是数据量为2^11时，不同增长速度的算法开始分开，运行时间相差较大。第二个拐点时数据量为2^13时，这时候增长速度相似的算法也开始波动了，这就与算法的具体实现过程有着密切的关系，比如虽然理论值Mergesort和Quicksort的运行时间应该小于Shell，但是实际上并没有多大的差距，这就表明在分配空间和递归的耗时抵消了算法上的优势。

任务3

题目：完成对每一个排序算法在数据规模为：2^8、2^9、2^10、……、2^16 的 k-有序的随机数据的排序时间的统计。（k-有序数据序列有时也被称为近似有序的数据序列）

要求：

 在同等规模的数据量下，要做 T 次运行测试，用平均值做为此次测试的结果，用以排除因数据的不同和机器运行当前的状态等因素造成的干扰；

 在该任务中除了有数据规模的变化外，还有一个可变因子 k，请同学们针对不同的 k 也做一次测试设计。

 将所有排序算法的运行时间结果用图表的方式进行展示，X 轴代表数据规模，Y 轴代表运行时间。（如果因为算法之间运行时间差异过大而造成显示上的问题，可以通过将运行时

间使用取对数的方式调整比例尺）

对实验的结果进行总结，要求同任务 2

代码：对任务二中的稍作修改即可；

数据（时间单位为ns）如下：

k=5

这是Insertion测试：  
数据量2^8,5次平均70240.0000  数据量2^9,5次平均73040.0000  数据量2^10,5次平均119780.0000  数据量2^11,5次平均228200.0000  数据量2^12,5次平均465260.0000  数据量2^13,5次平均276200.0000  数据量2^14,5次平均422700.0000  数据量2^15,5次平均668580.0000  数据量2^16,5次平均926340.0000  这是Shell测试：  
数据量2^8,5次平均81920.0000  数据量2^9,5次平均146000.0000  数据量2^10,5次平均385620.0000  数据量2^11,5次平均290640.0000  数据量2^12,5次平均293740.0000  数据量2^13,5次平均668400.0000  数据量2^14,5次平均629120.0000  数据量2^15,5次平均1305220.0000  数据量2^16,5次平均2659820.0000  这是Quicksort测试：  
数据量2^8,5次平均209900.0000  数据量2^9,5次平均96180.0000  数据量2^10,5次平均135320.0000  数据量2^11,5次平均288840.0000  数据量2^12,5次平均629000.0000  数据量2^13,5次平均1351740.0000  数据量2^14,5次平均3531480.0000  数据量2^15,5次平均2995280.0000  数据量2^16,5次平均7122440.0000  这是Selection测试：  
数据量2^8,5次平均738000.0000  数据量2^9,5次平均1435820.0000  数据量2^10,5次平均3447300.0000  数据量2^11,5次平均3149240.0000  数据量2^12,5次平均10804340.0000  数据量2^13,5次平均43137980.0000  数据量2^14,5次平均174787920.0000  数据量2^15,5次平均700124900.0000  数据量2^16,5次平均2294058560.0000  这是Mergesort测试：  
数据量2^8,5次平均139540.0000  数据量2^9,5次平均60960.0000  数据量2^10,5次平均107560.0000  数据量2^11,5次平均230620.0000  数据量2^12,5次平均516120.0000  数据量2^13,5次平均1193680.0000  数据量2^14,5次平均7410920.0000  数据量2^15,5次平均21259640.0000  数据量2^16,5次平均8129380.0000

(数据具有随机性，下面图像与上面数据不一致)

图像：

k=5

（k=10和k=3的数据不再给出，下面是图像）

取值不同的k，可以发现，k-序列排序对五种排序算法均有一定程度的影响。大大增加了Selection排序算法的排序时间。而大幅度减少了Insertion排序算法的排序时间。随着k值的增大可以看出，Selection排序算法排序时间增长，Mergesort和Quicksort在数据量较大时（2^15左右）小幅度影响。

任务4

题目：

完成了任务 2 和任务 3 之后，现要求为 GenerateData 类型再增加一种数据序列的生成方法， 该方法要求生成分布不均匀数据序列：1/2 的数据是 0，1/4 的数据是 1，1/8 的数据是 2 和 1/8 的 数据是 3。对这种分布不均匀的数据完成类似任务 2 的运行测试，检查这样的数据序列对于排序算 法的性能影响。要求同任务 2。（此时，可以将任务 2、任务 3 和任务 4 的运行测试结果做一个纵向比较，用以理解数据序列分布的不同对同一算法性能的影响，如果能从每个排序算法的过程去深 入分析理解则更好。

代码：

生成不均匀数据序列

public static Double[] getRandomData2(int N){  Double[] numbers = new Double[N];  for(int i = 0; i < N/2; i++)  numbers[i] = 0.0;  for(int i = N/2; i < 3*N/4; i++)  numbers[i] = 1.0;  for(int i = 3*N/4; i < 7*N/8; i++)  numbers[i] = 2.0;  for(int i = 7*N/8; i < N; i++)  numbers[i] = 3.0;  shuffle(numbers,0, numbers.length-1);  return numbers;  }

测试类与任务2，3的基本一致，不再放出。

需要提示的是，这种不均匀序列，我电脑会出现无法（极偶然可以）跑出Quicksort排序算法的结果。足以说明该不均匀序列对Quicksort的“不友好”。

因此Quicksort数据不再给出，图像如下：

下面将进行五种排序算法的纵向比较。

Mergesort

可以看出来，当数据量增大时，不同序列的Mergesort的运行时间逐渐接近，这与该算法的实现密切相关，因为Mergesort的最好、最坏、平均时间均为O（nlogn）。

Shell

可以看出，Shell排序算法在k-有序数据序列（近似有序的数据序列）用时明显减少，而该算法在完全随机序列用时最多。这是因为Shell算法先进行局部排序，最后一趟相当于Insert排序，因此排序序列越近似有序，该算法用时越少。

Insertion

在k-有序数据序列（近似有序的数据序列）下用时远远小于其余两项。这与Insertion实现方式有关。耗时主要是因为Insertion在排序时有着大量交换，在k-有序数据序列每项数据离其正确位置相差不大，因此交换次数少，用时少。而在完全随机序列和不均匀序列中，每项顺序离其正确位置不确定，达到了运行平均时间O(n^2)。

总体而言，三个序列曲线比较吻合，这是因为Selection无论序列特征如何，均要遍历序列找到最小值，次小值……因此，耗时在序列数值的比较，平均时间为O(n^2)。

Quicksort

 因为不均匀序列无法跑出结果，因此没有加入到图像之中。快速排序通过“随机”选择数值进行划分，在我编写的代码中“随机”的数字是中间值，因此在完全随机和k-有序数据序列中运行时间没有明显的差异。但如果“随机”的数字为前面，会导致在k-有序数据序列出现较差的情况，这是“随机”选择的数值不足以平均划分序列，导致运行时间大大增加。

       而不均匀序列无法跑出结果，初步判断为爆栈，因为不均匀序列有大量重复的数值，而且按照一定比例，因此“随机”出来的数值无法平均划分序列的情况大大增加，而且我没有进行任何优化，递归耗时较大，层数较深，导致无法运行出结果。

附录

任务1

public class Quicksort extends SortAlgorithm {  @Override  public void sort(Comparable[] objs) {  quicksort(objs,0,objs.length-1);  }  private void quicksort(Comparable[] arr, int start, int end){  int pickIndex = (start+end)/2;  exchange(arr,pickIndex,end);  int sortIndex = partition(arr,start,end-1,end);  exchange(arr,sortIndex,end);  if ((sortIndex-start)>1){  quicksort(arr,start,sortIndex-1);  }  if ((end-sortIndex)>1){  quicksort(arr,sortIndex,end);  }  }  private int partition(Comparable[] arr, int start, int end, int pivot){  do{  while (less(arr[start],arr[pivot])){  start++;  };  while (end!=0&&less(arr[pivot],arr[end])){  end--;  };  exchange(arr,start,end);  }while (start<end);  exchange(arr,start,end);  return start;  }  
}  

public class Selection extends SortAlgorithm {  @Override  public void sort(Comparable[] arr) {  for (int i=0;i< arr.length;i++){  int temp = i;  for (int j=i;j<arr.length;j++){  if (less(arr[j],arr[temp])){  temp = j;  }  }  exchange(arr,i,temp);  }  }  
}  

public class Shell extends SortAlgorithm {  @Override  public void sort(Comparable[] arr) {  int len = arr.length;  if (len<3){  new Selection().sort(arr);  return;  }  int temp = 1;  while (temp*3<len){  temp = temp*3;  }  for (int gap = temp;gap>0;gap /= 3){  for (int i=gap;i<len;i++){  for (int j= i;j>=gap&&less(arr[j],arr[j-gap]);j-=gap){  exchange(arr,j,j-gap);  }  }  }  }  
}  

public class Mergesort extends SortAlgorithm {  @Override  public void sort(Comparable[] arr) {  Comparable[] temArr = new Comparable[arr.length];  mergeSort(arr,temArr,0, arr.length-1);  }  private void mergeSort(Comparable[] arr,Comparable[] temArr, int left,int right){  if (left<right){  int center = (left+right)/2;  mergeSort(arr,temArr,left,center);  mergeSort(arr,temArr,center+1,right);  merge(arr,temArr,left,center+1,right);  }  }  private void merge(Comparable[] arr,Comparable[] temArr, int leftPos,int rightPos,int rightEnd){  int leftEnd = rightPos-1;  int tmpPos = leftPos;  int numElements = rightEnd - leftPos + 1;  while (leftPos<=leftEnd&&rightPos<=rightEnd){  if (less(arr[leftPos],arr[rightPos])){  temArr[tmpPos++]=arr[leftPos++];  }  else {  temArr[tmpPos++]=arr[rightPos++];  }  }  while (leftPos<=leftEnd){  temArr[tmpPos++]=arr[leftPos++];  }  while (rightPos<=rightEnd){  temArr[tmpPos++]=arr[rightPos++];  }  for (int i=1;i<=numElements;i++,rightEnd--){  arr[rightEnd] = temArr[rightEnd];  }  }  
}  

public class Test {  public static boolean judge(SortAlgorithm alg, Double[] numbers){  alg.sort(numbers);  return alg.isSorted(numbers);  }  public static boolean test(SortAlgorithm alg, int dataProbabilityType, int dataLength, int k, int T)  {  boolean flag = true;  Double[] numbers = null;  for(int i = 0; i < T; i++) {  switch(dataProbabilityType){  case GenerateData.UNIFORM -> numbers = GenerateData.getRandomData(dataLength);  }  flag = flag&&judge(alg,numbers);  }  return flag;  }  public static void main(String[] args) {  int[] dataLength = {100, 1000, 10000};  boolean[] judgeSort = new boolean[dataLength.length];  SortAlgorithm alg = new Insertion();  System.out.println("这是Insertion测试：");  for(int i = 0; i < dataLength.length; i++)  judgeSort[i] = test(alg, GenerateData.UNIFORM, dataLength[i], 0, 5);  for (int i=0;i<dataLength.length;i++){  System.out.printf("数据量为%d,验证结果为：%b%n",dataLength[i],judgeSort[i]);  }  alg = new Shell();  System.out.println("这是Shell测试：");  for(int i = 0; i < dataLength.length; i++)  judgeSort[i] = test(alg, GenerateData.UNIFORM, dataLength[i], 0, 5);  for (int i=0;i<dataLength.length;i++){  System.out.printf("数据量为%d,验证结果为：%b%n",dataLength[i],judgeSort[i]);  }  alg = new Quicksort();  System.out.println("这是Quicksort测试：");  for(int i = 0; i < dataLength.length; i++)  judgeSort[i] = test(alg, GenerateData.UNIFORM, dataLength[i], 0, 5);  for (int i=0;i<dataLength.length;i++){  System.out.printf("数据量为%d,验证结果为：%b%n",dataLength[i],judgeSort[i]);  }  alg = new Selection();  System.out.println("这是Selection测试：");  for(int i = 0; i < dataLength.length; i++)  judgeSort[i] = test(alg, GenerateData.UNIFORM, dataLength[i], 0, 5);  for (int i=0;i<dataLength.length;i++){  System.out.printf("数据量为%d,验证结果为：%b%n",dataLength[i],judgeSort[i]);  }  alg = new Mergesort();  System.out.println("这是Mergesort测试：");  for(int i = 0; i < dataLength.length; i++)  judgeSort[i] = test(alg, GenerateData.UNIFORM, dataLength[i], 0, 5);  for (int i=0;i<dataLength.length;i++){  System.out.printf("数据量为%d,验证结果为：%b%n",dataLength[i],judgeSort[i]);  }  }  
}

任务2

public class Test2 {  public static double time(SortAlgorithm alg, Double[] numbers){  double start = System.nanoTime();  alg.sort(numbers);  double end = System.nanoTime();  return end - start;  }  public static double test(SortAlgorithm alg, int dataProbabilityType, int dataLength, int k, int T)  {  double totalTime = 0;  Double[] numbers = null;  for(int i = 0; i < T; i++) {  switch(dataProbabilityType){  case GenerateData.UNIFORM -> numbers = GenerateData.getRandomData(dataLength);  case GenerateData.KSORTED -> numbers = GenerateData.getKSortedData(dataLength, k);  }  totalTime += time(alg, numbers);  }  return totalTime/T;  }  public static void main(String[] args) {  int[] dataLength = {256,512,1024,2048,4096,8192,16384,32768,65536};  double[] elapsedTime = new double[dataLength.length];  SortAlgorithm alg = new Insertion();  System.out.println("这是Insertion测试：");  for(int i = 0; i < dataLength.length; i++)  elapsedTime[i] = test(alg, GenerateData.UNIFORM, dataLength[i], 0, 5);  for(int i=0;i<dataLength.length;i++)  System.out.printf("数据量2^%d,5次平均%6.4f%n ",i+8, elapsedTime[i]);  alg = new Shell();  System.out.println("这是Shell测试：");  for(int i = 0; i < dataLength.length; i++)  elapsedTime[i] = test(alg, GenerateData.UNIFORM, dataLength[i], 0, 5);  for(int i=0;i<dataLength.length;i++)  System.out.printf("数据量2^%d,5次平均%6.4f%n ",i+8, elapsedTime[i]);  alg = new Quicksort();  System.out.println("这是Quicksort测试：");  for(int i = 0; i < dataLength.length; i++)  elapsedTime[i] = test(alg, GenerateData.UNIFORM, dataLength[i], 0, 5);  for(int i=0;i<dataLength.length;i++)  System.out.printf("数据量2^%d,5次平均%6.4f%n ",i+8, elapsedTime[i]);  alg = new Selection();  System.out.println("这是Selection测试：");  for(int i = 0; i < dataLength.length; i++)  elapsedTime[i] = test(alg, GenerateData.UNIFORM, dataLength[i], 0, 5);  for(int i=0;i<dataLength.length;i++)  System.out.printf("数据量2^%d,5次平均%6.4f%n ",i+8, elapsedTime[i]);  alg = new Mergesort();  System.out.println("这是Mergesort测试：");  for(int i = 0; i < dataLength.length; i++)  elapsedTime[i] = test(alg, GenerateData.UNIFORM, dataLength[i], 0, 5);  for(int i=0;i<dataLength.length;i++)  System.out.printf("数据量2^%d,5次平均%6.4f%n ",i+8, elapsedTime[i]);  }  
}

任务3

public class Test2 {  public static double time(SortAlgorithm alg, Double[] numbers){  double start = System.nanoTime();  alg.sort(numbers);  double end = System.nanoTime();  return end - start;  }  public static double test(SortAlgorithm alg, int dataProbabilityType, int dataLength, int k, int T)  {  double totalTime = 0;  Double[] numbers = null;  for(int i = 0; i < T; i++) {  switch(dataProbabilityType){  case GenerateData.UNIFORM -> numbers = GenerateData.getRandomData(dataLength);  case GenerateData.KSORTED -> numbers = GenerateData.getKSortedData(dataLength, k);  }  totalTime += time(alg, numbers);  }  return totalTime/T;  }  public static void main(String[] args) {  int[] dataLength = {256,512,1024,2048,4096,8192,16384,32768,65536};  double[] elapsedTime = new double[dataLength.length];  SortAlgorithm alg = new Insertion();  System.out.println("这是Insertion测试：");  for(int i = 0; i < dataLength.length; i++)  elapsedTime[i] = test(alg, GenerateData.KSORTED, dataLength[i], 5, 5);  for(int i=0;i<dataLength.length;i++)  System.out.printf("数据量2^%d,5次平均%6.4f%n ",i+8, elapsedTime[i]);  alg = new Shell();  System.out.println("这是Shell测试：");  for(int i = 0; i < dataLength.length; i++)  elapsedTime[i] = test(alg, GenerateData.KSORTED, dataLength[i], 5, 5);  for(int i=0;i<dataLength.length;i++)  System.out.printf("数据量2^%d,5次平均%6.4f%n ",i+8, elapsedTime[i]);  alg = new Quicksort();  System.out.println("这是Quicksort测试：");  for(int i = 0; i < dataLength.length; i++)  elapsedTime[i] = test(alg, GenerateData.KSORTED, dataLength[i], 5, 5);  for(int i=0;i<dataLength.length;i++)  System.out.printf("数据量2^%d,5次平均%6.4f%n ",i+8, elapsedTime[i]);  alg = new Selection();  System.out.println("这是Selection测试：");  for(int i = 0; i < dataLength.length; i++)  elapsedTime[i] = test(alg, GenerateData.KSORTED, dataLength[i], 5, 5);  for(int i=0;i<dataLength.length;i++)  System.out.printf("数据量2^%d,5次平均%6.4f%n ",i+8, elapsedTime[i]);  alg = new Mergesort();  System.out.println("这是Mergesort测试：");  for(int i = 0; i < dataLength.length; i++)  elapsedTime[i] = test(alg, GenerateData.KSORTED, dataLength[i], 5, 5);  for(int i=0;i<dataLength.length;i++)  System.out.printf("数据量2^%d,5次平均%6.4f%n ",i+8, elapsedTime[i]);  }  
}

任务4

public static final int RANDOM = 3;  public static Double[] getRandomData2(int N){  Double[] numbers = new Double[N];  for(int i = 0; i < N/2; i++)  numbers[i] = 0.0;  for(int i = N/2; i < 3*N/4; i++)  numbers[i] = 1.0;  for(int i = 3*N/4; i < 7*N/8; i++)  numbers[i] = 2.0;  for(int i = 7*N/8; i < N; i++)  numbers[i] = 3.0;  shuffle(numbers,0, numbers.length-1);  return numbers;  }

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

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

相关文章

关于Redisson分布式锁的用法

关于Redisson分布式锁的用法

关于Redisson分布式锁的用法 Redisson是一个基于Redis的Java分布式对象和服务框架&#xff0c;它提供了多种分布式锁的实现&#xff0c;包括可重入锁、公平锁、读写锁等。Redisson实现分布式锁的核心原理主要依赖于Redis的数据结构和Redisson框架提供的高级功能。以下详细讲解…
阅读更多...
深度学习11-20

深度学习11-20

1.神经元的个数对结果的影响&#xff1a; &#xff08;http://cs.stanford.edu/people/karpathy/convnetjs/demo/classify2d.html&#xff09; &#xff08;1&#xff09;神经元3个的时候 &#xff08;2&#xff09;神经元是10个的时候 神经元个数越多&#xff0c;可能会产生…
阅读更多...
第3章-数据类型和运算符

第3章-数据类型和运算符

#本章目标 掌握Python中的保留字与标识符 理解Python中变量的定义及使用 掌握Python中基本数据类型 掌握数据类型之间的相互转换 掌握eval()函数的使用 了解不同的进制数 掌握Python中常用的运算符及优先级1&#xff0c;保留字与标识符 保留字 指在Python中被赋予特定意义的一…
阅读更多...
[C++][设计模式][备忘录模式]详细讲解

[C++][设计模式][备忘录模式]详细讲解

目录 1.动机2.模式定义3.要点总结4.代码感受 1.动机 在软件构建过程中&#xff0c;某些对象的状态转换过程中&#xff0c;可能由于某中需要&#xff0c;要求程序能够回溯到对象之前处于某个点的状态。 如果使用一些公开接口来让其他对象得到对象的状态&#xff0c;便会暴露对象…
阅读更多...
pygame下载安装流程

pygame下载安装流程

方案一&#xff1a;直接下载 使用cmd打开窗口&#xff1a; 使用命令&#xff1a;pip install pygame即可下载最新pygame安装包 方案二&#xff1a;下载指定版本 我们需要去python官网查看对应包和发布版本&#xff1a; python官网 进去后点击PyPI&#xff0c;查找python发布…
阅读更多...
初阶数据结构之堆讲解

初阶数据结构之堆讲解

本篇文章带大家学习的是堆&#xff0c;还请各位观众老爷给个三连 正片开始 堆的概念 如果有一个关键码的集合 K { &#xff0c; &#xff0c; &#xff0c; … &#xff0c; } &#xff0c;把它的所有元素按完全二叉树的顺序存储方式存储 在一个一维数组中&#xff0c;并满…
阅读更多...
【Redis】主从复制

【Redis】主从复制

https://www.bilibili.com/video/BV1cr4y1671t?p101 https://blog.csdn.net/weixin_54232666/article/details/128825763 单节点Redis的并发能力是有上限的&#xff0c;要进一步提高Redist的并发能力&#xff0c;就需要搭建主从集群&#xff0c;实现读写分离。 主从搭建 这…
阅读更多...
访客(UV)、点击量(PV)、IP、访问量(VV)概念

访客(UV)、点击量(PV)、IP、访问量(VV)概念

1、https://www.cnblogs.com/QingPingZm/articles/13855808.htmlhttps://www.cnblogs.com/QingPingZm/articles/13855808.html
阅读更多...
监控电脑的软件有哪些？精选8大监控电脑的软件

监控电脑的软件有哪些？精选8大监控电脑的软件

根据当前市场反馈和功能评价&#xff0c;以下是八款备受推崇的电脑监控软件推荐&#xff0c;适合不同企业和组织的监控与管理需求&#xff1a; 1.安企神监控软件 特点&#xff1a;全面的局域网监控工具&#xff0c;擅长网络设备监控、网络性能管理和故障诊断。提供员工电脑屏幕…
阅读更多...
计算机网络：408考研｜湖科大教书匠｜原理参考模型II｜学习笔记

计算机网络：408考研｜湖科大教书匠｜原理参考模型II｜学习笔记

系列目录 计算机网络总纲领 计算机网络特殊考点 计算机网络原理参考模型I 计算机网络原理参考模型II 目录 系列目录更新日志前言应用层(Application Layer)一、应用层概述二、客户/服务器方式和对等方式三、动态主机配置协议(DHCP, Dynamic Host Configuration Protocol)四、域…
阅读更多...
微机原理与接口技术：重点内容｜计算机系统｜学习笔记

微机原理与接口技术：重点内容｜计算机系统｜学习笔记

系列目录 前言 只将最重要的知识点考点列出来方便学习复习 目录 系列目录前言第1章 微型计算机概述第2章 16位和32位微处理机&#x1f31f;16位微处理器 8086 第3章 Pentium 的指令系统常用指令 第4章 存储器、存储管理和高速缓存技术第5章 微型计算机和外设的数据传输第6章 串…
阅读更多...
LeetCode-213. 打家劫舍 II【数组 动态规划】

LeetCode-213. 打家劫舍 II【数组 动态规划】

LeetCode-213. 打家劫舍 II【数组 动态规划】 题目描述&#xff1a;解题思路一&#xff1a;分三种情况&#xff0c;一&#xff1a;不考虑头尾&#xff1b;二&#xff1a;考虑头不考虑尾&#xff1b;三&#xff1a;考虑尾不考虑头。解题思路二&#xff1a;优化空间解题思路三&am…
阅读更多...
Android笔记-adb keycode大全

Android笔记-adb keycode大全

使用方法 用adb发送按键事件时&#xff0c;可以使用下面表中的枚举值或者直接使用数值&#xff0c;比如 adb shell input keyevent KEYCODE_HOME 或者 adb shell input keyevent 3 下面按三种排序方法列出所有按键的 keycode&#xff0c; 分别是&#xff1a; 按功能分 按枚…
阅读更多...
LLM端侧部署系列 | 陈天奇MLC-LLM重磅升级：基于机器学习编译的通用LLM部署引擎

LLM端侧部署系列 | 陈天奇MLC-LLM重磅升级：基于机器学习编译的通用LLM部署引擎

引言 简介 MLCEngine的聊天功能 OpenAI风格API 云端REST API Python API iOS SDK Android SDK WebLLM SDK 小结 结构化生成 支持各种平台 优化引擎性能 总结 引言 流星透疏水&#xff0c;走月逆行云。 小伙伴们好&#xff0c;我是《小窗幽记机器学习》的小编&am…
阅读更多...
关于onlyoffice回调函数的问题

关于onlyoffice回调函数的问题

参考文档1&#xff1a;https://api.onlyoffice.com/zh/editors/callback 在官方文档中描述的十&#xff0c;文档存储服务的回调函数&#xff0c;必须要返回 {"error": 0}表示成功&#xff0c;否则将提示错误信息。 但是经过实测&#xff0c;我们只需要正常的返回2…
阅读更多...
每日一题——Python实现PAT乙级1090 危险品装箱（举一反三+思想解读+逐步优化）4千字好文

每日一题——Python实现PAT乙级1090 危险品装箱（举一反三+思想解读+逐步优化）4千字好文

一个认为一切根源都是“自己不够强”的INTJ 个人主页&#xff1a;用哲学编程-CSDN博客专栏&#xff1a;每日一题——举一反三Python编程学习Python内置函数 Python-3.12.0文档解读 题目链接&#xff1a;https://pintia.cn/problem-sets/994805260223102976/exam/problems/typ…
阅读更多...
基于SSM的校园闲置物品交易平台

基于SSM的校园闲置物品交易平台

文章目录 项目介绍主要功能截图：部分代码展示设计总结项目获取方式🍅 作者主页：超级无敌暴龙战士塔塔开 🍅 简介：Java领域优质创作者🏆、 简历模板、学习资料、面试题库【关注我，都给你】 🍅文末获取源码联系🍅 项目介绍 基于SSM的校园闲置物品交易平台,java项目…
阅读更多...
Advanced RAG 09：『提示词压缩』技术综述

Advanced RAG 09：『提示词压缩』技术综述

编者按&#xff1a; 如何最大限度地发挥 LLMs 的强大能力&#xff0c;同时还能控制其推理成本&#xff1f;这是当前业界研究的一个热点课题。 针对这一问题&#xff0c;本期精心选取了一篇关于"提示词压缩"(Prompt Compression)技术的综述文章。正如作者所说&#xf…
阅读更多...
Zookeeper 四、Zookeeper应用场景

Zookeeper 四、Zookeeper应用场景

Zookeeper是一个典型的发布/订阅模式的分布式数据管理与协调框架&#xff0c;我们可以使用它来进行分布式数据的发布与订阅。另一方面&#xff0c;通过对Zookeeper中丰富的数据节点类型进行交叉使用&#xff0c;配合Watcher事件通知机制&#xff0c;可以非常方便地构建一系列分…
阅读更多...
八爪鱼现金流-032，给用户发邮件提示功能

八爪鱼现金流-032，给用户发邮件提示功能

每个月的 5 号、15 号、25 号的 17:30 工资日&#xff0c;给用户发送邮件&#xff0c;提示记账月报。 您也来记账一笔吧。 然后首页能看到趋势图。 八爪鱼现金流 八爪鱼
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023