java排序算法大全_各种排序算法的分析及java实现

排序一直以来都是让我很头疼的事,以前上《数据结构》打酱油去了,整个学期下来才勉强能写出个冒泡排序。由于要找工作了,也知道排序算法的重要性(据说是面试必问的知识点),所以又花了点时间重新研究了一下。

排序大的分类可以分为两种:内排序和外排序。在排序过程中,全部记录存放在内存,则称为内排序,如果排序过程中需要使用外存,则称为外排序。下面讲的排序都是属于内排序。

内排序可以分为以下几类:

(1)、插入排序:直接插入排序、二分法插入排序、希尔排序。

(2)、选择排序:简单选择排序、堆排序。

(3)、交换排序:冒泡排序、快速排序。

外排序可以分为一下几类(既使用内部存储也使用外部存储,内存不够时建议使用):

(4)、归并排序

(5)、基数排序

稳定性:就是能保证排序前两个相等的数据其在序列中的先后位置顺序与排序后它们两个先后位置顺序相同。再简单具体一点,如果A i == A j,Ai 原来在 Aj 位置前,排序后 Ai  仍然是在 Aj 位置前。

不稳定:简单选择排序、快速排序、希尔排序、堆排序不是稳定的排序算法

稳定:冒泡排序、直接插入排序、二分法插入排序,归并排序和基数排序都是稳定的排序算法。

平均时间复杂度

O(n^2):直接插入排序,简单选择排序,冒泡排序。

在数据规模较小时(9W内),直接插入排序,简单选择排序差不多。当数据较大时,冒泡排序算法的时间代价最高。性能为O(n^2)的算法基本上是相邻元素进行比较,基本上都是稳定的。

O(nlogn):快速排序,归并排序,希尔排序,堆排序。

其中,快排是最好的, 其次是归并和希尔,堆排序在数据量很大时效果明显。

排序算法的选择

1.数据规模较小

(1)待排序列基本序的情况下,可以选择直接插入排序;

(2)对稳定性不作要求宜用简单选择排序,对稳定性有要求宜用插入或冒泡

2.数据规模不是很大

(1)完全可以用内存空间,序列杂乱无序,对稳定性没有要求,快速排序,此时要付出log(N)的额外空间。

(2)序列本身可能有序,对稳定性有要求,空间允许下,宜用归并排序

3.数据规模很大

(1)对稳定性有求,则可考虑归并排序。

(2)对稳定性没要求,宜用堆排序

4.序列初始基本有序(正序),宜用直接插入,冒泡

一、插入排序

•思想:每步将一个待排序的记录,按其顺序码大小插入到前面已经排序的字序列的合适位置,直到全部插入排序完为止。

•关键问题:在前面已经排好序的序列中找到合适的插入位置。

•方法:

–直接插入排序

–二分插入排序

–希尔排序

①直接插入排序(从后向前找到合适位置后插入)

1、基本思想:每步将一个待排序的记录,按其顺序码大小插入到前面已经排序的字序列的合适位置(从后向前找到合适位置后),直到全部插入排序完为止。

2、实例

998828785fbfb9c4660cafe20870055b.png

3、java实现

importjava.util.Scanner;public classMain {public static voidmain(String[] args) {//输入参数

Scanner in = newScanner(System.in);while(in.hasNext()) {

String inStr=in.nextLine();

String[] str= inStr.split(" ");int a[] = new int[str.length];for (int i = 0; i < a.length; i++) {

a[i]=Integer.parseInt(str[i]);

}//输出结果

int[] results =zhiJieChaRu(a);

StringBuffer result= newStringBuffer();for (int i = 0; i < results.length; i++) {

result.append(results[i]).append(",");

}//删除最后一个逗号

if (result.length() > 0) {

result.deleteCharAt(result.length()-1);

}

System.out.println(result);

}

}/*** 直接插入排序。

*@parama

*@return

*/

public static int[] zhiJieChaRu(int[] a) {//直接插入排序

for (int i = 1; i < a.length; i++) {//待插入元素

int temp =a[i];intj;for (j = i - 1; j >= 0; j--) {//将大于temp的往后移动一位

if (a[j] >temp) {

a[j+ 1] =a[j];

}else{break;

}

}

a[j+ 1] =temp;

}returna;

}

}

4、分析

直接插入排序是稳定的排序。

