java基础排序_Java排序算法-Java入门|Java基础课程

1、 课程目标排序是任何语言都会使用到的功能之一,然成果排序的算法有很多,对空间的要求及其时间效率也不尽相同。

本文章以Java语言示例,通过对空间要求、时间效率要求,来对比各种排序算法的使用场景

2、适用对象Java语言初学者

Java算法爱好者

3、相关概念

3.1 排序概念排序,就是使一串记录,按照其中的某个或某些关键字的大小,递增或递减的排列起来的操作。

3.2 排序算法排序算法,就是如何使得记录按照要求排列的方法。

排序算法在很多领域得到相当地重视,尤其是在大量数据的处理方面。

一个优秀的算法可以节省大量的资源。在各个领域中考虑到数据的各种限制和规范,要得到一个符合实际的优秀算法,得经过大量的推理和分析。

4、算法介绍

4.1 算法分类十种常见排序算法可以分为两大类: 非线性时间比较类排序:通过比较来决定元素间的相对次序,由于其时间复杂度不能突破O(nlogn),因此称为非线性时间比较类排序。

线性时间非比较类排序:不通过比较来决定元素间的相对次序,它可以突破基于比较排序的时间下界,以线性时间运行,因此称为线性时间非比较类排序。

4.2 算法复杂度

4.3 名词解释

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

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

时间复杂度:对排序数据的总的操作次数。反映当n变化时,操作次数呈现什么规律。

空间复杂度:是指算法在计算机内执行时所需存储空间的度量,它也是数据规模n的函数。

5、冒泡排序(Bubble Sort)

5.1 原理冒泡排序是一种简单的排序算法。

它重复地走访过要排序的数列,一次比较两个元素,如果它们的顺序错误就把它们交换过来。

走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。

这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

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

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

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

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

5.3 动图演示

5.4 代码实现

/*** 冒泡排序* 分类 -------------- 内部比较排序* 数据结构 ---------- 数组* 最差时间复杂度 ---- O(n^2)* 最优时间复杂度 ---- 如果能在内部循环第一次运行时,使用一个旗标来表示有无需要交换的可能,可以把最优时间复杂度降低到O(n)* 平均时间复杂度 ---- O(n^2)* 所需辅助空间 ------ O(1)* 稳定性 ------------ 稳定*/

public void bubble (int []array){

int temp;//交换数据 System.out.println("冒泡排序:");

for(int i=0;iarray[j+1]) { //大于时交换升降,反之降序 temp=array[j];

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

array[j+1]=temp;

}

}

}

}

6、选择排序(Selection Sort)

6.1 原理选择排序(Selection-sort)是一种简单直观的排序算法。

首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置,

然后,再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。

4以此类推,直到所有元素均排序完毕。

6.2 算法描述

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趟结束,数组有序化了。

6.3 动图演示

6.4 代码实现

/*** 选择排序* 分类 -------------- 内部比较排序* 数据结构 ---------- 数组* 最差时间复杂度 ---- O(n^2)* 最优时间复杂度 ---- O(n^2)* 平均时间复杂度 ---- O(n^2)* 所需辅助空间 ------ O(1)* 稳定性 ------------ 不稳定*/

public void selection (int []arr){

int len = arr.length;

int minIndex, temp;

for (int i = 0; i < len - 1; i++) {

minIndex = i; //用来记住数组元素的下标 for (int j = i + 1; j < len; j++) {

if (arr[j] < arr[minIndex]) { // 寻找最小的数 minIndex = j; // 将最小数的索引保存 }

}

//一轮排序进行一次数组位置交换 if(i!=minIndex) {

temp = arr[i];

arr[i] = arr[minIndex];

arr[minIndex] = temp;

}

}

}

7、插入排序(Insertion Sort)

7.1 原理插入排序(Insertion-Sort)的算法描述是一种简单直观的排序算法。

通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。

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

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

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

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

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

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

重复步骤2~5

7.3 动图演示

7.4 代码实现

/*** 插入排序* 分类 ------------- 内部比较排序* 数据结构 ---------- 数组* 最差时间复杂度 ---- 最坏情况为输入序列是降序排列的,此时时间复杂度O(n^2)* 最优时间复杂度 ---- 最好情况为输入序列是升序排列的,此时时间复杂度O(n)* 平均时间复杂度 ---- O(n^2)* 所需辅助空间 ------ O(1)* 稳定性 ------------ 稳定*/

