在基础的算法中,我们比较常见的功能包含两个:排序、查找。在本文中我们将介绍十大常见的排序算法,并对其原理、过程进行分析。
排序算法可以分为:
内部排序
:数据记录在内存中进行排序。外部排序
:因排序的数据很大,一次不能容纳全部的排序记录,在排序过程中需要访问外存。常见的内部排序算法有:插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等,本文只涉及内部排序算法。
十种常见排序算法可以分类两大类别:
比较类排序
非比较类排序
比较类排序
:通过比较来决定元素间的相对次序,由于其时间复杂度不能突破 O(nlogn),因此也称为非线性时间比较类排序。在冒泡排序之类的排序中,问题规模为 n,又因为需要比较 n 次,所以平均时间复杂度为 O(n²)。在归并排序、快速排序之类的排序中,问题规模通过分治法消减为 logn 次,所以时间复杂度平均 O(nlogn)。比较类排序的优势是,适用于各种规模的数据,也不在乎数据的分布,都能进行排序。可以说,比较排序适用于一切需要排序的情况。
非比较排序
:不通过比较来决定元素间的相对次序,而是通过确定每个元素之前,应该有多少个元素来排序。由于它可以突破基于比较排序的时间下界,以线性时间运行,因此称为线性时间非比较类排序。 非比较排序只要确定每个元素之前的已有的元素个数即可,所有一次遍历即可解决。算法时间复杂度 O(n)。非比较排序时间复杂度低,但由于非比较排序需要占用空间来确定唯一位置。所以对数据规模和数据分布有一定的要求。
冒泡排序是一种简单的排序算法。它重复地遍历要排序的数列,一次比较两个元素,如果顺序错误就把它们交换过来。遍历的最终结果是会把最大的数冒泡地沉到最底下,最小的数会像鱼泡一样被冒泡地推到最上面来。
实现一:快慢指针
public static void BubbleSort(int[] nums) {
//建立快指针
int fast = 1;
//建立慢指针
int slow = 0;
//逐渐移动快慢指针进行比较
//这里i维护的是一个完成排序区的长度
for (int i = 0;i < nums.length;i++) {
//如果快指针没有触碰到完成排序区的边界则继续
while (fast < nums.length - i) {
//如果慢指针指向的元素更大就交换两元素
if (nums[slow] > nums[fast]) {
int temp = nums[slow];
nums[slow] = nums[fast];
nums[fast] = temp;
}
//无论是否交换快慢指针都要前进
fast++;
slow++;
}
//重置快慢指针
slow = 0;
fast = 1;
}
}
实现二:
/**
* 冒泡排序
* @param arr
* @return arr
*/
public static int[] bubbleSort(int[] arr) {
for (int i = 1; i < arr.length; i++) {
// Set a flag, if true, that means the loop has not been swapped,
// that is, the sequence has been ordered, the sorting has been completed.
boolean flag = true;
for (int j = 0; j < arr.length - i; j++) {
if (arr[j] > arr[j + 1]) {
int tmp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = tmp;
// Change flag
flag = false;
}
}
if (flag) {
break;
}
}
return arr;
}
选择排序是一种简单直观的排序算法,无论什么数据进去都是 O(n²) 的时间复杂度。所以用到它的时候,数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。它的工作原理:首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。以此类推,直到所有元素均排序完毕。
/**
* 选择排序
* @param arr
* @return arr
*/
public static int[] selectionSort(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
int minIndex = i;
for (int j = i + 1; j < arr.length; j++) {
if (arr[j] < arr[minIndex]) {
minIndex = j;
}
}
if (minIndex != i) {
int tmp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = tmp;
}
}
return arr;
}
插入排序是一种简单直观的排序算法。它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。插入排序在实现上,通常采用 in-place 排序(即只需用到 O(1) 的额外空间的排序),因而在从后向前扫描过程中,需要反复把已排序元素逐步向后挪位,为最新元素提供插入空间。
插入排序的代码实现虽然没有冒泡排序和选择排序那么简单粗暴,但它的原理应该是最容易理解的了,因为只要打过扑克牌的人都应该能够秒懂。插入排序是一种最简单直观的排序算法,它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。
插入排序和冒泡排序一样,也有一种优化算法,叫做拆半插入。
/**
* 插入排序
* @param nums
*/
public static void InsertionSort(int[] nums) {
//维护排序区,指向待比较元素,从索引为 1 的位置开始
for (int i = 1;i < nums.length;i++) {
//待插入的值
int compare = nums[i];
//反向遍历排序区
int j;
for ( j = i - 1;j >= 0;j--) {
if (compare > nums[j]) break;
//如果大于插入值就往后移一位
nums[j + 1] = nums[j];
}
//插入
nums[j + 1] = compare;
}
}
希尔排序是希尔 (Donald Shell) 于 1959 年提出的一种排序算法。希尔排序也是一种插入排序,它是简单插入排序经过改进之后的一个更高效的版本,也称为递减增量排序算法,同时该算法是冲破 O(n²) 的第一批算法之一。
希尔排序的基本思想是:先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序,待整个序列中的记录 “基本有序” 时,再对全体记录进行依次直接插入排序。
我们来看下希尔排序的基本步骤,在此我们选择增量 gap=length/2
,缩小增量继续以 gap = gap/2
的方式,这种增量选择我们可以用一个序列来表示,{n/2, (n/2)/2, ..., 1}
,称为增量序列。希尔排序的增量序列的选择与证明是个数学难题,我们选择的这个增量序列是比较常用的,也是希尔建议的增量,称为希尔增量
,但其实这个增量序列不是最优的。此处我们做示例使用希尔增量。
先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序,具体算法描述:
{t1, t2, …, tk}
,其中 (ti>tj, i<j, tk=1)
;k
,对序列进行 k
趟排序;t
,将待排序列分割成若干长度为 m
的子序列,分别对各子表进行直接插入排序。仅增量因子为 1 时,整个序列作为一个表来处理,表长度即为整个序列的长度。 /**
* 希尔排序
* @param nums
*/
public static void ShellSort(int[] nums) {
int gap = nums.length / 2;
while (gap > 0) {
//维护排序区,指向待比较元素
for (int i = gap;i < nums.length;i++) {
//待插入的值
int compare = nums[i];
//反向遍历排序区
int j;
for ( j = i - gap;j >= 0;j-= gap) {
if (compare > nums[j]) break;
//如果大于插入值就往后移一位
nums[j + gap] = nums[j];
}
//插入
nums[j + gap] = compare;
}
//改变希尔增量
gap /= 2;
}
}
归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法 (Divide and Conquer) 的一个非常典型的应用。归并排序是一种稳定的排序方法。将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使子序列段间有序。若将两个有序表合并成一个有序表,称为 2 - 路归并。
Tips:什么是分治法?
分治法是一种很重要的算法设计技巧。它的基本思想是:将一个复杂的问题分解成两个或更多相同或相关的子问题,直到变成基本问题可以直接求解,最后将子问题的解汇总为原问题的解。
分治法通常包含三个步骤:
- 分解:将原问题分解为若干个子问题。
- 解决:递归地解决各个子问题。如果子问题还可以分解,则继续分解,否则直接解决子问题。
- 合并:将各个子问题的解合并为原问题的解。
分治法的优点是可以大大减少时间复杂度和空间复杂度。但是分治法也存在一定的缺点,例如在分解和合并阶段会有一定的额外开销,并不一定所有问题都可以很好地分解等。
典型的应用分治法的算法有:归并排序、快速排序、线段树、阶乘实现等。
和选择排序一样,归并排序的性能不受输入数据的影响,但表现比选择排序好的多,因为始终都是 O(nlogn) 的时间复杂度。代价是需要额外的内存空间。
归并排序算法是一个递归过程,边界条件为当输入序列仅有一个元素时,直接返回,具体过程如下:
如果没有看懂这个过程可以参考下面的文章:
十大经典排序算法-归并排序算法详解
/**
* 归并排序
* @param nums
*/
public static int[] MergeSort(int[] nums) {
//分割点
int division = nums.length / 2;
if (division < 1) return nums;
//左数组
int[] left = MergeSort(Arrays.copyOfRange(nums, 0, division));
//右数组
int[] right = MergeSort(Arrays.copyOfRange(nums, division, nums.length));
//合并
return merge(left,right);
}
public static int[] merge(int[] left,int[] right){
//创建一个大数组容量为两数组长度之和
int[] box = new int[left.length + right.length];
//设置left数组的头指针
int leftPointer = 0;
//设置right数组的头指针
int rightPointer = 0;
//设置box的排序指针
int boxPointer = 0;
while (boxPointer < box.length) {
//左数组已经全部填充完了的情况
if (leftPointer >= left.length) {
while (rightPointer < right.length) {
box[boxPointer++] = right[rightPointer++];
}
break;
}
//右数组已经全部填充完了的情况
if (rightPointer >= right.length) {
while (leftPointer < left.length) {
box[boxPointer++] = left[leftPointer++];
}
break;
}
//left指针更大的情况
if (left[leftPointer] <= right[rightPointer]) {
box[boxPointer++] = left[leftPointer++];
}else {
//right指针更大的情况
box[boxPointer++] = right[rightPointer++];
}
}
return box;
}
快速排序
用到了分治思想
,同样的还有归并排序。乍看起来快速排序和归并排序非常相似,都是将问题变小,先排序子串,最后合并。不同的是快速排序在划分子问题的时候经过多一步处理,将划分的两组数据划分为一大一小,这样在最后合并的时候就不必像归并排序那样再进行比较。但也正因为如此,划分的不定性使得快速排序的时间复杂度并不稳定。
快速排序的基本思想:通过一趟排序将待排序列分隔成独立的两部分,其中一部分记录的元素均比另一部分的元素小,则可分别对这两部分子序列继续进行排序,以达到整个序列有序。
快速排序使用分治法open in new window(Divide and conquer)策略来把一个序列分为较小和较大的 2 个子序列,然后递回地排序两个子序列。具体算法描述如下:
/**
* 快速排序
* @param nums
*/
public static void quickSort(int[] nums,int left,int right) {
if (left >= right) return;
//记录一下左右边界
int l = left;int r = right;
//确定基准元素
int standard = nums[left];
//左右交换标志 0:left比较 1:right比较
int exchange = 1;
while (left != right) {
if (exchange++ % 2 == 1) {
if (nums[right] < standard) nums[left++] = nums[right];
else {
right--;
exchange++;
}
}else {
if (nums[left] > standard) nums[right--] = nums[left];
else {
left++;
exchange++;
}
}
}
nums[left] = standard;
quickSort(nums,l,left -1);
quickSort(nums,left + 1,r);
}
堆排序是指利用堆这种数据结构所设计的一种排序算法。堆是一个近似完全二叉树的结构,并同时满足堆的性质:即子结点的值总是小于(或者大于)它的父节点。
(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
,则整个排序过程完成。// Global variable that records the length of an array;
static int heapLen;
/**
* Swap the two elements of an array
* @param arr
* @param i
* @param j
*/
private static void swap(int[] arr, int i, int j) {
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
/**
* Build Max Heap
* @param arr
*/
private static void buildMaxHeap(int[] arr) {
for (int i = arr.length / 2 - 1; i >= 0; i--) {
heapify(arr, i);
}
}
/**
* Adjust it to the maximum heap
* @param arr
* @param i
*/
private static void heapify(int[] arr, int i) {
int left = 2 * i + 1;
int right = 2 * i + 2;
int largest = i;
if (right < heapLen && arr[right] > arr[largest]) {
largest = right;
}
if (left < heapLen && arr[left] > arr[largest]) {
largest = left;
}
if (largest != i) {
swap(arr, largest, i);
heapify(arr, largest);
}
}
/**
* Heap Sort
* @param arr
* @return
*/
public static int[] heapSort(int[] arr) {
// index at the end of the heap
heapLen = arr.length;
// build MaxHeap
buildMaxHeap(arr);
for (int i = arr.length - 1; i > 0; i--) {
// Move the top of the heap to the tail of the heap in turn
swap(arr, 0, i);
heapLen -= 1;
heapify(arr, 0);
}
return arr;
}
计数排序的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。 作为一种线性时间复杂度的排序,计数排序要求输入的数据必须是有确定范围的整数。
计数排序 (Counting sort) 是一种稳定的排序算法。计数排序使用一个额外的数组 C,其中第 i 个元素是待排序数组 A 中值等于 i 的元素的个数。然后根据数组 C 来将 A 中的元素排到正确的位置。它只能对整数进行排序。
方法一:
注意:
标准的计数排序算法无法直接对负数进行排序。这是因为它依赖于找出数组的最大值和最小值来确定计数数组的大小,而对负数进行排序的话,最大值和最小值可能会超出计数数组的索引范围。
但是可以通过一些改进,使得计数排序也能对负数进行排序,另外我们方法一中,我们在新建的计数数组中记录序列中每个元素的数量,如果序列有相同的元素,则在输出时,无法保证元素原来的排序,是一种不稳定的排序算法,可通过优化,将其改为稳定排序算法:
以序列83、80、88、90、88、86为例,首先填充计数数组
将计数数组从第二个元素开始,每个元素都加上前面所有元素的和,此时,计数数组的值表示的是元素在序列中的排序
接下来我们创建输出数组,长度与待排序序列一致,从后往前遍历待排序序列
首先,遍历最后一个元素86,我们在计数数组中找到86对应的值为3,则在输出数组的第3位(下标为2)填入86,计数数组86对应的值减1,既当前的86排序是3,下次遇到86则排序是2
接着,遍历下一个元素88,在计数数组中找到88对应的值为5,在输出数组的第5位(下标为4)填入88,计数数组88对应的值减1
然后,遍历下一个元素90,在计数数组中找到90对应的值为6,在输出数组的第6位(下标为5)填入90,计数数组90对应的值减1
继续遍历下一个元素88,在计数数组中找到88对应的值为4,在输出数组的第4位(下标为3)填入88,计数数组88对应的值减1
以此类推,将所有元素遍历完,填入输出数组
原序列第3位、第5位均为88,从上面的步骤我们可以看到,在第二步,第5位的88填入输出数组的第5位,在第四步,第3位的88填入输出数组的第4位,没有改变原序列相同元素的顺序
我们总结一下,方法二:
max-min+1
,其元素默认值都为 0;A[i]-min
作为 C 数组的索引,以 A[i] 的值在 A 中元素出现次数作为 C[A[i]-min]
的值;i>1
时 C[i] = C[i] + C[i-1]
;A[i]
,使用 A[i]
减去最小值 min 作为索引,在计数数组 C 中找到对应的值 C[A[i]-min]
,C[A[i]-min]-1
就是 A[i]
在结果数组 R 中的位置,做完上述这些操作,将 count[A[i]-min]
减小 1。方法一代码:
/**
* 计数排序
* @param nums
*/
public static void countingSort(int[] nums){
//首先找到最值
int maxValue = nums[0];
int minValue = nums[0];
for (int i = 0; i < nums.length; i++) {
if (nums[i] > maxValue) {
maxValue = nums[i];
} else if (nums[i] < minValue) {
minValue = nums[i];
}
}
//创建计数数组
int[] countNums = new int[maxValue - minValue + 1];
//开始计数
for (int num : nums) countNums[num - minValue]++;
//重新填充原数组
//填充指针
int insert = 0;
for (int i = 0; i < countNums.length; i++) {
for (int j = countNums[i];j > 0;j--) nums[insert++] = i + minValue;
}
}
方法二代码:
/**
* Gets the maximum and minimum values in the array
*
* @param arr
* @return
*/
private static int[] getMinAndMax(int[] arr) {
int maxValue = arr[0];
int minValue = arr[0];
for (int i = 0; i < arr.length; i++) {
if (arr[i] > maxValue) {
maxValue = arr[i];
} else if (arr[i] < minValue) {
minValue = arr[i];
}
}
return new int[] {
minValue, maxValue };
}
/**
* Counting Sort
*
* @param arr
* @return
*/
public static int[] countingSort(int[] arr) {
if (arr.length < 2) {
return arr;
}
int[] extremum = getMinAndMax(arr);
int minValue = extremum[0];
int maxValue = extremum[1];
int[] countArr = new int[maxValue - minValue + 1];
int[] result = new int[arr.length];
for (int i = 0; i < arr.length; i++) {
countArr[arr[i] - minValue] += 1;
}
for (int i = 1; i < countArr.length; i++) {
countArr[i] += countArr[i - 1];
}
for (int i = arr.length - 1; i >= 0; i--) {
int idx = countArr[arr[i] - minValue] - 1;
result[idx] = arr[i];
countArr[arr[i] - minValue] -= 1;
}
return result;
}
当输入的元素是 n 个 0 到 k 之间的整数时,它的运行时间是 O(n+k)
。计数排序不是比较排序,排序的速度快于任何比较排序算法。由于用来计数的数组 C 的长度取决于待排序数组中数据的范围(等于待排序数组的最大值与最小值的差加上 1),这使得计数排序对于数据范围很大的数组,需要大量额外内存空间。
桶排序是计数排序的升级版。它利用了函数的映射关系,高效与否的关键就在于这个映射函数的确定。为了使桶排序更加高效,我们需要做到这两点:
桶排序的工作的原理:假设输入数据服从均匀分布,将数据分到有限数量的桶里,每个桶再分别排序(有可能再使用别的排序算法或是以递归方式继续使用桶排序进行。
/**
* Gets the maximum and minimum values in the array
* @param arr
* @return
*/
private static int[] getMinAndMax(List<Integer> arr) {
int maxValue = arr.get(0);
int minValue = arr.get(0);
for (int i : arr) {
if (i > maxValue) {
maxValue = i;
} else if (i < minValue) {
minValue = i;
}
}
return new int[] {
minValue, maxValue };
}
/**
* Bucket Sort
* @param arr
* @return
*/
public static List<Integer> bucketSort(List<Integer> arr, int bucket_size) {
if (arr.size() < 2 || bucket_size == 0) {
return arr;
}
int[] extremum = getMinAndMax(arr);
int minValue = extremum[0];
int maxValue = extremum[1];
int bucket_cnt = (maxValue - minValue) / bucket_size + 1;
List<List<Integer>> buckets = new ArrayList<>();
for (int i = 0; i < bucket_cnt; i++) {
buckets.add(new ArrayList<Integer>());
}
for (int element : arr) {
int idx = (element - minValue) / bucket_size;
buckets.get(idx).add(element);
}
for (int i = 0; i < buckets.size(); i++) {
if (buckets.get(i).size() > 1) {
buckets.set(i, sort(buckets.get(i), bucket_size / 2));
}
}
ArrayList<Integer> result = new ArrayList<>();
for (List<Integer> bucket : buckets) {
for (int element : bucket) {
result.add(element);
}
}
return result;
}
基数排序也是非比较的排序算法,对元素中的每一位数字进行排序,从最低位开始排序,复杂度为 O(n×k)
,n
为数组长度,k
为数组中元素的最大的位数;
基数排序是按照低位先排序,然后收集;再按照高位排序,然后再收集;依次类推,直到最高位。有时候有些属性是有优先级顺序的,先按低优先级排序,再按高优先级排序。最后的次序就是高优先级高的在前,高优先级相同的低优先级高的在前。基数排序基于分别排序,分别收集,所以是稳定的。
必须使用稳定的计数排序算法,否则在同一位上出现相同元素时,则前一轮的排序就没有意义了
/**
* Radix Sort
*
* @param arr
* @return
*/
public static int[] radixSort(int[] arr) {
if (arr.length < 2) {
return arr;
}
int N = 1;
int maxValue = arr[0];
for (int element : arr) {
if (element > maxValue) {
maxValue = element;
}
}
while (maxValue / 10 != 0) {
maxValue = maxValue / 10;
N += 1;
}
for (int i = 0; i < N; i++) {
List<List<Integer>> radix = new ArrayList<>();
for (int k = 0; k < 10; k++) {
radix.add(new ArrayList<Integer>());
}
for (int element : arr) {
int idx = (element / (int) Math.pow(10, i)) % 10;
radix.get(idx).add(element);
}
int idx = 0;
for (List<Integer> l : radix) {
for (int n : l) {
arr[idx++] = n;
}
}
}
return arr;
}
这些排序算法的使用场景如下:
所以具体使用哪种排序算法,需要根据数据量的大小,稳定性的要求,数据的分布特点以及其他要素来综合判断选用。一般来说,对小数据量使用简单排序,大数据量使用时间复杂度低的稳定排序,特殊数据使用对应分布的排序。
对于百万以上级别的数据,推荐使用时间复杂度为O(nlogn)的排序,如快速排序,堆排序和归并排序。如果数据分布较集中的话,可以考虑线性时间的计数排序和桶排序。
基数排序 vs 计数排序 vs 桶排序
这三种排序算法都利用了桶的概念,但对桶的使用方法上有明显差异:
文章浏览阅读604次。在编程中,我们经常需要了解int32的取值范围以确保我们的程序在处理整数时不会溢出或出现意外行为。通过了解int32的取值范围,并在程序中进行适当的范围检查,我们可以更好地处理整数数据,并避免潜在的溢出错误。请注意,这里只展示了C语言的示例,其他编程语言可能有类似的方法来确定整数类型的取值范围,并进行相应的范围检查。在不同的编程语言中,int32类型可能会有不同的名称,例如C语言中的"int",Java中的"int",Python中的"int"等。是否在int32的范围内,并输出相应的结果。_int32在c语言中
文章浏览阅读327次,点赞3次,收藏5次。要修改正常工单,一定要对原BAPI进行改造。使用该BAPI修改工单时,能正常出发增强推送等功能。_sap 修改工单组件bapi
文章浏览阅读212次。题目描述:给定一个正整数 N,试求有多少组连续正整数满足所有数字之和为 N?首先,刚开始读错题目了,以为是子集和就行,后来发现是连续子集;想到用子集树,但是超时了class Solution: def consecutiveNumbersSum(self, N: int) -> int: self.res = 0 nums = ..._leetcode qian 400 timu
文章浏览阅读1.5w次,点赞56次,收藏283次。STM32内存结构介绍和FreeRTOS内存分配技巧这是我第一次使用FreeRTOS构建STM32的项目,踩了好些坑,又发现了我缺乏对于操作系统的内存及其空间的分配的知识,故写下文档记录学习成果。文章最后要解决的问题是,如何恰当地分配FreeRTOS中的堆、任务栈的空间。但是在概念的理解上,也需要知道STM32内存的相关知识。所以首先大致介绍一下STM32的内存结构。STM32内存结构STM32的数据在物理上分别储存在RAM和Flash中。RAM可读可写,掉电清零。Flash可读可写,但是读写时间很_heap_size
文章浏览阅读493次。敏感度标记(Label) 对于主体和客体,DBMS为它们每个实例(值)指派一个敏感度标记(Label) 敏感度标记分成若干级别绝密(Top Secret,TS)机密(Secret,S)可信(Confidential,C)公开(Public,P)TS>=S>=C>=P主体的敏感度标记称为许可证级别(Clearance Level)客体的敏感度标记称为密级(Classification Level)规则:主体(操作者)的密级别=客体的密集时,可读可写。主体>客体_对删除sc表结构或删除sc表数据的操作进行审计
文章浏览阅读1.3k次。已知两个非降序链表序列S1与S2,设计函数构造出S1与S2的交集新链表S3。输入格式说明:输入分2行,分别在每行给出由若干个正整数构成的非降序序列,用-1表示序列的结尾(-1不属于这个序列)。数字用空格间隔。输出格式说明:在一行中输出两个输入序列的交集序列,数字间用空格分开,结尾不能有多余空格;若新链表为空,输出“NULL”。样例输入与输出:_有序链表的交集调用函数
文章浏览阅读2.9k次。当你找不到你想要的App、联络人、音乐……时,你可以向下轻扫屏幕,以获得搜索页面,只需输入该名称,然后点击来直接打开 6. 单手快速关 App 大家知道吗?5、快速静音 按住向下的降低调量键两秒钟,iPad就会快速变成静音模式 6、常用域名 在浏览器输入网址时,按住键盘上的〔.com〕键,就会跳出.net、.edu.、.hk、.tw等其他常用网域名可以选择 7、摇晃iPad撤销输入 文字输入错误时,只要摇晃iPad机身,就会跳出提示可以「撤销输入」,点击「撤销输入」即可重新输入文字。_ipad9右边两个键是什么
文章浏览阅读270次。Wireshark数据抓包分析——网络协议篇 Wireshark是眼下最受欢迎的抓包工具。它能够执行在Windows、Linux及MAC OS X操作系统中,并提供了友好的图形界面。同一时候,Wireshark提供功能强大的数据抓包功能。使用它。能够以各种方式抓取用户所须要的网络数据包。..._分析五条不同类型的wireshark抓包行分析是什么网络应用
文章浏览阅读4.1k次。GPS系统跟踪捕获算法_gps的ca码设计与相关verilog程序
文章浏览阅读81次。苹果今日向 Mac 电脑用户推送了 macOS 14 开发者预览版 Beta 3 更新。但是并未发现 macOS 14 Sonoma 的第三个开发者测试版的新功能,且更新日志和 Beta 2 类似。_mac os sonoma最新版本
文章浏览阅读270次。一.类(1).基础最简单的定义方式class Person{}log(new Person());//Person{}log(typeof Person);function标准写法class Person{ constructor(name = "zhangsan",age = "18"){ //私有属性 this.name = name; this.age = age; } //公有属性 _es6 类修饰 详解
文章浏览阅读335次。3.1 可变字符串和BigDecimal3.1.1 可变字符串由于我们的字符串,是不可变的。每次都要在 字符串池里 新建和共享。这样效率很低,而且占用空间大。我们的 Java 就开发了 可变字符串下面的两者,都比传统的 String 类型要快很多。① StringBuffer:JDK1.0提供的,效率低,线程安全。它是实现开辟一个缓冲区,然后操作的时候,直接在 缓冲区里进行操作。② StringBuilder:JDK5.0提供的,效率高,线程不安全3.1.2 StringBuffer①_java字符串和bigdecimal类