文件初态不同时,直接插入排序所耗费的时间有很大差异。若文件初态为正序,则每个待插入的记录只需要比较一次就能够找到合适的位置插入,故算法的时间复杂度为O(n),这时最好的情况。若初态为反序,则第i个待插入记录需要比较i+1次才能找到合适位置插入,故时间复杂度为O(n2),这时最坏的情况。

直接插入排序的平均时间复杂度为O(n2)。

②二分法插入排序(按二分法找到合适位置插入)

1、基本思想:二分法插入排序的思想和直接插入一样,只是找合适的插入位置的方式不同,这里是按二分法找到合适的位置,可以减少比较的次数。

2、实例

5fd2a1e44b035418f51820d03de5e793.png

3、java实现

importjava.util.Scanner;public classMain {public static voidmain(String[] args) {//输入参数

Scanner in = newScanner(System.in);while(in.hasNext()) {

String inStr=in.nextLine();

String[] str= inStr.split(" ");int a[] = new int[str.length];for (int i = 0; i < a.length; i++) {

a[i]=Integer.parseInt(str[i]);

}//调用方法得到数组

int[] results =erFenChaRu(a);//将数组转换成字符串输出

StringBuffer result = newStringBuffer();for (int i = 0; i < results.length; i++) {

result.append(results[i]).append(",");

}//删除最后一个逗号

if (result.length() > 0) {

result.deleteCharAt(result.length()- 1);

}

System.out.println(result);

}

}/*** 二分插入排序

*@parama

*@return

*/

public static int[] erFenChaRu(int[] a) {for (int i = 0; i < a.length; i++) {int temp =a[i];int left = 0;int right = i - 1;int mid = 0;while (left <=right) {

mid= (left + right) / 2;if (temp

right= mid - 1;

}else{

left= mid + 1;

}

}for (int j = i - 1; j >= left; j--) {

a[j+ 1] =a[j];

}if (left !=i) {

a[left]=temp;

}

}returna;

}

}

4、分析

当然,二分法插入排序也是稳定的。

二分插入排序的比较次数与待排序记录的初始状态无关,仅依赖于记录的个数。当n较大时,比直接插入排序的最大比较次数少得多。但大于直接插入排序的最小比较次数。算法的移动次数与直接插入排序算法的相同,最坏的情况为n2/2,最好的情况为n,平均移动次数为O(n2)。

③希尔排序

1、基本思想:先取一个小于n的整数d1作为第一个增量,把文件的全部记录分成d1个组。所有距离为d1的倍数的记录放在同一个组中。先在各组内进行直接插入排序;然后,取第二个增量d2

2、实例

4694773ea19a829f06ccc7fac1d8fae7.png

3、java实现

/*** 希尔排序。

*@parama

*@return

*/

public static int[] xiErSort(int[] a) {int d =a.length;while (true) {

d= d / 2;for (int x = 0; x < d; x++) {for (int i = x + d; i < a.length; i = i +d) {int temp =a[i];intj;for (j = i - d; j >= 0 && a[j] > temp; j = j -d) {

a[j+ d] =a[j];

}

a[j+ d] =temp;

}

}if (d == 1) {break;

}

}returna;

}

4、分析

我们知道一次插入排序是稳定的,但在不同的插入排序过程中,相同的元素可能在各自的插入排序中移动,最后其稳定性就会被打乱,所以希尔排序是不稳定的。

希尔排序的时间性能优于直接插入排序,原因如下:

(1)当文件初态基本有序时直接插入排序所需的比较和移动次数均较少。

(2)当n值较小时,n和n2的差别也较小,即直接插入排序的最好时间复杂度O(n)和最坏时间复杂度0(n2)差别不大。

(3)在希尔排序开始时增量较大,分组较多,每组的记录数目少,故各组内直接插入较快,后来增量di逐渐缩小,分组数逐渐减少,而各组的记录数目逐渐增多,但由于已经按di-1作为距离排过序,使文件较接近于有序状态,所以新的一趟排序过程也较快。

因此,希尔排序在效率上较直接插人排序有较大的改进。

希尔排序的平均时间复杂度为O(nlogn)。

二、选择排序

•思想:每趟从待排序的记录序列中选择关键字最小的记录放置到已排序表的最前位置,直到全部排完。

•关键问题:在剩余的待排序记录序列中找到最小关键码记录。

•方法:

–直接选择排序

–堆排序

①简单的选择排序