public void insertion (int []arr){

int len = arr.length;

int preIndex, current;

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

preIndex = i - 1;

current = arr[i];

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

arr[preIndex + 1] = arr[preIndex];

preIndex--;

}

arr[preIndex + 1] = current;

}

}

8、希尔排序(Shell Sort)

8.1 原理1959年Shell发明,第一个突破O(n2)的排序算法,是简单插入排序的改进版。

它与插入排序的不同之处在于,它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。

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

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

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

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

8.3 动图演示

8.4 代码实现

/*** 希尔排序* 分类 -------------- 内部比较排序* 数据结构 ---------- 数组* 最差时间复杂度 ---- 根据步长序列的不同而不同。已知最好的为O(n(logn)^2)* 最优时间复杂度 ---- O(n)* 平均时间复杂度 ---- 根据步长序列的不同而不同。* 所需辅助空间 ------ O(1)* 稳定性 ------------ 不稳定*/

public void shellSort(int[] arrays) {

if (arrays == null || arrays.length <= 1) {

return;

}

//增量 int incrementNum = arrays.length / 2;

while (incrementNum >= 1) {

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

//进行插入排序 for (int j = i; j < arrays.length - incrementNum; j = j + incrementNum) {

if (arrays[j] > arrays[j + incrementNum]) {

int temple = arrays[j];

arrays[j] = arrays[j + incrementNum];

arrays[j + incrementNum] = temple;

}

}

}

//设置新的增量 incrementNum = incrementNum / 2;

}

System.out.println(Arrays.toString(arrays));

}

9、归并排序(Merge Sort)

9.1 原理归并排序是建立在归并操作上的一种有效的排序算法。

该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。

将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使子序列段间有序。

若将两个有序表合并成一个有序表,称为2-路归并。

9.2 算法描述把长度为n的输入序列分成两个长度为n/2的子序列;

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

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

9.3 动图演示

实现步骤(分而治之)分阶段可以理解为就是递归拆分子序列的过程,递归深度为log2n。治阶段,我们需要将两个已经有序的子序列合并成一个有序序列,比如上图中的最后一次合并,要将[4,5,7,8]和[1,2,3,6]两个已经有序的子序列,合并为最终序列[1,2,3,4,5,6,7,8],来看下实现步骤。

9.4 代码实现

/*** 归并排序* 分类 -------------- 内部比较排序* 数据结构 ---------- 数组* 最差时间复杂度 ---- O(nlogn)* 最优时间复杂度 ---- O(nlogn)* 平均时间复杂度 ---- O(nlogn)* 所需辅助空间 ------ O(n)* 稳定性 ------------ 稳定*/

public class MergeSort {

public static void main(String[] args) {

int[] arr = {9, 8, 7, 6, 5, 4, 3, 2, 1};

sort(arr);

System.out.println(Arrays.toString(arr));

}

public static void sort(int[] arr) {

int[] temp = new int[arr.length];//在排序前,先建好一个长度等于原数组长度的临时数组,避免递归中频繁开辟空间 sort(arr, 0, arr.length - 1, temp);

}

private static void sort(int[] arr, int left, int right, int[] temp) {

if (left < right) {

int mid = (left + right) / 2;

sort(arr, left, mid, temp);//左边归并排序,使得左子序列有序 sort(arr, mid + 1, right, temp);//右边归并排序,使得右子序列有序 merge(arr, left, mid, right, temp);//将两个有序子数组合并操作 }

}

private static void merge(int[] arr, int left, int mid, int right, int[] temp) {

int i = left;//左序列指针 int j = mid + 1;//右序列指针 int t = 0;//临时数组指针 while (i <= mid && j <= right) {

if (arr[i] <= arr[j]) {

temp[t++] = arr[i++];

} else {

temp[t++] = arr[j++];

}

}

while (i <= mid) {//将左边剩余元素填充进temp中 temp[t++] = arr[i++];

}

while (j <= right) {//将右序列剩余元素填充进temp中 temp[t++] = arr[j++];

}

t = 0;

//将temp中的元素全部拷贝到原数组中 while (left <= right) {

arr[left++] = temp[t++];

}

}

}

10、快速排序(Quick Sort)

10.1 原理通过一趟排序将待排记录分隔成独立的两部分,

其中一部分记录的关键字均比另一部分的关键字小,

