精华内容
下载资源
问答
  • 初级练习
  • NULL 博文链接:https://baoyao.iteye.com/blog/2042130
  • 从小到大排序

    2015-06-16 16:36:39
    从小到大排序
  • Java利用冒泡排序法实现从小到大排序的功能。
  • //对34,5,22,-98,6,-76,0,-3这一组数从小到大排序 int arr[] = new int[]{34, 5, 22, -98, 6, -76, 0, -3}; //外层循环控制排序的次数 for (int i = 0; i < arr.length - 1; i++) { //内层循环读取数组的元素...

    冒泡排序

    适合新手,简单易懂,废话不多说,直接上JAVA代码:
    首先定义数组,定义两层循环
    int arr[] = new int[]{“这里填需要排序的数”};

    //对34,5,22,-98,6,-76,0,-3这一组数从小到大排序
    	int arr[] = new int[]{34, 5, 22, -98, 6, -76, 0, -3};
    //外层循环控制排序的次数
    	for (int i = 0; i < arr.length - 1; i++) {
    //内层循环读取数组的元素进行比较
    	for (int j = 0; j < arr.length - 1 - i; j++) {
    

    再来个if条件判断大小:

    //数组第一个元素与第二个元素相比较,如果第一个元素大
    //则交换位置,实现从小到大排序;如果从大到小,则是“<”符号
    	if (arr[j] > arr[j + 1]) {
    		  int temp = arr[j];
    		  arr[j] = arr[j + 1];
    		  arr[j + 1] = temp;
    	}
    

    最后输出排好序的数组:

    //循环遍历输出数组中的每一个元素
    	for (int i = 0; i < arr.length; i++) {
    		System.out.print(arr[i] + " ");
    	}
    

    完整代码:

    public class BubbleSort {
        public static void main(String[] args) {
            //对34,5,22,-98,6,-76,0,-3这一组数从小到大排序
            int arr[] = new int[]{34, 5, 22, -98, 6, -76, 0, -3};
            //外层循环控制排序的次数
            for (int i = 0; i < arr.length - 1; i++) {
                //内层循环读取数组的元素进行比较
                for (int j = 0; j < arr.length - 1 - i; j++) {
                    //数组第一个元素与第二个元素相比较,如果第一个元素大
                    //则交换位置,实现从小到大排序;如果从大到小,则是“<”符号
                    if (arr[j] > arr[j + 1]) {
                        int temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                    }
                }
            }
            //循环遍历输出数组中的每一个元素
            for (int i = 0; i < arr.length; i++) {
                System.out.print(arr[i] + " ");
            }
    
        }
    }
    
    

    运行结果:
    在这里插入图片描述
    似懂非懂???

    展开全文
  • //java类QuickSort public class QuickSort { //main方法(增加main方法是为了验证结果),main方法是java程序的入口方法,jvm在运行时首先查找main方法 public static void main(String[] args) { //实例化类new...
    //java类
    QuickSort 
    public class QuickSort {
        //main方法(增加main方法是为了验证结果),main方法是java程序的入口方法,jvm在运行时首先查找main方法
        public static void main(String[] args) {
            //实例化类new一个对象
            QuickSort str = new QuickSort();
            //qwrplkjhgffdsazcbnm
            String s="qwrplkjhgffdsazcbnm";
            //使用java封装好的方法把string转换成char数组
            char[] cs1 = s.toCharArray();
            //求字符数组的长度
            int sl = cs1.length-1;
              //使用new的str对象调用QuickSort类的排序方法并输出
            System.out.println(str.SortString(cs1,0,sl));
        }
        //字符串排序方法
        public String SortString(char [] cs,int low,int high){
                  //定义数组地位和高位角标变量
                    int l=low;
                    int h=high;
                    //将低位数组值赋给povit变量
                    char povit=cs[low];
             //以下while实现一次排序,第一次后前面是比cs[low]小的字符,后面都是比cs[low]大的字符
                 while(l<h)
                    {
                        //从后往前查找如果高位数组值大于povit 则高位角标数减一
                  while(l<h&&cs[h]>=povit)
                             h--;
                  //如果高位数组值小于povit&脚标l小于h则将l和h的数组值交换
                      if(l<h){
                    char temp=cs[h];
                        cs[h]=cs[l];
                         cs[l]=temp;
                         l++;
                        }
                        //高位比较交换一次后,从前往后查询,如果低位数组值小于povit则l加一
                  while(l<h&&cs[l]<=povit)
                        l++;
                      //如果低位数组值大于povit&脚本l<h则将l和h的数值值交换
                      if(l<h){
                    char temp=cs[h];
                     cs[h]=cs[l];
                      cs[l]=temp;
                       h--;
                        }
                      }
    
               //打印第一次排序交换的内容
                 System.out.print("l="+(l+1)+"h="+(h+1)+"povit="+povit+"\n");
            //低位分组递归实现快速比较
            if(l>low)SortString(cs,low,l-1);
                 //高位分组递归实现快速排序
            if(h<high)SortString(cs,l+1,high);
                //转换数据类型
                String ss = "";
                //将数组中的char字符拼接成字符串
                for (char c : cs) {
    //            System.out.println(c);
                    ss += c;
                }
    
                //返回字符串结果
                return ss;
    
        }
    
    
    }
    
    展开全文
  • 冒泡排序:从大到小 public class arrDome { public static void main(String[] args) { int[] num = {12,654,2,867,11,56,88,601}; /** * 数组八位故比七轮 */ // outer for(int i=0;i<num....

    冒泡排序:从小到大

    在这里插入图片描述

    public class arrDome {
    
    	public static void main(String[] args) {
    		int[] num = {12,654,2,867,11,56,88,601};
    		/**
    		 * 数组八位故比七轮
    		 */
    		// outer
    		for(int i=0;i<num.length-1;i++)
    		{
    			//inner
    			for(int j=0;j<num.length-1-i;j++)//j<num.length-1也行
    			{
    				if(num[j]>num[j+1])
    				{
    					int temp = num[j+1];
    					num[j+1] = num[j];
    					num[j] = temp;
    				}
    			}
    		}
    		for(int i=0;i<num.length;i++)
    			System.out.print(num[i]+"  ");
    	}
    }
    

    上述代码步骤:
        1、自定义一个int型数组,数组内部元素随机摆放。
        2、利用双层循环进行排序。
            第一层:利用变量i进行轮数比,由于num数组中有8位,故只用比7轮。第一次比较7次,第二次比较6次,第三次比较5次,以此类推 第七次比较一次。
            第二层:利用变量j开始比较num数组中的元素,看到代码可能会有疑问:为什么j<num.length-1-i与j<num.length-1都可以。j<num.length-1-i在数组中元素比较中编译运行的速度要高于j<num.length-1;因为第一轮过后到第二轮j<num.length-1-i就意味着inner(内层循环)只需要运行6次,以此类推,第七次只用运行1次;而对于j<num.length-1而言,无论第几轮inner(内层循环)都会运行7次。
        3、inner每次循环结束后都会借变量temp将较大的值赋给新的num数组。
        4、循环遍历num数组中的元素

    运行结果:

    2  11  12  56  88  601  654  867  
    
    展开全文
  • old子列表中数据可能会被覆盖,该算法具体操作如下: 3/8的Buffer Pool空间用于old子列表 列表的中点是new子列表的尾部与old子列表的头部之间的边界 当InnoDB将一个页面读入缓冲池时,它首先将它插入中间点(old子...

    InnoDB总体结构

    首先我们来看官网的一张图(图片来源于MySQL官网):

    image

    从上图中可以看出其主要分为两部分结构,一部分为内存中的结构(上图左边),一部分为磁盘中的结构(上图右边)

    内存结构

    InnoDB内存中的结构主要分为:Buffer Pool,Change Buffer和Log Buffer三部分。

    Buffer Pool

    Buffer Pool是InnoDB缓存表和索引的一块主内存区域,Buffer Pool允许直接从内存中处理经常使用的数据,从而加快处理速度,带来一定的性能提升。 但是缓存总有放满的时候,当缓存满了新来的数据怎么处理呢?Bufer Pool中采用的是LRU(least recently used,最近最少使用)算法,LRU列表中最前面存的是高频使用页,尾部放的是最少使用的页。当有新数据过来而缓存满了就会覆盖尾部数据。

    假如我们有一条查询语句非常大,返回的结果集直接就超过了Buffer Pool的大小,而这种语句使用场景又是极少的,可能查询这一次之后很久不会查询,而这一次就将缓存占满了,将一些热点数据全部覆盖了。为了避免这种情况发生,InnoDB对传统的LRU算法又做了改进,将LRU列表分拆分为2个,如下图(图片来源于MySQL官网):

    image

    该算法在new子列表中保留大量页面(5/8),old子列表包含较少使用的页面(3/8);old子列表中数据可能会被覆盖,该算法具体操作如下:

    • 3/8的Buffer Pool空间用于old子列表

    • 列表的中点是new子列表的尾部与old子列表的头部之间的边界

    • 当InnoDB将一个页面读入缓冲池时,它首先将它插入到中间点(old子列表的头)。读取的页面是由用户发起的操作(比如SQL查询)或InnoDB自动执行的预读操作

    • 访问old子列表中的页面使其“young”,并将其移动到new子列表的头部。如果读取的页是由用户发起的操作,那么就会立即进行第一次访问,并使页面处于young状态;如果读取的页是由预读发起的操作,那么第一次访问不会立即发生,而且可能直到覆盖都不会发生。

    • 操作数据时,Buffer Pool中未被访问的页会逐渐移到尾部,最终会被覆盖。

    默认情况下,查询读取的页面会立即移动到新的子列表中,这意味着它们在缓冲池中停留的时间更长。

    Change Buffer

    Change Buffer是一种特殊的缓存结构,用来缓存不在Buffer Pool中的辅助索引页, 支持insert, update,delete(DML)操作的缓存(注意,这个在MySQL5.5之前叫做Insert Buffer,仅支持insert操作的缓存)。当这些数据页被其他查询加载到Buffer Pool后,则会将数据进行merge到索引数据叶中。

    image

    InnoDB在进行DML操作非聚集非唯一索引时,会先判断要操作的数据页是不是在Buffer Pool中,如果不在就会先放到Change Buffer进行操作,然后再以一定的频率将数据和辅助索引数据页进行merge。这时候通常都能将多个操作合并到一次操作,减少了IO操作,尤其是辅助索引的操作大部分都是IO操作,可以大大提高DML性能。

    如果Change Buffer中存储了大量的数据,那么可能merge操作会需要消耗大量时间。

    为什么Change Buffer只能针对非聚集非唯一索引

    因为如果是主键索引或者唯一索引,需要判断数据是否唯一,这时候就需要去索引页中加载数据判断而不能仅仅只操作缓存。

    Change Buffer什么时候会merge

    总体来说,Change Buffer的merge操作发生在以下三种情况:

    • 辅助索引页被读取到Buffer Pool时。 当执行一条select语句时,会去检查当前数据页是否在Change Buffer中,如果在,就会把数据merge到索引页

    • 该辅助索引页没有可用空间时。 InnoDB内部会检测辅助索引页是否还有可用空间(至少有1/32页),如果检测到当前操作之后,当前索引页剩余空间不足1/32时,会进行一次强制merge操作

    • 后台线程Master Thread定时merge。 Master Thread是一个非常核心的后台线程,主要负责将缓冲池中的数据异步刷新到磁盘,保证数据的一致性。

    Adaptive Hash Index

    Adaptive Hash Index,自适应哈希索引。InnoDB引擎会监控对索引页的查询,如果发现建立哈希索引可以带来性能上的提升,就会建立哈希索引,这种称之为自适应哈希索引,InnoDB引擎不支持手动创建哈希索引。

    Log Buffer

    日志缓冲区是存储要写入磁盘日志文件的一块数据内存区域,大小由变量innodb_log_buffer_size 控制,默认大小为16MB(5.6版本是8MB):

    SHOW VARIABLES LIKE 'innodb_log_buffer_size';-- global级别,无session级别
    

    上文讲述update语句更新流程一文中,我们只提到了Buffer Pool用来代替缓存区,通过本文对内存结构的分析,实际上Buffer Pool中严格来说还有Change Buffer,Log Buffer和Adaptive Hash Index三个部分,DML操作会缓存在Change Buffer区域,而写redo log之前会先写入Log Buffer,所以Log Buffer又可以称之为redo Log Buffer。

    Log Buffer什么时候写入redo log

    一个大的Log Buffer空间大允许运行大型事务,而无需在事务提交之前将redo log数据写入磁盘。Log Buffer中的数据会定期刷新到磁盘,那么Log Buffer的数据又是如何写入磁盘的呢?Log Buffer数据flush到磁盘有三种方式,通过变量innodb_flush_log_at_trx_commit 控制,默认为1。 |value|描述|

    image

    • 当设置为0时,由于数据还在内存,所以崩溃后数据基本会被丢失

    • 当设置为2时,由于数据已经实时写到redo log了,如果磁盘文件没有被损坏,还是可以恢复的

    另外,Mast Thread默认1s进行一次刷盘操作,这个可以通过变量innodb_flush_log_at_timeout控制,默认1s。

    SHOW VARIABLES LIKE 'innodb_flush_log_at_timeout';-- global级别,无session级别
    
    

    磁盘结构

    InnoDB引擎的磁盘结构,从大的方面来说可以分为Tablespace和redo log两部分

    Tablespace

    Tablespace可以分为4大类,分别是:System Tablespace,File-Per-Table Tablespaces,General Tablespaces,Undo Tablespaces

    System Tablespace

    系统表空间中包括了 InnoDB data dictionary,doublewrite buffer, change buffer, undo logs 4个部分,默认情况下InnoDB存储引擎有一个共享表空间ibdata1,如果我们创建表没有指定表空间,则表和索引数据也会存储在这个文件当中,可以通过一个变量控制(后面会介绍)。

    ibdata1文件默认大小为12MB,可以通过变量innodb_data_file_path来控制,改变其大小的最好方式就是设置为自动扩展。

    innodb_data_file_path=ibdata1:12M:autoextend
    
    

    上面表示默认表空间ibdata1大小为12MB,支持自动扩展大小。

    当我们的文件达到一定的大小之后,比如达到了998MB,我们就可以另外开启一个表空间文件:

    innodb_data_home_dir=
    innodb_data_file_path=/ibdata/ibdata1:988M;/disk2/ibdata2:50M:autoextend
    
    

    关于上面的设置有3点需要注意:

    • innodb_data_home_dir如果不设置的话,那么就默认所有的表空间文件都在datadir目录下,而我们上面指定了2个不同路径,所以需要把innodb_data_home_dir设为空

    • autoextend这个属性,只能放在最后一个文件

    • 指定新的表空间文件名的时候,不能和现有表空间文件名一致,否则启动MySQL时会报错

    当然,表空间可以增大,自然也可以减少,但是一般我们都不会去设置减少,而且减少表空间也相对麻烦,在这里就不展开叙述了。

    InnoDB Data Dictionary

    InnoDB数据字典由内部系统表组成,其中包含用于跟踪对象(如表、索引和表列)的元数据。元数据在物理上位于InnoDB系统表空间中。由于历史原因,数据字典元数据在某种程度上与存储在InnoDB表元数据文件(.frm文件)中的信息重叠。

    Doublewrite Buffer

    Doublewrite Buffer,双写缓冲区,这个是InnoDB为了实现double write而设置的一块缓冲区,double write和上面的change buffer一个确保了可靠性,一个确保了性能的提升,是InnoDB中非常重要的两大特性。

    我们先来看下面一张图:

    image

    InnoDB默认页的大小是16KB,而操作系统是4KB,如果存储引擎正在写入页的数据到磁盘时发生了宕机,可能出现页只写了一部分的情况,比如只写了 4K,这种情况叫做部分写失效(partial page write),可能会导致数据丢失。

    可能有人会说,可以通过redo log来恢复,但是注意,redo log恢复数据有一个前提,那就是页没有损坏,如果页本身已经被损坏了,那么是没办法恢复的,所以为了确保万无一失,我们需要先保存一个页的副本,如果出现了上面的极端情况,可以用页的副本结合redo log来恢复数据,这就是double write技术。

    double write也是由两部分组成,一部分是内存中的double write buffer,大小为2MB,另一部分是物理磁盘上的共享表空间中的连续128个页,大小也是2MB,写入流程如下图(图片来源于《MySQL技术内幕 InnoDB存储引擎》):

    image

    double write机制会使得数据写入两次磁盘,但是其并不需要两倍的I/O开销或两倍的I/O操作。通过对操作系统的单个fsync()调用,数据以一个大的顺序块的形式写入到双写入缓冲区。

    在大多数情况下默认启用了doublewrite缓冲区。要禁用doublewrite缓冲区,可通过将变量innodb_doublewrite设置为0即可。

    总结

    就写到这了,也算是给这段时间的面试做一个总结,查漏补缺,祝自己好运吧,也希望正在求职或者打算跳槽的 程序员看到这个文章能有一点点帮助或收获,我就心满意足了。多思考,多问为什么。希望小伙伴们早点收到满意的offer! 越努力越幸运!

    金九银十已经过了,就目前国内的面试模式来讲,在面试前积极的准备面试,复习整个 Java 知识体系将变得非常重要,可以很负责任的说一句,复习准备的是否充分,将直接影响你入职的成功率。但很多小伙伴却苦于没有合适的资料来回顾整个 Java 知识体系,或者有的小伙伴可能都不知道该从哪里开始复习。我偶然得到一份整理的资料,不论是从整个 Java 知识体系,还是从面试的角度来看,都是一份含技术量很高的资料。

    感兴趣的朋友可以点击这里获得免费领取!

    三面蚂蚁核心金融部,Java开发岗(缓存+一致性哈希+分布式)

    论是从整个 Java 知识体系,还是从面试的角度来看,都是一份含技术量很高的资料。**

    感兴趣的朋友可以点击这里获得免费领取!

    [外链图片转存中…(img-r2T84RP7-1624945234187)]

    展开全文
  • java--将数组从小到大排序

    千次阅读 2020-05-14 20:48:22
    java方法——将数组从小到大排序 public static void sort(int[] arr) { for(int x=0;x<arr.length-1;x++) { for(int y=x+1;y<arr.length;y++) { if(arr[x]>arr[y]) { int temp =...
  • 从小到大: public static void main(String[] args) { System.out.println("输入你要排序的数据大小:"); Scanner input = new Scanner(System.in); int num = input.nextInt(); int[] numbers = new int[num]...
  • TreeMap<String, Object> params = new TreeMap<...//ASCII 从小到大排序 String obj = Joiner.on("&").withKeyValueSeparator("=").join(params);//编辑格式 keyA=valueA&keyB=valueB
  • 给定值的快速排序` import java.util.*; public class Program_kuaipai { public static void main(String[] args) { String str = "12 34 1 -5 9 100 55 0"; String[] numStrs = str.split(&...
  • JAVA---数组从小到大排序方法

    千次阅读 2020-11-26 16:56:50
    1.Arrays.sort()方法排序 public static void main(String[] args) { Scanner scan = new Scanner(System.in); System.out.println("输入数组个数:"); int n = scan.nextInt(); System.out.println("输入...
  • *Java常用排序算法从小到大) (1)##冒泡排序## 特点:效率低,实现简单。 思想:将序列中所有元素两两比较,将最大的放在最后面。将剩余序列中所有元素两两比较,将最大的放在最后面。重复第二步,直到只剩下一...
  • //输入10个整数,按照从小到大进行排序 public class HomeWork01 { public static void main(String[] args) { // 获取键盘数值 Scanner s = new Scanner(System.in); // 创建一个长度为10的整型数组 int...
  • 理解冒泡排序问题,有详细的步骤 重点: 从某一个值开始,只有当后面的大于此值.交换值, 附代码 public static void main(String[] args) { //1.首先随机生成20个随机数 int[] a=new int[30]; for(int i=0;i<a...
  • 定义一个int 类型的数组,并将其中的数从小到大的排列。 思路:从数组中拿出两个数来进行比较并保留最小的值来和数组中的其他值进行比较,得到最小值,并把他放到第一位(i 循环一次,j 进行了一次所有值的比对) ...
  • 编写程序实现经典的冒泡排序法 本程序中以初始化过的数组为例
  • ASCII排序的实现原理:先把字符串转换为一个的char型数组,接着使用冒泡排序把char型数组的每一个字符转化为int类型然后进行判断。(提示:本次使用的冒泡排序有个缺点,一旦有大量的数组进行排序,那么执行起来的...
  • 包涵Java基础、Java集合、JavaWeb、Java异常、OOP、IO与NIO、反射、注解、多线程、JVM、MySQL、MongoDB、Spring全家桶、计算机网络、分布式架构、Redis、Linux、git、前端、算法与数据结构、MyBatis、RocketMQ、...
  • Java冒泡排序(小到大)

    2020-07-18 14:35:58
    1: 冒泡排序概述 2: 冒泡排序图解 3:冒泡排序代码实现 public static void main(String[] args) { //定义一个数组 int[] arr = {56, 23, 43, 22, 22, 34}; System.out.println("排序前"+Arrays.toString(arr)); ...
  • Java冒泡排序算法

    万次阅读 多人点赞 2018-10-21 07:25:16
    对比相邻的元素值,如果满足条件就交换元素值,把较小的元素移动到数组的前面(从小到大排序),把大的元素移动到数组的后面,即交换两个元素的位置,这样较小的元素就像气泡一样从底部上升到顶部。 2.算法实现: ...
  • 快速排序:   快速排序由于排序效率在同为O(nlogn)的几种排序方法中效率较高,因此经常被采用,再加上快速...2.将比这个数(小)的数全放它的右边,小于或等于(大于或等于)它的数全放它的左边。 3.对左...
  • java通过输入数字然后将这些数字从小到大排序输出 可自定义你要排几个数字, package SortArray; import java.util.Scanner; public class SortArray { public static void main(String[] args) { // TODO ...
  • * 通过控制台输入数值,使用冒泡排序法将数值从小到大或者从大到小排序输出 */ import java.util.Scanner; public class sort_Bubble { public static void main(String[] args) { // 控制台输入十个成绩,...
  • java冒泡排序 public class Arrays_m { public static void main(String[] args) { int arr[]={12,15,46,78,989,65,23}; for(int i=0;i<arr.length;i++){ for(int j=0;j<arr.length-1;j++){ if...
  • 需要这份文档的朋友可以帮忙点个赞,点击下方神秘超链接,就可以免费获取了,还有小编准备的一份Java进阶学习路线图(Xmind)以及来年金三银四必备的一份《Java面试必备指南》 资料领取链接:Java进阶学习路线图...
  • public class Demo22 { public static void main(String[] args) { int [] arr= {24,11,65,9,55}; bubbleSort(arr); } public static void bubbleSort(int [] arr) { for(int j=0;...
  • 排序原理和示意图不多说了,网上各种有。总结下其最核心的思想: (1)自底向上,自右向左遍历建堆。这里的底不是指最后一个节点,而是最后一个非叶子节点。每个非叶子节点与其左儿子与右儿子(假如有的话)相比,...
  • 十大排序算法汇总-Java版(由小到大排序)1.冒泡排序 — O(N^2)2.选择排序 — O(N^2)3.插入排序 — O(N^2)4.归并排序 — O(NlogN)5.快速排序 — O(NlogN)6.堆排序 — O(NlogN)7.希尔排序 — O(NlogN)8.计数排序 — O...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 26,424
精华内容 10,569
关键字:

从小到大的java排序算法

java 订阅