1、基本思想:在要排序的一组数中,选出最小的一个数与第一个位置的数交换;然后在剩下的数当中再找最小的与第二个位置的数交换,如此循环到倒数第二个数和最后一个数比较为止。

2、实例

a9a74822cc8ced52769120c482878d36.png

3、java实现

/*** 直接选择排序。

*@parama

*@return

*/

public static int[] zhiJieXuanZe(int[] a) {for (int i = 0; i < a.length; i++) {int min =a[i];int n = i; //最小数的索引

for (int j = i + 1; j < a.length; j++) {if (a[j] < min) { //找出最小的数

min =a[j];

n=j;

}

}

a[n]=a[i];

a[i]=min;

}returna;

}

4、分析

简单选择排序是不稳定的排序。

时间复杂度:T(n)=O(n2)。

②堆排序

1、基本思想:

堆排序是一种树形选择排序,是对直接选择排序的有效改进。

堆的定义下:具有n个元素的序列 (h1,h2,...,hn),当且仅当满足(hi>=h2i,hi>=2i+1)或(hi<=h2i,hi<=2i+1) (i=1,2,...,n/2)时称之为堆。在这里只讨论满足前者条件的堆。由堆的定义可以看出,堆顶元素(即第一个元素)必为最大项(大顶堆)。完全二 叉树可以很直观地表示堆的结构。堆顶为根,其它为左子树、右子树。

思想:初始时把要排序的数的序列看作是一棵顺序存储的二叉树,调整它们的存储序,使之成为一个 堆,这时堆的根节点的数最大。然后将根节点与堆的最后一个节点交换。然后对前面(n-1)个数重新调整使之成为堆。依此类推,直到只有两个节点的堆,并对 它们作交换,最后得到有n个节点的有序序列。从算法描述来看,堆排序需要两个过程,一是建立堆,二是堆顶与堆的最后一个元素交换位置。所以堆排序有两个函数组成。一是建堆的渗透函数,二是反复调用渗透函数实现排序的函数。

2、实例

初始序列:46,79,56,38,40,84

建堆:

eba8e2adf3f900ddbfa2c3755a46079d.png

交换,从堆中踢出最大数

c6ae227410e36a125fa4af0c4c1088bd.png

依次类推:最后堆中剩余的最后两个结点交换,踢出一个,排序完成。

3、java实现

/*** 堆排序

*@parama

*@return

*/

public static int[] heapSort(inta[]) {int arrayLength =a.length;//循环建堆

for (int i = 0; i < arrayLength - 1; i++) {//建堆

buildMaxHeap(a, arrayLength - 1 -i);//交换堆顶和最后一个元素

swap(a, 0, arrayLength - 1 -i);

}returna;

}//对data数组从0到lastIndex建大顶堆

public static void buildMaxHeap(int[] data, intlastIndex) {//从lastIndex处节点(最后一个节点)的父节点开始

for (int i = (lastIndex - 1) / 2; i >= 0; i--) {//k保存正在判断的节点

int k =i;//如果当前k节点的子节点存在

while (k * 2 + 1 <=lastIndex) {//k节点的左子节点的索引

int biggerIndex = 2 * k + 1;//如果biggerIndex小于lastIndex,即biggerIndex+1代表的k节点的右子节点存在

if (biggerIndex

if (data[biggerIndex] < data[biggerIndex + 1]) {//biggerIndex总是记录较大子节点的索引

biggerIndex++;

}

}//如果k节点的值小于其较大的子节点的值

if (data[k]

swap(data, k, biggerIndex);//将biggerIndex赋予k,开始while循环的下一次循环,重新保证k节点的值大于其左右子节点的值

k =biggerIndex;

}else{break;

}

}

}

}//交换

private static void swap(int[] data, int i, intj) {int tmp =data[i];

data[i]=data[j];

data[j]=tmp;

}

4、分析

堆排序也是一种不稳定的排序算法。

堆排序优于简单选择排序的原因:

直接选择排序中,为了从R[1..n]中选出关键字最小的记录,必须进行n-1次比较,然后在R[2..n]中选出关键字最小的记录,又需要做n-2次比较。事实上,后面的n-2次比较中,有许多比较可能在前面的n-1次比较中已经做过,但由于前一趟排序时未保留这些比较结果,所以后一趟排序时又重复执行了这些比较操作。

堆排序可通过树形结构保存部分比较结果,可减少比较次数。