则可分别对这两部分记录继续进行排序,以达到整个序列有序。

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

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

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

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

10.3 动图演示

10.4 代码实现

/*** 快速排序* 分类 ------------ 内部比较排序* 数据结构 --------- 数组* 最差时间复杂度 ---- 每次选取的基准都是最大(或最小)的元素,导致每次只划分出了一个分区,需要进行n-1次划分才能结束递归,时间复杂度为O(n^2)* 最优时间复杂度 ---- 每次选取的基准都是中位数,这样每次都均匀的划分出两个分区,只需要logn次划分就能结束递归,时间复杂度为O(nlogn)* 平均时间复杂度 ---- O(nlogn)* 所需辅助空间 ------ 主要是递归造成的栈空间的使用(用来保存left和right等局部变量),取决于递归树的深度,一般为O(logn),最差为O(n)* 稳定性 ---------- 不稳定*/

public class QuickSort {

public static void main(String[] args) {

int[] a = {1, 2, 4, 5, 7, 4, 5, 3, 9, 0};

System.out.println(Arrays.toString(a));

quickSort(a);

System.out.println(Arrays.toString(a));

}

public static void quickSort(int[] a) {

if (a.length > 0) {

quickSort(a, 0, a.length - 1);

}

}

private static void quickSort(int[] a, int low, int high) {

//1,找到递归算法的出口 if (low > high) {

return;

}

//2, 存 int i = low;

int j = high;

//3,key int key = a[low];

//4,完成一趟排序 while (i < j) {

//4.1 ,从右往左找到第一个小于key的数 while (i < j && a[j] > key) {

j--;

}

// 4.2 从左往右找到第一个大于key的数 while (i < j && a[i] <= key) {

i++;

}

//4.3 交换 if (i < j) {

int p = a[i];

a[i] = a[j];

a[j] = p;

}

}

// 4.4,调整key的位置 int p = a[i];

a[i] = a[low];

a[low] = p;

//5, 对key左边的数快排 quickSort(a, low, i - 1);

//6, 对key右边的数快排 quickSort(a, i + 1, high);

}

}

11、堆排序(Heap Sort)

11.1 原理堆排序(Heapsort)是指利用堆这种数据结构所设计的一种排序算法。

堆积是一个近似完全二叉树的结构,并同时满足堆积的性质:即子结点的键值或索引总是小于(或者大于)它的父节点。

