精华内容
下载资源
问答
  • 由此,他想出了一种十分奇妙数字比较方法,给出两个数字xy,请你比较xyyx大小,如果前者大于后者,输出">",小于则输出"<",等于则输出"="。 输入描述: 两个...

    题目描述:

    牛牛很喜欢对数字进行比较,但是对于3 > 2这种非常睿智的比较不感兴趣。上了高中之后,学习了数字的幂,他十分喜欢这种数字表示方法,比如xy。
    由此,他想出了一种十分奇妙的数字比较方法,给出两个数字x和y,请你比较xy和yx的大小,如果前者大于后者,输出">",小于则输出"<",等于则输出"="。

    输入描述:

    两个数字x和y。
    满足1 <= x,y <= 10^9

    输出描述:

    一个字符,">","<“或者”="。

    示例1

    输入
    2 2

    输出
    =

    示例2

    输入
    2 4

    输出
    =

    分析:

    分析题意,如果直接比较幂函数,会导致内存溢出,无法正确比较幂函数大小。但是可以根据对数函数单调递增的特点,将幂函数的比较转换成对数函数大小的比较。
    将x^y和 y^x转换成ylogx和xlogy之间大小的比较。

    代码如下:

    import java.util.Scanner;
    
    public class Main {
    
    	public static void main(String[] args) throws Exception {
    		
    		Scanner scan = new Scanner(System.in);
    		double x = scan.nextLong();
    		double y = scan.nextLong();
    		System.out.println(comp(x,y));
    		
    	}
    
    	public static String comp(double num1, double num2) throws Exception {
    		
    		if((num1<1.0||num1>Math.pow(10, 9)) && (num2<1.0||num2>Math.pow(10, 9))){
    			throw new Exception("输入超出限制");
    		}
    		
    		double a = num2*Math.log(num1);
    		double b = num1*Math.log(num2);
    		
    		if(a==b){
    			return "=";
    		}	
    		else if(a>b){
    			return ">";
    		}else{
    			return "<";
    		}	
    	}
    }
    
    
    展开全文
  • java源码包---java 源码 大量 实例

    千次下载 热门讨论 2013-04-18 23:15:26
     基于JAVA的UDP服务器模型源代码,内含UDP服务器端模型UDP客户端模型两个小程序,向JAVA初学者演示UDP C/S结构原理。 简单聊天软件CS模式 2个目标文件 一个简单CS模式聊天软件,用socket实现,比较简单。 ...
  • 7.5.5 重载容易引发误解的两个地方——返回类型形参名 170 7.5.6 重载中最难点——参数匹配原则 171 7.6 使用类实例作为方法参数 172 7.6.1 超车方法:使用类实例做参数 172 7.6.2 调用这个方法 173 ...
  • 求职者就碰到家公司问了同样问题,第一次答 不出,回去没查,第二次又被问到,当然这是郁闷事情。  3.2 电话面试 电话面试主要是对简历上一些模糊信息确认、之前经历验证、 针对应聘职位简单技术...
  • 7.5.5 重载容易引发误解的两个地方——返回类型形参名 170 7.5.6 重载中最难点——参数匹配原则 171 7.6 使用类实例作为方法参数 172 7.6.1 超车方法:使用类实例做参数 172 7.6.2 调用这个方法 173 ...
  • 7.5.5 重载容易引发误解的两个地方——返回类型形参名 170 7.5.6 重载中最难点——参数匹配原则 171 7.6 使用类实例作为方法参数 172 7.6.1 超车方法:使用类实例做参数 172 7.6.2 调用这个方法 173 ...
  • 冒泡排序是java十大排序算法中的基础算法,了解其实现原理有必要...然后比较第2个数第3个数,将小数放前,大数放后,如此继续,直至比较最后两个数,将小数放前,大数放后。至此第一趟结束,将最大的数放到了最...

    冒泡排序是java十大排序算法中的基础算法,了解其实现原理很有必要,下面就来说说冒泡排序,其实现代码并不复杂,主要是弄清楚执行的流程,

    一、基本概念:

    依次比较相邻的两个数,将小数放在前面,大数放在后面。即在第一趟:首先比较第1个和第2个数,将小数放前,大数放后。然后比较第2个数和第3个数,将小数放前,大数放后,如此继续,直至比较最后两个数,将小数放前,大数放后。至此第一趟结束,将最大的数放到了最后。在第二趟:仍从第一对数开始比较(因为可能由于第2个数和第3个数的交换,使得第1个数不再小于第2个数),将小数放前,大数放后,一直比较到倒数第二个数(倒数第一位置上已经是最大的),第二趟结束,在倒数第二位置上得到一个新的最大数(其实在整个数列中是第二大的数)。如此下去,重复以上过程,直至最终完成排序。

    二、实现思路:

    用二重循环实现,外循环变量设为i,内循环变量设为j。假如有n个数需要进行排序,则外循环重复n-1次,内循环依次重复n-1,n-2,…,1次。每次进行比较的两个元素都是与内循环j有关的,它们可以分别用a[j]和a[j+1]标识,i的值依次为1,2,…,n-1,对于每一个i,j的值依次为0,1,2,…n-i 。

    设数组长度为N:
    1.比较相邻的前后二个数据,如果前面数据大于后面的数据,就将二个数据交换。
    2.这样对数组的第0个数据到N-1个数据进行一次遍历后,最大的一个数据就“沉”到数组第N-1个位置。
    3.N=N-1,如果N不为0就重复前面二步,否则排序完成。

    三、java代码实现:

    //排序方法
    public static int[] sortBubble(int[] arr){
    		if(arr == null || arr.length <= 1){
    			return null;
    		}
    		//外层循环,冒泡进行的轮数
    		for(int i=0;i<arr.length-1;i++){
    			//内层循环,指每一轮冒泡操作中的两两数据比较与数据交换
    			for(int j=0;j<arr.length-1-i;j++){
    				if(arr[j+1] < arr[j]){
    					SwapUtils.swap(arr, j, j+1);
    				}
    			}
    		}
    		
    		return arr;
    	}
    
    public static void main(String[] args) {
    		int[] arr = {11,18,43,32};
    		System.out.println(Arrays.toString(sortBubble(arr)));
    	}
    
    工具类代码:
    public static void swap(int[] arr, int i, int j) {
    		int temp = arr[i];
    		arr[i] = arr[j];
    		arr[j] = temp;
    	}
    
    

    运行主函数,可以看到已经对测试的数组中的数据进行了排序,

    四、性能分析:

    若记录序列的初始状态为"正序",则冒泡排序过程只需一趟排序,此过程最简单也是最好的一种情况,时间复杂度为O(n);反之,若记录序列的初始状态为"逆序",则需进行n(n-1)/2次比较和记录移动。因此冒泡排序总的时间复杂度为O(nn)。总体来看,冒泡排序的平均书剑复杂度为O(nn)

    展开全文
  • java大作业,课程设计

    2014-12-27 18:46:15
    用来完成作业。文档内容: 1 Java技术体系 1.1 Java语言 1.2 Java平台 ...现在要求用户输入两个数mn(m*1000),输出幸运数的个数。 例如: 用户输入: 1 20 程序输出: 5 格式:小四,1.5倍行距
  • 2个目标文件 摘要:Java源码,网络相关,UDP 基于JAVA的UDP服务器模型源代码,内含UDP服务器端模型UDP客户端模型两个小程序,向JAVA初学者演示UDP C/S结构原理。 简单聊天软件CS模式 2个目标文件 一个简单CS模式...
  • 2个目标文件 摘要:Java源码,网络相关,UDP 基于JAVA的UDP服务器模型源代码,内含UDP服务器端模型UDP客户端模型两个小程序,向JAVA初学者演示UDP C/S结构原理。 简单聊天软件CS模式 2个目标文件 一个简单CS模式...
  • 前面一篇文章已经讲到了三个比较简单的排序算法,现在准备说一下比较高级一点的两个算法,他们在数据量比较大的时候的效果还是明显的,我这里给出java的实现代码。 1.快速排序 过程:将待排序的第一个作为标志...

    前面一篇文章已经讲到了三个比较简单的排序算法,现在准备说一下比较高级一点的两个算法,他们在数据量比较大的时候的效果还是很明显的,我这里给出java的实现代码。

    1.快速排序

    过程:将待排序的第一个数作为标志temp,然后开始比较,i指向第一个数,j指向最后一个数,最开始j指向的数和temp比较,如果j比较大,j往左移动,否则i和j的数字交换,并且i开始想右边移动,知道i=j,完成一趟。一趟执行完了之后这个数就在正确的位置上面,即它不小于它左边的数,同时不大于它右边的数。

    同样有一个Test类获取比较的数组。

    public class Test {
        //通过scan一个一个读入数据,获取输入的数组
        public List Input() {
            List list = new ArrayList<>();
            Scanner scanner = new Scanner(System.in);
            int length = 0;//数组长度
            System.out.print("输入数组长度:");
            length = scanner.nextInt();
            System.out.print("输入排序数组:");
            int count = 0;
            while (length != count) {
                list.add(scanner.nextInt());
                count++;
            }
    
            System.out.print("输入的数组为:");
            for (int j = 0; j < list.size(); j++) {
                System.out.print(list.get(j) + " ");
            }
            return list;
        }
    
        public List getRandomInput() {
            List list = new ArrayList<>();
            System.out.print("输入随机数个数:");
            Scanner scanner = new Scanner(System.in);
            int n = scanner.nextInt();
            System.out.print("sort before:");
            boolean flag;
            int a;
            for (int i = 0; i < n; i++) {
                flag = true;
                //while循环是为了保证随机到的数组没有重复的,不然有时候如果范围比较小的下,重复比较高,这个并不影响,大家可以自行修改
                while (flag) {
                    a = new Random().nextInt(100);
                    if (i == 0) {
                        list.add(a);
                        System.out.print(a + " ");
                        flag = false;
                    } else {
                        for (int j = 0; j < list.size(); j++) {
                            //判断list中是否存在a,如果不存在 就加入到list中
                            if ((int) list.get(j) == a) {
                                flag =true;
                                break;
                            }
                            flag = false;
                        }
                        if(!flag){
                            list.add(a);
                            System.out.print(a + " ");
                        }
                    }
                }
            }
            System.out.print("\n");
            return list;
        }
    }

    快速排序java代码实现:

    public class QuickSort {
        public static void main(String[] args) {
            //获取输入需要排序的数组
            Test test = new Test();
            //List list = test.Input();
            List list = test.getRandomInput();
    
            int low = 0;
            int high = list.size() - 1;
            //递归排序
            long time = System.currentTimeMillis();
            QuickSort quickSort = new QuickSort();
            quickSort.Sort(list, low, high);     
        }
    
        public void Sort(List list, int low, int high) {
            int temp = (int) list.get(low);
            int l = low;
            int h = high;
            int k;
            if (l < h) {
                while (l < h) {
                    //从右往左,查看有没有数值比temp小,如果有小的,就停止右移,继续换左移
                    while (l < h && (int) list.get(h) >= temp) h--;
                    //找到了 比temp小的值,就交换位置,同时temp的值不变
                    k = (int) list.get(h);
                    list.set(h, list.get(l));
                    list.set(l, k);
                    //从左往右移动,查看有没有数值比temp大,有就交换位置,停止左移,继续换右移,直到l = h
                    while (l < h && temp >= (int) list.get(l)) l++;
                    k = (int) list.get(h);
                    list.set(h, list.get(l));
                    list.set(l, k);
                }
                System.out.print("sort after:");
                for (int i = 0; i < list.size(); i++) {
                    if(i == l){
                        System.out.print("{");
                        System.out.print(list.get(i));
                        System.out.print("} ");
                    }else System.out.print(list.get(i)+ " ");
                }
                System.out.println();
                if(l>low){
                    Sort(list, low, l-1);
                }
                if(l<high){
                    Sort(list, l+1 , high);
                }
            }
        }
    }
    每一趟排序好的我都用括号标志出来了,方便观察。

    测试结果:


    2.归并排序

    过程:归并排序其实就是先用递归将数组分成一个一个的子数组,将子数组排序好,然后在将两个子数组排序合并在一起。

    归并排序java代码实现:

    public class MergeSort {
    
        public static void main(String[] args) {
            MergeSort mergeSort = new MergeSort();
            Test test = new Test();
            List list = test.getRandomInput();
            //通过递归,局部排序
            mergeSort.sort(list, 0, list.size() - 1);
            System.out.print("sort after:");
            for (int i = 0; i < list.size(); i++) {
                System.out.print(list.get(i) + " ");
            }
        }
    
        public void sort(List list, int low, int high) {
            int mid = (low + high) / 2;
            List list1 = new ArrayList<>();
            if (low < high) {
                //左边
                sort(list, low, mid);
                //右边
                sort(list, mid + 1, high);
                //合并
                merge(list, low, high, list1);
            }
        }
    
        public void merge(List list, int low, int high, List list1) {
            int mid = (low + high) / 2;
            int i = low;
            int h = high;
            int j = mid + 1;
            int m = mid;
    
            while (i <= m && j <= h) {
                if ((int) list.get(i) < (int) list.get(j)) {
                    list1.add(list.get(i));
                    i++;
                } else {
                    list1.add(list.get(j));
                    j++;
                }
            }
    
            while (i <= m) {
                list1.add(list.get(i));
                i++;
            }
            while (j <= h) {
                list1.add(list.get(j));
                j++;
            }
    
            for (i = 0; i < list1.size(); i++)
                list.set(low+i, list1.get(i));
        }
    }

    测试结果:


    以上都是自己用IDEA写的代码,亲测可行。大家可以直接拷贝运行测试,如果大家想测试效率,可以将Test类中随机的范围编程10000+,然后生成5000+的数组,然后使用

    long time = System.currentTimeMillis();
     //排序代码快
     System.out.print(System.currentTimeMillis() - time);
    这样就可以打印时间了。

    如果大家有什么更好的代码实现,或者我的代码有什么问题,欢迎大家提意见

    展开全文
  • java源码包2

    千次下载 热门讨论 2013-04-20 11:28:17
     基于JAVA的UDP服务器模型源代码,内含UDP服务器端模型UDP客户端模型两个小程序,向JAVA初学者演示UDP C/S结构原理。 简单聊天软件CS模式 2个目标文件 一个简单CS模式聊天软件,用socket实现,比较简单。 ...
  • java源码包

    2015-12-01 16:29:37
     基于JAVA的UDP服务器模型源代码,内含UDP服务器端模型UDP客户端模型两个小程序,向JAVA初学者演示UDP C/S结构原理。 简单聊天软件CS模式 2个目标文件 一个简单CS模式聊天软件,用socket实现,比较简单。 ...
  • java源码包3

    千次下载 热门讨论 2013-04-20 11:30:13
     基于JAVA的UDP服务器模型源代码,内含UDP服务器端模型UDP客户端模型两个小程序,向JAVA初学者演示UDP C/S结构原理。 简单聊天软件CS模式 2个目标文件 一个简单CS模式聊天软件,用socket实现,比较简单。 ...
  • 并且这种一算一般被用作数量级比较大的数据当中,在大数据中有着重要的地位。 算法流程 下面是快速排序算法的流程:1、首先设定一分界值(一般都是取中间或者第一个数),通过该分界值将数组分成左右部分; 2...
        

    算法简述

    所谓快速排序算法是基于交换排序和递归思想的,它的速度的确如名字所示——快!并且这种一算一般被用作数量级比较大的数据当中,在大数据中有着很重要的地位。

    算法流程

    下面是快速排序算法的流程:
    1、首先设定一个分界值(一般都是取中间或者第一个数),通过该分界值将数组分成左右两部分; 2、将数组中大于等于分界值的数值放在分界值的右边,将数组中小于等于分界值的数值放在分界值的左边;
    3、然后左右两边的数组又可以按照这个方式进行独立排序;
    4、重复这个过程,可以看出这是一种递归的思想,当递归到最后,整个数组也就排序完成;

    实例讲解

    下面通过一个例子来讲解一下:对数组int[] arr = {34,25,65,33,16,78,43,22}进行快速排序

    1. 取33为分界值,用i,j两个引用从两端进行遍历,i从左边依次遍历直到找出比33大的数34(即arr[0]),j从右依次遍历直至找到比33小的数22(即arr[7])交换这两个数的位置:

    {22,25,65,33,16,78,43,34}

    1. 然后i向右移,j向左移进行遍历,经过一轮后:{22,25,16,33,65,78,43,34}
    2. 接下来通过递归调用,将左右数组进行排序。

    代码片段

    语言组织能力有限,直接上代码:

    /**
         * 排序算法之快速排序
         * 参数arr为需要排序的数组
         * 参数left为数组的起始下角标即0
         * 参数right为数组的最后下角标即arr.length-1
         */
        private void quickSort(int[] arr,int left,int right)
        {
            int f,t;
            int rtemp,ltemp;
            ltemp = left;
            rtemp = right;
            f = arr[(left+right)/2];
            //经过一轮排序,已经将数组分为左右两部分
            while(ltemp<rtemp)
            {
                while(arr[ltemp]<f)
                {
                    ++ltemp;
                }
                while(arr[rtemp]>f)
                {
                    --rtemp;
                }
                if(ltemp<=rtemp)
                {
                    t = arr[ltemp];
                    arr[ltemp] = arr[rtemp];
                    arr[rtemp] = t;
                    --rtemp;
                    ++ltemp;
                }
            }
            if(ltemp == rtemp)
            {
                ltemp++;
            }
            //进行递归排序
            if(left<rtemp)
            {
                quickSort(arr,left,ltemp-1);
            }
            if(ltemp<right)
            {
                quickSort(arr,rtemp+1,right);
            }
        }

    总结

    快速排序的精髓在于分治思想,分而治之,它的时间复杂度为O(nlog2n)。

    展开全文
  • HashtableHashMap采用的hash/rehash算法都大概一样,所以性能不会有很大的差异。 15、final, finally, finalize的区别。  final 用于声明属性,方法类,分别表示属性不可变,方法不可覆盖,类不可继承。 ...
  • Java开发人员团体中的热衷人土也不少,然而,J最近才开始从其影响更大的同属 品JEEJSE的阴影中走出其不成熟期。 JME在开发面向內存有限的移动终端(例如寻呼机、移动电话)的应用时,显得尤其实用。 因为它是建立在...
  • ES 在数据量很大的情况下(十亿级别)如何提高查询效率啊? ES 生产集群的部署架构是什么?每索引的数据量大概有多少?每索引大概有多少分片? 缓存 在项目中缓存是如何使用的?缓存如果使用不当会造成...
  • JAVA上百实例源码以及开源项目

    千次下载 热门讨论 2016-01-03 17:37:40
     基于JAVA的UDP服务器模型源代码,内含UDP服务器端模型UDP客户端模型两个小程序,向JAVA初学者演示UDP C/S结构原理。 简单聊天软件CS模式 2个目标文件 一个简单CS模式聊天软件,用socket实现,比较简单。 ...
  • 2个目标文件 摘要:Java源码,网络相关,UDP 基于JAVA的UDP服务器模型源代码,内含UDP服务器端模型UDP客户端模型两个小程序,向JAVA初学者演示UDP C/S结构原理。 简单聊天软件CS模式 2个目标文件 一个简单CS模式...
  • // 一个包含两个元素数组 $a[0] = "first"; $a[1] = "second"; $a[] = "third"; // 添加数组元素简单方法 // 现在$a[2]被赋值为"third" echo count($a); // 打印出3,因为该是...
  • java 面试题 总结

    2009-09-16 08:45:34
    HashtableHashMap采用的hash/rehash算法都大概一样,所以性能不会有很大的差异。 12、final, finally, finalize的区别。  final 用于声明属性,方法类,分别表示属性不可变,方法不可覆盖,类不可继承。 ...
  • JAVA 正则表达式

    热门讨论 2010-01-15 11:16:37
    默认情况下,这两个表达式仅仅匹配字符串开始结束。 Pattern.UNICODE_CASE (?u) 在这个模式下,如果你还启用了 CASE_INSENSITIVE 标志,那么它会对 Unicode 字符进行 小写不明感匹配。默认情况下,小写...
  • JAVA面试题最全集

    2010-03-13 13:09:10
    26.java的awtswing组件GUI设计关键 27.对于java认识 28.简单描述一下awt与swing区别。 29.简述java编程中事件处理模式。 30.你编写过applet吗?applet安全权限如何?试列举java application或者...
  • 69、两个对象值相同(x.equals(y) == true),但却可有不同hash code,这句话对不对? 48 70、TreeSet里面放对象,如果同时放入了父类子类实例对象,那比较时使用是父类compareTo方法,还是使用子类...
  • 然后比较第2个数第3个数,将小数放前,大数放后,如此继续,直至比较最后两个数,将小数放前,大数放后。至此第一趟结束,将最大的数放到了最后。在第二趟:仍从第一对数开始比较(因为可能由于第2个...
  • 石头就相当于是一比较的数,它进去水里面的其它数作比较,遇到比它(小)的就去它交换位置,然后(小)的数就继续往下走,去交换更(小)的数到水面上来。 这就是为什么要叫冒泡排序。 接下来,我将用代码...
  • 排序算法可以分为内部排序外部排序,内部排序是数据记录在内存中进行排序,而外部排序是因排序数据很大,一次不能容纳全部排序记录,在排序过程中需要访问外存。常见内部排序算法有:插入排序、希尔排序、...
  • 此外,还要考虑开发人员水平,学习了两年jsp开发,对于这个系统编写,我想完整的之需要两个月就可以写出程序,再花上几天调试,计划两个月左右就可以完成投入使用了。 我们掌握了数据库及其应用技术、...

空空如也

空空如也

1 2 3 4 5 6
收藏数 107
精华内容 42
关键字:

java比较两个很大的数之和

java 订阅