精华内容
下载资源
问答
  • Java数组去重排序从大到小

    千次阅读 2018-07-31 11:22:04
    Java小白的独立写出的第一个Java程序,虽然是很简单的程序,氮素我也花了很长的时间,写出来还是很开心的   ​ package arraySort; import java.util.Scanner; /* * 数组去重排序 */ public class arrayaa {...

    Java小白的独立写出的第一个Java程序,虽然是很简单的程序,氮素我也花了很长的时间,写出来还是很开心的

     

    ​
    package arraySort;
    
    import java.util.Scanner;
    
    /*
     * 数组去重排序
     */
    public class arrayaa {
    	public static void main(String[] args) {
    		int demoArray[];// 定义数组
    		int i, j, temp;
    		demoArray = new int[5];// 分配内存空间
    		/*
    		 * 或者在定义的同时分配空间 int demoArray[] = new int[5];
    		 */
    		// long total = 0;
    		int len = demoArray.length;// len为数组长度
    		System.out.print("请输入" + len + "个整数,以空格为分隔:");
    		Scanner sc = new Scanner(System.in);
    		for (i = 0; i < len; i++) {
    			demoArray[i] = sc.nextInt();
    		}
    		for (int x : demoArray) {
    			System.out.print(x + " ");
    		}
    		System.out.println(" ");
    		/*
    		 * 以下数组去重
    		 */
    		for (i = 0; i < len - 1; i++) {
    			for (j = i + 1; j < len; j++) {
    				if (demoArray[i] == demoArray[j]) {
    					demoArray[j] = demoArray[len - 1];
    					len--;
    				}
    			}
    		}
    		System.out.print("去重后:");
    		for (i = 0; i < len; i++) {
    			System.out.print(demoArray[i] + " ");
    		}
    		System.out.println(" ");
    		/*
    		 * 以下数组排序
    		 */
    		for (i = 0; i < len; i++)
    			for (j = len - 2; j >= i; j--) // 从后向前,排好序的放在数组前面 
    				if (demoArray[j] < demoArray[j + 1]) {
    					temp = demoArray[j];
    					demoArray[j] = demoArray[j + 1];
    					demoArray[j + 1] = temp;
    				} // 冒泡排序
    		/*
    		 * 数组输出
    		 */
    		System.out.print("去重排序后的数组:");
    		for (i = 0; i < len; i++) {
    			System.out.print(demoArray[i] + " ");
    		}
    		sc.close();
    	}
    }
    
    ​

     

    展开全文
  • Java从入门到精通07-排序 ...简单地说,排序就是把一组记录(元素)按照某个域的值的递增(由小到大)或递减(由大到小)的次序重新排列的过程。 排序分类:1、内部排序:交换式排序法、选...

    排序(Sorting)是将一群数据,依指定的顺序进行排列的过程。

    排序是数据处理中一种很重要的运算,同时也是很常用的运算,一般数据处理工作25%的时间都在排序。简单地说,排序就是把一组记录(元素)按照某个域的值的递增(由小到大)或递减(由大到小)的次序重新排列的过程。

    排序分类:
    1、内部排序:交换式排序法、选择式排序法和插入式排序法;
      交换式排序是运行数据值比较后,依判断规则对数据位置进行交换,以达到排序的目的,分以下两种:
      a、冒泡排序法(Bubble sort),通过对待排序序列从后向前(从下标较大的元素开始),依次比较相邻元素的排序码,若发现逆序则交换,使排序码较小的元素逐渐从后部移向前部,就像水底的气泡一样逐渐向上冒。
      例子如下: 

    class Bubble {
        public void sort(int arr[]) {
            int temp = 0;
            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]) {
                        //换位
                        temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                    }
                }
            }
        }
    }

      b、快速排序法(Quick sort)是对冒泡排序的一种改进。它的基本思想是:通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。

    class Quick {
        public void sort(int left, int right, int arr[]) {
            int l = left;
            int r = right;
            int pivot = arr[(left + right) / 2];
            int temp = 0;
            while (l < r) {
                while (arr[l] < pivot) l++;
                while (arr[r] > pivot) r--;
                if (l >= r) break;
                temp = arr[l];
                arr[l] = arr[r];
                arr[r] = temp;
                if (arr[l] == pivot) --r;
                if (arr[r] == pivot) ++l;
            }
            if (l == r) {
                l++;
                r--;
            }
            if (left < r) sort(left, r, arr);
            if (right > l) sort(l, right, arr);
        }
    }

      选择排序,是从待排序的数据中,按指定的规则选出某一元素,经过和其他元素重整,再依原则交换位置达到排序的目的。

      选择式排序分:
      ①选择排序法(Selection Sort)
      ②堆排序法(Heap Sort)

    class Select {
        public void sort(int arr[]) {
            int temp = 0;
            for (int j = 0; j < arr.length - 1; j++) {
                int min = arr[j];
                int minIndex = j;
                for (int k = j + 1; k < arr.length; k++) {
                    if (min > arr[k]) {
                        min = arr[k];
                        minIndex = k;
                    }
                }
                temp = arr[j];
                arr[j] = arr[minIndex];
                arr[minIndex] = temp;
            }
        }
    }

      插入排序法是对于欲排序的元素以插入的方式找寻该元素的适当位置,以达到排序的目的。分三种:
      ①插入排序法(Insertion sort),把n个待排序的元素看成一个有序表和一个无序表,开始时有序表中只包含一个元素,无序表中包含有n-1个元素,排序过程中每次从无序表中取出第一个元素,把它的排序码依次与有序表的排序码进行比较,将它插入到有序表中的适当位置,使之成为新的有序表。

    class Insertion {
        public void sort(int arr[]) {
            for(int i=1;i<arr.length;i++){
                int insertVal=arr[i];
                int index=i-1;
                while (index>0&&insertVal<arr[index]){
                    arr[index+1]=arr[index];
                    index--;
                }
                arr[index+1]=insertVal;
            }
        }
    }

      ②谢耳排序法(Shell sort)

      ③二叉树排序法(Binary-tree sort)

    2、外部排序:合并排序法、直接合并排序法;
      合并排序法(Merge sort)是外部排序最常用的排序方法,若数据量太大无法一次完全加载内存,可使用外部辅助内存来处理排序数据,主要应用在文件排序。

    posted on 2015-10-12 14:26 惊蝴蝶 阅读(...) 评论(...) 编辑 收藏

    转载于:https://www.cnblogs.com/alphastudio/p/4871569.html

    展开全文
  • 如hash冲突解决办法,常用排序算法的应用场景和空间/时间复杂度等 数据库,能看懂ER关系,熟悉数据库三范式,熟练常用SQL语句 可以掌握一点java网络编程方面的知识,对tcp/ip有初步的认识 学习servlet/jsp,...
    1. 基础
      主要看《java核心技术:卷一》的重点章节
      掌握java常用技术,io、多线程、反射、常用集合框架
      数据结构看一遍,作用至少要清楚。如hash冲突解决办法,常用排序算法的应用场景和空间/时间复杂度等
      数据库,能看懂ER关系,熟悉数据库三大范式,熟练常用SQL语句
      可以掌握一点java网络编程方面的知识,对tcp/ip有初步的认识
      学习servlet/jsp,至少能写简单的图书管理系统,熟悉核心api
      了解前后端交互方式,ajax、json/xml至少知道,会使用jquery,html,css,js最好
    2. 提高
      学习后端框架,SpringMVC/Struts2、Mybatis、Spring,熟悉MVC模式,知道三层架构及每一层之间的关系
      会用chrome/firefox浏览器分析http请求,解决、定位问题。知道常用http状态码,了解TCP/IP,知道一次http请求发生了哪些事情
      学习设计模式,23种设计模式都需要了解一点,熟悉常用的如:单例,工厂,模板,适配器,代理,责任链,构造器,装饰器,迭代器,策略,命令,观察者,外观,享元。理解他们的好处,可以找找在其他框架哪些用了这些设计模式。
      可以适当的看一些源码,Spring的源码可以着重的看一下。tomcat可以从源码的角度看看tomcat的整体设计方案,一次请求tomcat如何处理,servlet在tomcat中的加载,编译过程。tomcat自定义的ClassLoader有什么作用。
      会设计数据库,多对多,一对多,迭代,会写复杂的SQL,了解SQL调优,会写存储过程,触发器。熟悉索引的使用,了解视图。去了解一些常用NOSQL,比如Redis/mongodb
      学习Linux,熟悉基本命令,学习一种脚本语言(shell/python)。会在linux下写脚本开发
    3. 深入
      算法,可以看看编程之美,算法导论。学习一些算法相关的知识
      深入java:理解JVM,JMM,Classloader,GC算法,GC收集器。学会定位OOM问题所在。
      源码分析,常用集合类如:Hashmap,Arraylist,linkedList,HashSet,ConcurrentHashmap等的源码分析,要非常熟悉java集合框架设计。最好能够分析一种框架源码,比如Spring
      深入数据库,理解至少两种数据库引擎(Inndb/Mysiam)的差异性,熟悉索引的内部数据结构,熟悉常见的索引方式(Btree,hash),和索引类型(unique,full text,normal),会使用explain分析SQL语句,会优化SQL语句,熟悉一种NOSQL,知道内部实现原理(内部数据结构,在算法优化,内部机制),掌握分布式数据库的知识,分表,分库,分区,分布式事务等,可以学习一个数据库中间件(TDDL/COBAR)
      架构设计,看看大型高流量/高并发的网站设计(CDN,异步,前端优化),了解缓存(分布式memcached/常用本地缓存),搜索引擎(lucene/solr/elasticSearch),分布式(负载均衡/分布式数据库/分布式应用集群),消息队列(ActiveMQ/Rabbitmq)在大型网站中的作用
      还有一些其他的知识,如RPC框架,分布式服务架构,SOA,REST架构等等
      可以接触一些云计算方面的知识,如Hadoop/Storm/Spark等,要是再能接触一点机器学习就更棒啦(反正我是没有,听着就吓人,跑个kmeans算法都要弄死人
    展开全文
  • 思路首先在未排序序列中找到最小()元素,存放到排序序列的起始位置,然后,再剩余未排序元素中继续寻找最小()元素,然后放排序序列的末尾。以此类推,直到所有元素均排序完毕。时间复杂度最佳情况:T(n) =...

    思路

    首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。以此类推,直到所有元素均排序完毕。

    时间复杂度

    最佳情况:T(n) = O(n2) 最差情况:T(n) = O(n2) 平均情况:T(n) = O(n2)

    代码

    import java.util.Arrays;

    /**

    * 简单选择排序

    * @author remainsu

    * @version 1.0 2019-06-04

    */

    public class SelectionSort {

    /**

    * 排序方法

    * @param arr 待排序的数组

    * @return toString 方便输出

    */

    public static String selectionSort(int[] arr) {

    for(int i=0; i

    //最小数的索引

    int minIndex = i;

    for(int j=i; j

    //找到最小数,并记录最小数的索引

    if(arr[j] < arr[minIndex]) {

    minIndex = j;

    }

    }

    //交换符合条件的数

    int tmp = arr[i];

    arr[i] = arr[minIndex];

    arr[minIndex] = tmp;

    }

    return Arrays.toString(arr);

    }

    public static void main(String[] args) {

    int[] arr = {111, 3, 5, 52, 74, 312, 75, 3, 764, 3, 2111, 7, 31};

    System.out.println("排序后的数组:"+ selectionSort(arr));

    }

    }

    参考

    展开全文
  • 我刚刚学习到数组时候,第一次接触了冒泡排序,所谓冒泡排序就是一个高大上的称呼,他的实质就是把数组的元素按顺序(从大到小或者从小到大)根据程序员自己的设计。他的原理是一种交换法,从数组的开始的第一个元素,...
  • Java排序

    2019-04-27 12:25:49
    工具与关键技术:MyEclipse...从小到大 :this‐o ,从大到小:o‐this 下面这里:改进比较方法:先根据money排序,如果money一样,就根据number排序 omparable排序接口 是在类的内部实现 使用迭代器遍历输出列表数...
  • 1.术语说明稳定与不稳定:a在b前,若a=b,排序后a一定还在b前,这就说明稳定内外排序:基于内存排序,就是内排序时间复杂度:算法耗费的时间空间复杂度:耗费内存的大小2.算法分类下面详细介绍算法。1.冒泡排序这是...
  • java 排序

    2020-08-24 14:09:45
    冒泡排序算法:它重复地走访过要排序的元素列,依次比较两个相邻的元素,如果顺序(如从大到小、首字母从Z到A)错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换,也就是说该元素列已经...
  • Java-排序 【冒泡排序

    万次阅读 多人点赞 2020-12-21 18:20:32
    冒泡排序基本的思想是每次比较两个数,的沉下去,的冒起来 算法主要是比较相邻的两个元素,如果第一个比第二个,就交换他们两个。一直开始的一对比较最后的一对,直到最后 时间复杂度:O(n²) package...
  • Java-排序-选择排序

    2020-12-07 20:11:36
    第一次排序的数据元素中选出最小(或最大)的一个元素,存放在序列的起始位置,然后再剩余的未排序元素中寻找最小()元素,然后放排序的序列的末尾。以此类推,直到全部待排序的数据元素的个数为零。...
  • Java实现八大排序算法

    2020-03-03 21:49:38
    //将一个记录插入排序好的有序表中,从而得到一个新,记录数增1的有序表。即:先将序列的第1个记录看成是一个有序的子序列,然后第2个记录逐个进行插入,直至整个序列有序为止。 //时间复杂度:O(n^2) 空间...
  • 冒泡排序的基本思想是:对比相邻的元素值,如果满足条件就交换元素值,把较的元素值移动数组前面,把的元素值移动数组后面(也就是交换两个元素的位置),这样数组元素就像气泡一样底部上升顶部。...
  • 排序算法平均时间复杂度冒泡排序O(n2)选择排序O(n2)插入排序O(n2)希尔排序O(n1.5)快速排序O(N*logN)归并排序O(N*logN)堆排序O(N*logN)基数排序O(d(n+r))一. 冒泡排序(BubbleSort)基本思想:两个数比较大小,较的数...
  • 冒泡排序: 第一个数开始往后比若比后面的数则交换,依次两两比较直到把最大的数排最右边,称为第一趟冒泡排序,在重复上述过程即可。 时间复杂度O(N^2), 最好时间复杂度O(N^2),最差时间复杂度O(N^2),额外空间...
  • java 选择排序

    2019-06-20 18:41:00
    首先在未排序序列中找到最小()元素,存放到排序序列的起始位置,然后,再剩余未排序元素中继续寻找最小()元素,然后放排序序列的末尾。以此类推,直到所有元素均排序完毕。 时间复杂度 最佳情况:T...
  • 选择排序,每一次排序的数据元素中选出最小(或最大)的一个元素,存放在序列的起始位置,然后,再剩余未排序元素中继续寻找最小()元素,然后放排序序列的末尾。 /* 1.选择排序是一种原地排序 2....
  • 一般以最左边第一个元素作为基准值,数组最右边开始向左检索,当检索比基准数的值停下后基准数开始向右检索比基准数的值停下,交换这两个值之后再在交换这两值之间进行上述检索执行方式,直到左右检索...
  •  整个过程像气泡一样往上升,单向冒泡排序的基本思想是(假设由小到大排序):对于给定n个记录,第一个记录开始依次对相邻的两个记录进行比较,当前面的记录大于后面的记录时,交换位置,进行一轮比较和换位后,n...
  • 它的工作原理是:在未排序的序列中找到最小(最大)的元素,放在序列的起始位置,然后再剩余序列中继续寻找最小最大元素,放排序的元素末尾,以此类推,直到所有的元素都排序完毕; 原理很好理解,下面就来看...
  • 每次无序表中取出第一个元素,把它插入有序表的合适位置,使有序表仍然有序。 第一趟比较前两个数,然后把第二个数按大小插入有序表中; 第二趟把第三个数据与前两个数从前向后扫描,把第三个数按大小插入...
  • 基本思想:两个数比较大小,较的数下沉,较的数冒起来。 过程: 比较相邻的两个数据,如果第二个数,就交换位置。 后向前两两比较,一直比较最前两个数据。最终最小数被交换起始的位置,这样第一个最...
  • java冒泡排序

    2019-10-21 15:27:45
    顾名思义,就是进行排序排序也就分为由大到小、由小到大 算法原理 冒泡排序算法的原理如下: 1、比较相邻的元素。如果第一个比第二个大,就交换他们两个。 2、对每一对相邻元素做同样的工作,开始第一对到结尾的...
  • 临近的数字两两进行比较,按照从小到大或者从大到小的顺序进行交换, 这样一趟过去后,最大或最小的数字被交换到了最后一位, 然后再从头开始进行两两比较交换,直到倒数第二位时结束,因此冒泡排序需要n-1趟  复杂度: ...
  • 它的工作原理是:第一次排序的数据元素中选出最小(或最大)的一个元素,存放在序列的起始位置,然后再剩余的未排序元素中寻找最小()元素,然后放排序的序列的末尾。以此类推,直到全部待排序的数据...
  • JAVA选择排序代码

    2021-01-30 15:41:39
    * 然后再剩余的未排序元素中寻找最小()元素,然后放排序的序列的末尾。 * 以此类推,直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。 * <p> * 平均时间复杂度 最好情况 最...
  • java 排序算法

    2018-09-11 18:48:15
    基本思想:两个数比较大小,较的数下沉,较的数冒起来。 过程: 比较相邻的两个数据,如果第二个数,就交换位置。 后向前两两比较,一直比较最前两个数据。最终最小数被交换起始的位置,这样第一个最...
  • java选择排序优化

    2019-07-22 23:37:50
    选择排序工作原理:第一次排序的数据元素中选出最小(或最大)的一个元素,存放在序列的起始位置,然后再剩余的未排序元素中寻找最小()元素,然后放排序的序列的末尾。以此类推,直到全部待排序的...
  • 第一次排序的数据元素中选出最小(或最大)的一个元素,存放在序列的起始位置,然后再剩余的未排序元素中寻找最小()元素,然后放排序的序列的末尾。以此类推,直到全部待排序的数据元素的个数为零。...

空空如也

空空如也

1 2 3 4 5 ... 19
收藏数 364
精华内容 145
关键字:

java时间从大到小排序

java 订阅