堆排序的最坏时间复杂度为O(nlogn)。堆序的平均性能较接近于最坏性能。由于建初始堆所需的比较次数较多,所以堆排序不适宜于记录数较少的文件。

三、交换排序

①冒泡排序

1、基本思想:在要排序的一组数中,对当前还未排好序的范围内的全部数,自上而下对相邻的两个数依次进行比较和调整,让较大的数往下沉,较小的往上冒。即:每当两相邻的数比较后发现它们的排序与排序要求相反时,就将它们互换。

2、实例

928afef4bb6e3f7ebe67a15bd9ce17ab.png

3、java实现

/*** 冒泡排序。

*@parama

*@return

*/

public static int[] maoPaoSort(inta[]) {//冒泡排序

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

if(a[j]>a[j+1]){int temp =a[j];

a[j]= a[j+1];

a[j+1] =temp;

}

}

}returna;

}

4、分析

冒泡排序是一种稳定的排序方法。

•若文件初状为正序,则一趟起泡就可完成排序,排序码的比较次数为n-1,且没有记录移动,时间复杂度是O(n)

•若文件初态为逆序,则需要n-1趟起泡,每趟进行n-i次排序码的比较,且每次比较都移动三次,比较和移动次数均达到最大值∶O(n2)

•起泡排序平均时间复杂度为O(n2)

②快速排序

1、基本思想:选择一个基准元素,通常选择第一个元素或者最后一个元素,通过一趟扫描,将待排序列分成两部分,一部分比基准元素小,一部分大于等于基准元素,此时基准元素在其排好序后的正确位置,然后再用同样的方法递归地排序划分的两部分。

2、实例

f6d3a016e6f483127b2395aca7487fc1.png

3、java实现

/*** 快速排序。

*@parama

*@return

*/

public static int[] quick(int[] a) {

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

}public static void quickSort(int[] a, int low, inthigh) {if (low < high) { //如果不加这个判断递归会无法退出导致堆栈溢出异常

int middle =getMiddle(a, low, high);

quickSort(a,0, middle - 1);

quickSort(a, middle+ 1, high);

}

}public static int getMiddle(int[] a, int low, inthigh) {int temp = a[low];//基准元素

while (low

while (low < high && a[high] >=temp) {

high--;

}

a[low]=a[high];while (low < high && a[low] <=temp) {

low++;

}

a[high]=a[low];

}

a[low]=temp;returnlow;

}

4、分析

快速排序是不稳定的排序。

快速排序的时间复杂度为O(nlogn)。

当n较大时使用快排比较好,当序列基本有序时用快排反而不好。

四、归并排序

1、基本思想:归并(Merge)排序法是将两个(或两个以上)有序表合并成一个新的有序表,即把待排序序列分为若干个子序列,每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

2、实例

2c393a6a6ce02ed66946a69caad0c60d.png

3、java实现

/*** 归并排序。

*

*@parama

*@return

*/

public static int[] guiBingSort(int[] a) {

mergeSort(a,0, a.length-1);returna;

}public static void mergeSort(int[] a, int left, intright) {if (left

mergeSort(a, left, middle);//对右边进行递归

mergeSort(a, middle + 1, right);//合并

merge(a, left, middle, right);

}

}public static void merge(int[] a, int left, int middle, intright) {int[] tmpArr = new int[a.length];int mid = middle + 1; //右边的起始位置

int tmp =left;int third =left;while (left <= middle && mid <=right) {//从两个数组中选取较小的数放入中间数组

if (a[left] <=a[mid]) {

tmpArr[third++] = a[left++];

}else{

tmpArr[third++] = a[mid++];

}

}//将剩余的部分放入中间数组

while (left <=middle) {

tmpArr[third++] = a[left++];

}while (mid <=right) {

tmpArr[third++] = a[mid++];

}//将中间数组复制回原数组

while (tmp <=right) {

a[tmp]= tmpArr[tmp++];

}

}

4、分析

归并排序是稳定的排序方法。

归并排序的时间复杂度为O(nlogn)。

速度仅次于快速排序,为稳定排序算法,一般用于对总体无序,但是各子项相对有序的数列。

五、基数排序

1、基本思想:将所有待比较数值(正整数)统一为同样的数位长度,数位较短的数前面补零。然后,从最低位开始,依次进行一次排序。这样从最低位排序一直到最高位排序完成以后,数列就变成一个有序序列。

2、实例