11.2 算法描述将初始待排序关键字序列(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,则整个排序过程完成。

11.3 动图演示

11.4 代码实现

import java.util.Arrays;

/*** 堆排序* 分类 -------------- 内部比较排序* 数据结构 ---------- 数组* 最差时间复杂度 ---- O(nlogn)* 最优时间复杂度 ---- O(nlogn)* 平均时间复杂度 ---- O(nlogn)* 所需辅助空间 ------ O(1)* 稳定性 ------------ 不稳定*/

public class HeapSort {

public static void main(String[] args) {

int a[] = { 51, 46, 20, 18, 65, 97, 82, 30, 77, 50 };

heapSort(a);

System.out.println(Arrays.toString(a));

}

/*** 构建大顶堆*/

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

int temp, j;

temp = a[i];

for (j = 2 * i; j < len; j *= 2) {// 沿关键字较大的孩子结点向下筛选 if (j < len && a[j] < a[j + 1])

++j; // j为关键字中较大记录的下标 if (temp >= a[j])

break;

a[i] = a[j];

i = j;

}

a[i] = temp;

}

public static void heapSort(int[] a) {

int i;

for (i = a.length / 2 - 1; i >= 0; i--) {// 构建一个大顶堆 adjustHeap(a, i, a.length - 1);

}

for (i = a.length - 1; i >= 0; i--) {// 将堆顶记录和当前未经排序子序列的最后一个记录交换 int temp = a[0];

a[0] = a[i];

a[i] = temp;

adjustHeap(a, 0, i - 1);// 将a中前i-1个记录重新调整为大顶堆 }

}

}

12、计数排序(Counting Sort)

12.1 原理计数排序不是基于比较的排序算法,其核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。

作为一种线性时间复杂度的排序,计数排序要求输入的数据必须是有确定范围的整数。

12.2 算法描述找出待排序的数组中最大和最小的元素;

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

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

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

12.3 动图演示

12.4 代码实现

/*** 计数排序* 分类 ------------ 内部非比较排序* 数据结构 --------- 数组* 最差时间复杂度 ---- O(n + k)* 最优时间复杂度 ---- O(n + k)* 平均时间复杂度 ---- O(n + k)* 所需辅助空间 ------ O(n + k)* 稳定性 ----------- 稳定*/

public class CountSort {

private static int[] countSort(int[] array,int k)

{

int[] C=new int[k+1];//构造C数组 int length=array.length,sum=0;//获取A数组大小用于构造B数组 int[] B=new int[length];//构造B数组 for(int i=0;i

{

C[array[i]]+=1;// 统计A中各元素个数,存入C数组 }

for(int i=0;i

sum+=C[i];

C[i]=sum;

}

for(int i=length-1;i>=0;i--)//遍历A数组,构造B数组 {

B[C[array[i]]-1]=array[i];//将A中该元素放到排序后数组B中指定的位置 C[array[i]]--;//将C中该元素-1,方便存放下一个同样大小的元素

}

return B;//将排序好的数组返回,完成排序

}

public static void main(String[] args)

{

int[] A=new int[]{2,5,3,0,2,3,0,3};

int[] B=countSort(A, 5);

System.out.println(Arrays.toString(B));

}

}

13、桶排序(Bucket Sort)

13.1 原理桶排序是计数排序的升级版。

它利用了函数的映射关系,高效与否的关键就在于这个映射函数的确定。

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

13.2 算法描述设置一个定量的数组当作空桶;

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

对每个不是空的桶进行排序;

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

13.3 动图演示

13.4 代码实现

/*** 桶排序* * 分类 ------------- 内部非比较排序* 数据结构 --------- 数组* 最差时间复杂度 ---- O(nlogn)或O(n^2),只有一个桶,取决于桶内排序方式* 最优时间复杂度 ---- O(n),每个元素占一个桶* 平均时间复杂度 ---- O(n),保证各个桶内元素个数均匀即可* 所需辅助空间 ------ O(n + bn)* 稳定性 ----------- 稳定*/

public static void bucketSort(int[] arr){

int max = Integer.MIN_VALUE;

int min = Integer.MAX_VALUE;

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

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

min = Math.min(min, arr[i]);

}

//桶数 int bucketNum = (max - min) / arr.length + 1;

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

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

bucketArr.add(new ArrayList());

}

//将每个元素放入桶 for(int i = 0; i < arr.length; i++){

int num = (arr[i] - min) / (arr.length);

bucketArr.get(num).add(arr[i]);

}

//对每个桶进行排序 for(int i = 0; i < bucketArr.size(); i++){

Collections.sort(bucketArr.get(i));

}

System.out.println(bucketArr.toString());

}

14、基数排序(Radix Sort)

14.1 原理基数排序是按照低位先排序,然后收集;

再按照高位排序,然后再收集;依次类推,直到最高位。

有时候有些属性是有优先级顺序的,先按低优先级排序,再按高优先级排序。

最后的次序就是高优先级高的在前,高优先级相同的低优先级高的在前。

14.2 算法描述取得数组中的最大数,并取得位数;

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

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

14.3 动图演示

14.4 代码实现

/*** 基数排序* 分类 ------------- 内部非比较排序* 数据结构 ---------- 数组* 最差时间复杂度 ---- O(n * dn)* 最优时间复杂度 ---- O(n * dn)* 平均时间复杂度 ---- O(n * dn)* 所需辅助空间 ------ O(n * dn)* 稳定性 ----------- 稳定*/

private static void radixSort(int[] array,int d)

