精华内容
下载资源
问答
  • 490public class SortBench {public static void main(String args[]){Random rand = new Random(System.currentTimeMillis());for(int k = 100; k <= 1000; k += 100){//Keep track of timelong time = 0;...

    490

    public class SortBench {

    public static void main(String args[]){

    Random rand = new Random(System.currentTimeMillis());

    for(int k = 100; k <= 1000; k += 100)

    {

    //Keep track of time

    long time = 0;

    //Create new arrays each time

    int[] a = new int[k];

    int[] b = new int[k];

    int[] c = new int[k];

    int[] d = new int[k];

    int[] e = new int[k];

    //Insert random integers into the arrays

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

    {

    int range = Integer.MAX_VALUE;

    a[i] = rand.nextInt(range);

    b[i] = rand.nextInt(range);

    c[i] = rand.nextInt(range);

    d[i] = rand.nextInt(range);

    e[i] = rand.nextInt(range);

    }

    long start = System.nanoTime();

    insertionSort(a);

    long end = System.nanoTime();

    time += end-start;

    start = System.nanoTime();

    insertionSort(b);

    end = System.nanoTime();

    time += end-start;

    start = System.nanoTime();

    insertionSort(c);

    end = System.nanoTime();

    time += end-start;

    start = System.nanoTime();

    insertionSort(d);

    end = System.nanoTime();

    time += end-start;

    start = System.nanoTime();

    insertionSort(e);

    end = System.nanoTime();

    time += end-start;

    System.out.println((time/5)/1000);

    }

    }

    static void insertionSort(int[] a)

    {

    int key;

    int i;

    for(int j = 1; j < a.length; j++)

    {

    key = a[j];

    i = j - 1;

    while(i>=0 && a[i]>key)

    {

    a[i + 1] = a[i];

    i = i - 1;

    }

    a[i + 1] = key;

    }

    }

    }

    展开全文
  • 内容包括: 稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、...

    2.网上数据结构和算法的课程不少,但存在两个问题:

    1)授课方式单一,大多是照着代码念一遍,数据结构和算法本身就比较难理解,对基础好的学员来说,还好一点,对基础不好的学生来说,基本上就是听天书了

    2)说是讲数据结构和算法,但大多是挂羊头卖狗肉,算法讲的很少。 本课程针对上述问题,有针对性的进行了升级

    3)授课方式采用图解+算法游戏的方式,让课程生动有趣好理解

    4)系统多面的讲解了数据结构和算法, 除常用数据结构和算法外,还包括程序员常用10大算法:二分查找算法(非递归)、分治算法、动态规划算法、KMP算法、贪心算法、普里姆算法、克鲁斯卡尔算法、迪杰斯特拉算法、弗洛伊德算法、马踏棋盘算法。可以解决面试遇到的最短路径、最小生成树、最小连通图、动态规划等问题及衍生出的面试题,让你秒杀其他面试小伙伴

    3.如果你不想永远都是代码工人,就需要花时间来研究下数据结构和算法。

    教程内容:

    本教程是使用Java来讲解数据结构和算法,考虑到数据结构和算法较难,授课采用图解加算法游戏的方式。内容包括: 稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、选择排序、插入排序、快速排序、归并排序、希尔排序、基数排序(桶排序)、堆排序、排序速度分析、二分查找、插值查找、斐波那契查找、散列、哈希表、二叉树、二叉树与数组转换、二叉排序树(BST)、AVL树、线索二叉树、赫夫曼树、赫夫曼编码、多路查找树(B树B+树和B*树)、图、图的DFS算法和BFS、程序员常用10大算法、二分查找算法(非递归)、分治算法、动态规划算法、KMP算法、贪心算法、普里姆算法、克鲁斯卡尔算法、迪杰斯特拉算法、弗洛伊德算法马踏棋盘算法。

    学习目标:

    通过学习,学员能体验主流数据结构和算法的实现机制,开阔编程思路,提高优化程序的能力。

    展开全文
  • 归并排序 大体思路 先二分出左右二侧 左侧排好序 右侧排好序 ,申请一个与原数组相同长度的数组,和二个指针分别指向已排好序的左右数组起点位置index = 0 和index=mid+1 此时 如果左右二侧数组为{2,6,9,3,6,8} ...

    归并排序

    大体思路 先二分出左右二侧 左侧排好序 右侧排好序 ,申请一个与原数组相同长度的数组,和二个指针分别指向已排好序的左右数组起点位置index = 0 和index=mid+1
    此时 如果左右二侧数组为{2,6,9,3,6,8} 左侧为{2,6,9} 右侧为{3,6,8}

            {2,6,9,3,6,8}
             ↑     ↑
             0     mid+1 
      辅助数组  arrHelp
      当arr[0]>arr[mid+1]的时候 将右侧的arr[mid+1]放入辅助数组中数组中 且mid+1先右移动一位
      当arr[0]<arr[mid+1] 的时候 将左侧的arr[0]放入辅助数组中数组中 且指针为0的指针向右移动一位
      当arr[0]=arr[mid+1] 的时候 将右侧arr[0]放入辅助数组中数组中 移动指针为0的指针向右移动一位
      
      在二分的时候求出单个的也是这个步骤,所以改排序还是稳定排序。
    

    代码实现

    public static void process(int[] arr,int L,int R){
    1		if(L==R){
    2			return;
    		}
    3		int mid = L+((R-L)>>1);
    4		process(arr,L,mid);//f(0,0)
    5		process(arr,mid+1,R);//f(1,1)
    6		merge(arr,mid,L,R);
    
    	}
    	public static void merge(int[] arr ,int mid ,int L,int R){
    		int[] arrHelp = new int[R-L+1];
    		int i = 0;//操作数组下标
    		int leftSilde = L;
    		int rightSilde = mid+1;
    		//这里是
    		while(leftSilde <= mid && rightSilde<=R ){
    			arrHelp[i++] = arr[leftSilde] > arr[rightSilde]?arr[rightSilde++]:arr[leftSilde++];
    		}
    		while(leftSilde<=mid){//当rightSilde已经超过R的时候  则help数组剩下的值全在letfsidel到mid这里 全拷贝
    			arrHelp[i++] = arr[leftSilde++];
    		}
    		while(rightSilde<=R){//同上
    			arrHelp[i++] = arr[rightSilde++];
    		}
    		//当界限全超了的时候则help数组已经包括了需要的值
            for(int j=0;j<arrHelp.length;j++){
    			arr[L++]=arrHelp[j];
    		}
    	}
    

    系统执行流程说明 测试数组:{6,2,5,8}

    f(0,3) 记录l =0 ;r = 3 mid = 1 执行到4行
    f(0,1) 记录 l =0 ;r = 1 mid = 0 执行到4行
    f(0,0) 弹出执行f(1,1) 也弹出 这二个值没球用 只是为了切分
    此时的f(0,1)栈中还保留 L=0;R=1 mid=0 传入到merge(arr,mid,L,R);中
    int[] arrHelp = new int[R-L+1]; 构建数组arrHelp =new int[2];
    且使用上述二个指针移动的操作来摘取小的值优先存入arrhelp数组中,
    然后通过 for(int j=0;j<arrHelp.length;j++) 回写到arr原数组中,
    执行完毕之后 栈内部还有f(0,3)函数没有执行,l =0 ;r = 3 mid = 1 执行到第4行
    然后执行第5行 process(arr,mid+1,R); =f(2,3) 具体执行步骤同上
    执行完毕之后 开始执行第6行merge(arr,mid,L,R);

    递归主要应用了栈结构,类似于js中的闭包函数

    function closen(a){
    	return (a)=>{
    	  return a;
    	}
    }
    let fn1 = closen(4);
    let aguments = fn1();
    console.log(aguments)  依然打印出4
    
    

    时间复杂度的计算
    还是master公式
    O(T) = 2O(T/2)+O(N^1)
    O(N) = aT(N/b)+O(N^d)
    说明一下 O(N^1)是出去process1和process2之外的时间复杂度 这里主要在master函数中,由于遍历了整个数组 所以时间复杂度为O(N)
    log2^2 = 1 时间复杂度为 O(logN*N ^d) 0(lognN)

    展开全文
  • import java.util.Arrays; //包含Arrays import java.util.Random; public class HelloWorld { public static void main(String[] args){ // Scanner s = new Scanner(System.in); // System.out.println("请...
    import java.util.Arrays; //包含Arrays
    import java.util.Random;
    
    public class HelloWorld {
    	public static void main(String[] args){
    	//	Scanner s = new Scanner(System.in);
    	//	System.out.println("请输入一个数字");
    	//	int num = s.nextInt();
        //打印数组
    		int []a = {10,14,2,3,9,87} ;
    		sort(a);
    		System.out.println(Arrays.toString(a));
    		a = insertValue(a,15);
    		System.out.println(Arrays.toString(a));
    		int []b = {2,34,87,1,2,77,8,56,2} ;
    		insertsort(b);
    		System.out.println(Arrays.toString(b)) ;
    		/
    		//数组中自带的API排序接口
    		int []c = {11,20,8,48,45,23,14} ;
    		Arrays.sort(c);//调用sort方法,jdk自带,非常高效的算法
    		System.out.println(Arrays.toString(c)) ;
    		
    		int []d = new int[1000000];
    		for(int i = 0 ; i < d.length ;i++){
    			Random r = new Random();
    			d[i] = r.nextInt();//获取一个随机的整数
    		}
    		long start = System.currentTimeMillis() ;//获取当前的时间到1970开始时间相差的毫秒
    		Arrays.sort(d); //对随机产生数组的元素进行排序,性能最好,运行最快
    		//insertsort(d);
    		//sort(d)
    		long end = System.currentTimeMillis();
    		System.out.println(end-start);//计算当前排序花费的时间
    		
    		//二维数组
    		Two_array();
    	}
    	//选择排序算法
    	//跟三个数交换是同样的原理
    	public static void sort(int []a){
    		for(int i = 0 ; i < a.length - 1 ; i++){
    			for(int j = i + 1 ; j < a.length ; j++){
    				if(a[i] > a[j]){
    					int temp = a[i] ; 
    					a[i] = a[j] ; 
    					a[j] = temp ;
    				}
    			}
    		}
    	}
    	/*
    	 * a[0]和a[1]比较如果大则交换---->a[0]和a[1]中大的放入了a[1]
    	 * a[1]和a[2]比较如果大则交换---->a[0],a[1],[2]中大的放入了a[2]
    	 * a[2]和a[3]比较如果大则交换
    	 * .....
    	 * a[4]和a[5]比较如果大则交换---->最大的放入了a[5] ;
    	 * -------------------------------第一轮
    	 * a[0]和a[1],a[1]和a[2],a[2]和a[3],a[3]和a[4]------第二轮
    	 * 
    	 * ...最后一轮a[0]和a[1]比较
    	 */
    	//冒泡排序算法
    	public static void sort1(int []a){
    		for(int i = 0 ; i < a.length-1 ; i++){
    			for(int j = 0 ; j < a.length - 1 - i ; j++){
    				if(a[j] > a[j+1]){
    					int temp = a[j];
    					a[j] = a[j+1];
    					a[j+1] = temp ;
    				}
    			}
    		}
    	}
    	//插入一个数以后自动排序--->一个已经排好序的数组,插入一个新元素
    	public static int[] insertValue(int []a , int value){
    		//从最后一个元素开始和value进行比较,如果比value大,这些元素都后移
    		//一直到value大于数组的某个元素,那么说明value就应该放在这个元素之后
    		a = Arrays.copyOf(a, a.length+1);
    		//因为前面扩容了,最后一个元素为空,要最后一个元素的前一个才是
    		for(int i = a.length - 2 ; i >= 0 ; i--){
    			if(value < a[i])
    				a[i+1] = a[i] ; //后移动
    			else 
    				break ;
    			a[i+1] = value ;
    		}
    		return a ;
    	}
    	/**
    	 * a[0]作为基本量,拿出a[1]进行插入工作 a[0]和a[1]已经排好序了
    	 * a[0],a[1]作为基本量 拿出a[2]进行插入工作  a[0],a[1],a[2]已经排好序了
    	 * .....依次类推
    	 */
    	//插入排序
    	public static void insertsort(int []a){
    		int t , j; 
    		for(int i = 1 ; i < a.length ; i++){
    			t = a[i];
    			for(j = i-1 ; j >= 0 && t < a[j]; j--){
    				a[j+1] = a[j] ;
    			}
    		}
    	}
    	
    	public static void Two_array()
    	{
    		int [][] a = {
    				{1,2,3,4,5},
    				{6,7,8,9,10},
    				{5,9,7,8,3},
    		};
    		int [][]b = new int[][]{{1,2,3},{4,5,6}};
    		System.out.println(a.length);
    		/*
    		 * a中有三个一维数组
    		 * 第一个a[0]
    		 * ......a[1]
    		 * */
    		//二维数组中第二个一维数组的元素的长度
    		System.out.println(a[1].length);
    		//遍历第二个一维数组的长度
    		for(int i = 0 ; i < a[1].length ; i++){
    			System.out.print(a[1][i] + " ");
    		}
    		System.out.println();
    		/*遍历二维数组中所有的元素*/
    		for(int i = 0 ; i < a.length ;i++){
    			for(int j = 0 ; j < a[1].length ; j++){
    				System.out.print(a[i][j]+" ") ;
    			}
    			System.out.println();
    		}
    		
    	}
    }
    

    展开全文
  • 然后再继续拿交换后的第1位与后续位进行比较,直到第1位与后续所有位置都比较完毕,最后会发现第一轮冒泡排序的最终结果是把最小值放到了第1位; 第二轮冒泡排序:因为第一轮已经把最小值放到了第1位,则第二轮...
  • (当然前提是参与排序的数据量足够大)Java中有两种方式获取时间:1.使用Calendar类(包为java.util.Calendar)获取系统当前时间来进行执行时间的判断2.通过System.currentTimeMillis()或者System.nanoTime()方法获得当前...
  • 思路: 使用线性查找找到序列中值最小的数,标记它。 如果标记的数不是待排序序列的第一个数,将它和第一个数交换位置。 注意:交换完毕后标记数已经有序,不再属于...在待排序序列中重复1,2步,直到排序结束。 ...
  • Duration与Period相对应,Period用于处理日期,而Duration计算时间差还可以处理具体的时间,也是通过调用其静态的between方法,该方法为between(Temporal startInclusive,Temporal endExclusive),因此可以传入两个...
  • 思路: 从序列左侧开始比较相邻的两个数,把较大的数交换至右端。 从开始第一对到结尾的最后一对,重复以上操作。一轮比较完成。 注意:一轮比较完成后,最后的数...排序完成。 核心代码: int temp; for (...
  • 本文实例讲述了Java排序算法总结之冒泡排序。...冒泡排序是计算机的一种排序方法,它的时间复杂度为O(n^2),虽然不及堆排序、快速排序的O(nlogn,底数为2),但是有两个优点:1.“编程复杂度”很低,很容易写出...
  • 本文实例讲述了Java排序算法总结之冒泡排序。...冒泡排序是计算机的一种排序方法,它的时间复杂度为O(n^2),虽然不及堆排序、快速排序的O(nlogn,底数为2),但是有两个优点:1.“编程复杂度”很低,很容易写出代码;...
  • (当然前提是参与排序的数据量足够大)Java中有两种方式获取时间:1.使用Calendar类(包为java.util.Calendar)获取系统当前时间来进行执行时间的判断2.通过System.currentTimeMillis()或者System.nanoTime()方法获得当前...
  • java 计算方法执行时间

    千次阅读 2017-07-18 13:50:37
    用到了反射,也是对反射的简单回顾吧。package algorithm;import java.lang.reflect.Method;...public class Test { // 排序原始数据 private static final int[] NUMBERS = {49, 38, 65, 97, 76, 13, 2
  • java计算时间

    2014-03-04 16:17:33
    public static void main(String[] args) { long t1 = System.... // 排序前取得当前时间 try { Thread.currentThread().sleep(3160); } catch (Exception err) { } long t2 = Sy...
  • java 计算时间

    千次阅读 2010-12-27 19:04:00
    package test; import java.util.*; public class Test2 ...public static void main... //排序前取得当前时间 try { Thread.currentThread().sleep(3160); } catch(Exception err) { }
  • 时间复杂度和java十大排序的实现、横向对比 时间复杂度 简介 为了计算时间复杂度,我们通常会估计算法的操作单元数量,每个单元运行的时间都是相同的。因此,总运行时间和算法的操作单元数量最多相差一个常量系数。...
  • java插入排序

    2018-10-31 23:10:29
    基本思想  每一步将一个待排序的记录,按其顺序码大小插入当前面已经排序的字序列的合适位置,知道全部... 插入排序所需要的时间取决于输入中元素的初始顺序。 package wang.chunsen.sort; /** * 插入排序 ...
  • Java程序运行时间计算

    2017-11-21 17:41:53
    (当然前提是参与排序的数据量足够大) Java中有两种方式获取时间:1.使用Calendar类(包为java.util.Calendar)获取系统当前时间来进行执行时间的判断2.通过System.currentTimeMillis()或者System.na...
  • java排序

    千次阅读 2013-08-07 19:27:06
    (1) 循环计算每个关键字的桶映射函数,这个时间复杂度是O(N)。 (2) 利用先进的比较排序算法对每个桶内的所有数据进行排序,其时间复杂度为 ∑ O(Ni*logNi) 。其中Ni 为第i个桶的数据量。   很显然,第(2)...
  • Java冒泡排序

    2011-05-22 11:39:48
    冒泡排序,是指计算机的一种排序方法,它的时间复杂度为O(n^2),虽然不及堆排序、快速排序的O(nlogn,底数为2),但是有两个优点:1.“编程复杂度”很低,很容易写出代码;2.具有稳定性,这里的稳定性是指原序列...
  • 一、基本概念在计算机科学中,分治...任何一个可以用计算机求解的问题所需的计算时间都与其规模有关。问题的规模越小,越容易直接求解,解题所需的计算时间也越少。例如,对于n个元素的排序问题,当n=1时,不需任何...
  • java基本排序算法汇总

    2020-08-09 09:44:03
    排序算法 排序也称为排序算法,排序是将一组数据,依指定的顺序进行排序的过程。 一、排序算法的种类 1.内部排序 ...算法中执行语句随着n趋于无穷时计算需要的时间级别。 常数阶 O(1) 对数阶 O(log2

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 499
精华内容 199
关键字:

java计算排序时间

java 订阅