2d34fa746fababdcf7c5f8b32973bbd2.png

3、java实现

public static int[] jiShuSort(int[] array) {//找到最大数,确定要排序几趟

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

max=array[i];

}

}//判断位数

int times = 0;while(max>0){

max= max/10;

times++;

}//建立十个队列

List queue = new ArrayList();for (int i = 0; i < 10; i++) {

ArrayList queue1= newArrayList();

queue.add(queue1);

}//进行times次分配和收集

for (int i = 0; i < times; i++) {//分配

for (int j = 0; j < array.length; j++) {int x = array[j]%(int)Math.pow(10, i+1)/(int)Math.pow(10, i);

ArrayList queue2=queue.get(x);

queue2.add(array[j]);

queue.set(x,queue2);

}//收集

int count = 0;for (int j = 0; j < 10; j++) {while(queue.get(j).size()>0){

ArrayList queue3 =queue.get(j);

array[count]= queue3.get(0);

queue3.remove(0);

count++;

}

}

}returnarray;

}

4、分析

基数排序是稳定的排序算法。

基数排序的时间复杂度为O(d(n+r)),d为位数,r为基数。

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

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

相关文章

6/12 Sprint2 看板和燃尽图

转载于:https://www.cnblogs.com/queenjuan/p/5578551.html

转:PHP应用性能优化指南

程序员都喜欢最新的PHP 7&#xff0c;因为它使PHP成为执行最快的脚本语言之一&#xff08;参考PHP 7 vs HHVM 比较&#xff09;。但是保持最佳性能不仅需要快速执行代码&#xff0c;更需要我们知道影响性能的问题点&#xff0c;以及这些问题的解决方案。本文涵盖了保障PHP应用平…

java list集合增删改_Java中集合类list的增删改查

今天给大家带来的是Java中list类的使用&#xff0c;java.util 包提供了list类来对线性数据操作List接口是Collection接口的子接口&#xff0c;List有一个重要的实现类--ArrayList类&#xff0c;List中的元素是有序排列的而且可重复&#xff0c;所以被称为是序列List可以精确的控…

IIS6、IIS7和IIS8各版本的差别

一、写在前面 目前市面上所用的IIS版本估计都是>6.0的.所以我们主要以下面三个版本进行讲解 服务器版本IIS默认版本server20036.0server20087.0server20128.0二、IIS6的请求过程 由图可知,所有的请求会被服务器中的http.sys组件监听到,它会根据IIS中的 Metabase 查看基于该 …

Android Studio 插件的使用

1、GsonFormat https://github.com/zzz40500/GsonFormat 2、Android SelectorChapek http://blog.csdn.net/weifei554287925/article/details/41727541

安卓Java虚拟机大小_虚拟机为安卓流畅度背锅,是因为关系数十万程序员饭碗?...

导读&#xff1a;虚拟机相当于应用程序在不同运行环境中的翻译。说起谷歌安卓系统的“虚拟机”&#xff0c;很多人爱拿它和苹果iOS做比较&#xff0c;结果&#xff0c;安卓的很多短腿儿都让虚拟机背了锅&#xff0c;比如安卓手机运存容量是iPhone的两到三倍&#xff0c;流畅度却…

AppCompatActivity实现全屏的问题

前言&#xff1a;我的 Activity 是继承 BaseActivity , 而 BaseActivity 继承 AppCompatActivity 。 BaseActivity 的继承 /*** 应用程序的基类**/ public class BaseActivity extends AppCompatActivity {}HomeActivity 的继承 public class HomeActivity extends BaseActivit…

Cinder 组件详解 - 每天5分钟玩转 OpenStack(47)

本节我们将详细讲解 Cinder 的各个子服务。 cinder-api cinder-api 是整个 Cinder 组件的门户&#xff0c;所有 cinder 的请求都首先由 nova-api 处理。cinder-api 向外界暴露若干 HTTP REST API 接口。在 keystone 中我们可以查询 cinder-api 的 endponits。 客户端可以将请…

RedHat Enterprise Linux 6 配置Xmanager ,实现图形界面连接

我们经常见到的几种最为常用的windows下远程管理Linux服务器的方法&#xff0c;基本上都是利用SecureCRT,或者是PUTTY等客户端工具通过ssh服务来实现Windows下管理Linux服务器的&#xff0c;这些客户端工具几乎不需要什么配置&#xff0c;使用简单&#xff0c;但是它们都无法启…