{

int n=1;//代表位数对应的数:1,10,100... int k=0;//保存每一位排序后的结果用于下一位的排序输入 int length=array.length;

int[][] bucket=new int[10][length];//排序桶用于保存每次排序后的结果,这一位上排序结果相同的数字放在同一个桶里 int[] order=new int[length];//用于保存每个桶里有多少个数字 while(n

{

for(int num:array) //将数组array里的每个数字放在相应的桶里 {

int digit=(num/n)%10;

bucket[digit][order[digit]]=num;

order[digit]++;

}

for(int i=0;i

if(order[i]!=0)//这个桶里有数据,从上到下遍历这个桶并将数据保存到原数组中 {

for(int j=0;j

{

array[k]=bucket[i][j];

k++;

}

}

order[i]=0;//将桶里计数器置0,用于下一次位排序 }

n*=10;

k=0;//将k置0,用于下一轮保存位排序结果 }

}

更多资深讲师相关课程资料、学习笔记请入群后向管理员免费获取,更有专业知识答疑解惑。入群即送价值499元在线课程一份。

QQ群号:560819979

敲门砖(验证信息):浪淘沙

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

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

相关文章

python逐行打印_python中逐行打印

方法一&#xff1a;readline函数 f open("./code.txt")      #返回一个文件对象 line f.readline() #调用文件的 readline()方法 whileline: print(line, end ) #在 Python 3中使用 line f.readline() f.close() 方法二&#xff1a;一次读取多行数据 with ope…

多个python脚本同时执行_Python实现脚本锁功能(同时只能执行一个脚本)

1. 文件锁脚本启动前检查特定文件是否存在&#xff0c;不存在就启动并新建文件&#xff0c;脚本结束后删掉特定文件。通过文件的判断来确定脚本是否正在执行。方法实现也比较简单&#xff0c;这里以python脚本为例#codingutf-8## 文件锁脚本测试#import os #操作系统import tim…

耳机不分主从是什么意思_开学必备高性价蓝牙耳机,学生党时尚配件推荐

耳机自从手机出世之后就一直伴随着我们&#xff0c;作为手机的最佳搭档被我们使用&#xff0c;像现如今流行的蓝牙耳机我们就经常使用&#xff0c;大学生也是差不多每天都用得着&#xff0c;听歌、散步、玩游戏、看剧等哪都看得到它的身影&#xff0c;当然蓝牙耳机价格也有高低…

11g java 驱动_Oracle 11g Java驱动包ojdbc6.jar安装到maven库,并查看jar具体版本号

ojdbc6.jar下载Oracle官方宣布的Oracle数据库11g的驱动jar包是ojdbc6.jarojdbc6.jar下载地址&#xff1a;https://www.oracle.com/technetwork/database/enterprise-edition/jdbc-112010-090769.html (Oracle Database 11g Release 2 (11.2.0.4) JDBC Drivers & UCP Downlo…

功放音量调节原理_玩汽车音响,功放和喇叭,应该如何做好匹配?

原标题&#xff1a;玩汽车音响&#xff0c;功放和喇叭&#xff0c;应该如何做好匹配&#xff1f;功放和喇叭搭配使用&#xff0c;离不开合理匹配&#xff0c;那么如何做好两者匹配呢&#xff1f;功放和喇叭要做到三匹配&#xff1a;阻抗匹配、功率匹配和工作频率匹配。只有这样…

python淘宝抢购_Python 实现毫秒级淘宝抢购脚本的示例代码

本篇文章主要介绍了Python 通过selenium实现毫秒级自动抢购的示例代码&#xff0c;通过扫码登录即可自动完成一系列操作&#xff0c;抢购时间精确至毫秒&#xff0c;可抢加购物车等待时间结算的&#xff0c;也可以抢聚划算的商品。 博主不提供任何服务器端程序&#xff0c;也不…

java seekbar_SeekBar的基本使用方法

a)什么是SeekBarb)使用SeekBar的步骤:i.在布局文件当中声明SeekBar: ii.定义一个OnSeekBarChangeListener: private class SeekBarListener implements SeekBar.OnSeekBarChangeListener{public void onProgressChanged(SeekBar seekBar,int progress,Boolean fromUser){System…

线程中如何使用对象_在 Flink 算子中使用多线程如何保证不丢数据?

简介&#xff1a; 本人通过分析痛点、同步批量请求优化为异步请求、多线程 Client 模式、Flink 算子内多线程实现以及总结四部分帮助大家理解 Flink 中使用多线程的优化及在 Flink 算子中使用多线程如何保证不丢数据。分析痛点笔者线上有一个 Flink 任务消费 Kafka 数据&#x…

用python绘制好看的图形_怎么用Python画出好看的词云图?

相信很多人在第一眼看到下面这些图时&#xff0c;都会被其牛逼的视觉效应所吸引&#xff0c;这篇文章就教大家怎么用Python画出这种图。 前期准备 上面的这种图叫做词云图&#xff0c;主要用途是将文本数据中出现频率较高的关键词以可视化的形式展现出来&#xff0c;使人一眼就…

linux回到桌面的命令符_三 基本的base shell 命令

1、启动shell进入 /etc/passwd 看到知道默认的是base shell ctrlaltt 或者双击终端&#xff0c;就进入如下图界面&#xff1b;如果你还是CLI新手&#xff0c;请记住&#xff0c;在输入shell命令之后&#xff0c;需要按回车键才能让shell执行你输入的命令。2、bash 手册man 命令…

java单纯形法_单纯形法 - fjzzq2002 - 博客园

看了集训队答辩&#xff0c;感觉要学习的有杜教筛高级版、线性规划、FFT、仙人掌、高级版线段树不出意外的话一个月内博客内都不会有别的东西了QAQ首先是喜闻乐见的单纯形法解线性规划。今年(2016年)和线性规划有关的集训队论文有两篇&#xff0c;大家可以自行翻一下集训队论文…

python调用js获取异步返回的数据_Python怎么获取js动态加载的数据

展开全部 import selenium from selenium import webdriver from selenium.common.exceptions import NoSuchElementException from selenium.webdriver.common.keys import Keys import time browser webdriver.Firefox() # Get local session of firefox browser.get("…

一个柱状图里两种数据_分享一些数据分析常用的统计图图表

无论是报表分析还是可视化分析中&#xff0c;最直观传达数据走向趋势的就是各式各样的统计图&#xff0c;比如想要比较分析两种不同的变量数据&#xff0c;可以用柱状图&#xff1b;想要查看某一数据在整体数据中所占的比例&#xff0c;可以用饼图来展示&#xff1b;想要查看某…

java 单例 读写锁_你用对锁了吗?浅谈 Java “锁” 事

每个时代&#xff0c;都不会亏待会学习的人大家好&#xff0c;我是yes。本来打算继续写消息队列的东西的&#xff0c;但是最近在带新同事&#xff0c;发现新同事对于锁这方面有一些误解&#xff0c;所以今天就来谈谈“锁”事和 Java 中的并发安全容器使用有哪些注意点。不过在这…

word无法启动转换器recovr32_迅捷PDF转换器3.0.1Mod会员版

特别声明所有软件皆来源于网上收集整理&#xff0c;仅供学习与交流技术,不得用作其它用途&#xff0c;如有侵犯你的权益&#xff0c;请联系我们,我们将于24小时内进行删除&#xff0c;谢谢你的配合&#xff01;1 迅捷PDF转换器作为一款专业实用的文件格式转换器&#xff0c;不仅…

python数据清理_Python-数据清理

在现实生活中&#xff0c;数据丢失始终是一个问题。诸如机器学习和数据挖掘之类的领域在模型预测的准确性方面面临着严重的问题&#xff0c;因为缺少值会导致数据质量较差。在这些领域中&#xff0c;缺失值处理是使模型更准确和有效的主要重点。什么时候以及为什么会丢失数据&a…

java 自动加载jar_JAVA 动态(手动)加载jar文件

//filePath 是jar的绝对路径URL url new URL("file:"filePath);//里面是一个url的数组&#xff0c;可以同时加载多个URLClassLoader loader new URLClassLoader( new URL[]{ url } );//根据类名加载指定类&#xff0c;例&#xff1a;Class class loader.loadClass…

项目管理知识体系指南_MP考前冲刺丨项目管理知识体系指南(PMBOK)串讲(11)...

第一单元&#xff1a;必考知识点08 项目质量管理(下)根本原因分析因果图因果图 Cause and Effect Diagram根本原因分析在被视为特殊偏差的不良结果与飞随机原因之间建立联系&#xff0c;基于这种联系&#xff0c;采取纠正措施&#xff0c;小区在控制图中呈现的特殊偏差。直方图…

nfa状态转换图正规式_0x02 从NFA到DFA

书接上文&#xff0c;上回说道NFA已经可以完全描述正则语言的全部内容。那么&#xff0c;我们在这一章探索一下一个比较复杂的正则表达式在用NFA做匹配的时候会有什么“不足“。NFA匹配的"不足"为了言之有物&#xff0c;不妨设要讨论的模式为d?(c(a|b)*)*(b|c)图1-1…

java filter教程_Java Web Filter 过滤器学习教程(推荐)

一、Filter简介Filter也称之为过滤器&#xff0c;它是Servlet技术中最激动人心的技术&#xff0c;WEB开发人员通过Filter技术&#xff0c;对web服务器管理的所有web资源&#xff1a;例如Jsp, Servlet, 静态图片文件或静态 html 文件等进行拦截&#xff0c;从而实现一些特殊的功…