Mac下配置iterm2 支持rz sz命令

转自:http://blog.csdn.net/citywolf4/article/details/49071679 1.安装lrzsz&#xff0c;使用brew命令&#xff1a;brew install lrzsz如果找不到lrzsz&#xff0c;使用以下命令更新brew库&#xff1a;brew update2.下载zmoden脚本在https://github.com/mmastrac/iterm2-zmode…

java中session对象登录_JavaWeb中Session对象的学习笔记

一、Session简单介绍在WEB开发中&#xff0c;服务器可以为每个用户浏览器创建一个会话对象(session对象)&#xff0c;注意&#xff1a;一个浏览器独占一个session对象(默认情况下)。因此&#xff0c;在需要保存用户数据时&#xff0c;服务器程序可以把用户数据写到用户浏览器独…

微信小程序 没有找到 node_modules 目录

在学习小程序云开发的时候&#xff0c;遇到一个问题&#xff0c;使用npm i --production 和npm i vant-weapp -S --production之后&#xff0c;在微信开发者工具中并没有node_modules文件夹 但是在根目录下生成了一个package-lock.json文件。也就是下载的依赖都已经装好了&…

Knockoutjs官网翻译系列(一)

最近马上要开始一个新项目的研发&#xff0c;作为第一次mvvm应用的尝试,我决定使用knockoutjs框架。作为学习的开始就从官网的Document翻译开始吧&#xff0c;这样会增加印象并加入自己的思考&#xff0c;说是翻译也并不是纯粹的翻译&#xff0c;会加入自己对知识点的思考以及自…

Django之静态文件配置

静态文件 了解静态文件配置之前&#xff0c;我们需要知道静态文件是什么&#xff1f; 静态文件其实指的是像css,js&#xff0c;img等一些被模板需要的文件。 如何在Django中配置我们的静态文件 1.建立static文件夹&#xff0c;将静态文件放在该目录下 2.在settings文件下配置如…

神奇的图像处理算法

http://blog.chinaunix.net/uid-23065002-id-4392043.html http://blog.csdn.net/k_shmily/article/details/51138154 几周前&#xff0c;我介绍了相似图片搜索。 这是利用数学算法&#xff0c;进行高难度图像处理的一个例子。事实上&#xff0c;图像处理的数学算法&#xff0c…

JavaWeb项目前端规范(采用命名空间使js深度解耦合)

没有规矩不成方圆&#xff0c;一个优秀的代码架构不仅易于开发和维护&#xff0c;而且是一门管理与执行的艺术。 这几年来经历了很多项目&#xff0c;对代码之间的强耦合及书写不规范&#xff0c;维护性差等问题深恶痛绝。在这里&#xff0c;通过仔细分析后&#xff0c;结合自己…

PCB genesis自制孔点 Font字体实现方法

一.先看genesis原有Font字体 在PCB工程CAM加孔点字体要求时,通常我们直接用Geneis软件给我们提供了2种孔点字体canned_57与canned_67,但此字体可能不能满足各个工厂个性化需求&#xff0c;比如&#xff1a;孔密度&#xff0c;孔间距&#xff0c;孔形状分布&#xff0c;如果有一…

Google 最新的 Fuchsia OS【科技讯息摘要】

转自&#xff1a;http://www.cnblogs.com/pied/p/5771782.html 就是看到篇报道&#xff0c;有点好奇&#xff0c;就去FQ挖了点东西回来。 我似乎已开始就抓到了重点&#xff0c;没错&#xff0c;就是 LK 。 LK 是 Travis Geiselbrecht 写的一个针对 ARM 的嵌入式操作系统&#…

pandas:根据行间差值进行数据合并

1. 问题描述 在处理用户上网数据时&#xff0c;用户的上网行为数据之间存在时间间隔&#xff0c;按照实际情况&#xff0c;若时间间隔小于阈值&#xff08;next_access_time_app&#xff09;&#xff0c;则可把这几条上网行为合并为一条行为数据&#xff1b;若时间间隔大于阈值…

java8的路径_什么是路径?

# 什么是路径&#xff1f;文件系统以某种形式的媒体(通常为一个或多个硬盘驱动器)存储和组织文件&#xff0c;使得它们可以容易地被检索。目前使用的大多数文件系统将文件存储在树形(或分层)结构中。在树的顶部是一个(或多个)根节点。在根节点下&#xff0c;有文件和目录(Micro…