精华内容
下载资源
问答
  • Java对象数组排序

    千次阅读 2013-06-15 19:35:12
    数组排序:  1, 数组的元素  基本类型, 直接使用 Arrays.sort(arr) 即可 ;   2, 数组的元素 引用类型, 则需要让元素 具备可比性; 原理: 数组工具类Arrays 的 sort 方法, 比较元素的大小, 会调用...

    数组排序:

      1, 数组元素 是 基本类型, 直接使用 Arrays.sort(arr) 即可 ; 

      2, 数组的元素 是 引用类型, 则需要让元素 具备可比性;


    原理:

    数组工具类Arrays 的 sort 方法, 比较元素的大小, 会调用对象的 compareTo方法.

    因此, 只需要让 对象实现 Comparable 接口即可.


    实现:

    /** 人  */
    class Person implements Comparable<Person> {	// 使对象具备可比性
    	private int id;	// 编号
    	private String name;	// 名称
    
    	public Person(int id, String name) {
    		this.id = id;
    		this.name = name;
    	}
    	
    	@Override
    	public int compareTo(Person person) {	// 正数: 大; 负数: 小; 0: 等
    		// 比较 编号 ID
    		int result = this.id - person.id;
    		// 如果 编号相等, 则比较名称的 字典顺序
    		if (0 == result) {
    			result = this.name.compareTo(person.name);
    		}
    		return result;
    	}
    	
    	@Override
    	public String toString() {
    		return this.id + "-" + this.name;
    	}
    }
    

    验证:

    public class ObjectArraySort {
    	public static void main(String[] args) {
    		
    		Person[] persons = new Person[10];
    		
    		Random random = new Random();	// 产生 随机数
    			
    		// 给数组赋值
    		for (int i = 0; i < persons.length; i++) {
    			int nextInt = random.nextInt(100);	// 产生[0, 100]的随机整数
    			persons[i] = new Person(nextInt, "张" + nextInt);
    		}
    		
    		// 打印原始数组
    		System.out.println( Arrays.toString(persons) );
    		
    		// 排序
    		Arrays.sort(persons);
    		
    		// 打印排序后的数组
    		System.out.println( Arrays.toString(persons) );
    		
    	}
    
    }
    


         








    展开全文
  • 首先,我们要进行冒泡排序,我们需要一个排序对象,这里我们以int类型数组为例,这里先声明一个int类型数组,声明一个数组有两种方式,一种动态初始化,一种静态初始化,我们要对数组内的元素进行排序,所以...

    首先,我们要进行冒泡排序,我们需要一个排序对象,这里我们以int类型的数组为例,这里先声明一个int类型的数组,声明一个数组有两种方式,一种是动态初始化,一种是静态初始化,我们要对数组内的元素进行排序,所以这里我们采用静态初始化,int[] arr = {3,1,5,4,2};。
    **原理:**冒泡排序,顾名思义就是每次从数组的低端冒出一个最大值和最小值来实现对组数的降序或者升序排列,这里我们来实现对上面数组的升序排列,也就是从数组的底端到顶端每次冒出一个最小值来,那这个最小值是怎么得到的呢?就是数组最末尾(用当前位表示)的那个元素和它前一个比较,如果小就发生一个值的互换,当前位往上挪一位,再进行比较;如果比它大就不用发生值的互换,但当前位还是要往上挪一位,再进行比较。这样进行x次比较我们就可以得到第一个最小值,x次是几次呢?x=数组长度-1次。我们用一个循环表示怎样得到了这个最小值,那第二小值怎么办,所以说我们要在这个循环外边再用一个循环来控制它得轮次,外面的循环表示每一次找到一个最小值,那外面的循环需要执行几次呢?y=数组的长度-1,我们以上面那个数组为例,当外面的循环执行4次,其实数组已经排好了,所以说我们为了优化程序,把外面循环定义成数组长度-1次。那再有一个问题就是,当外面循环执行第二次的时候,也就是找出这个数组中第二小值得时候里面循环是不是只需要循环3次就可以找到第二小的值?答案是对的,第二次循环里层循环就会少一次,依次类推。
    代码展示:
    在这里插入图片描述
    大家可以把代码和上面文字说明联系起来看,这样可以更方便理解,理解了对数组的升序排列,相信叫大家在做一个降序排列也没什么问题了。

    展开全文
  • Java 第三课回顾 数组 3种初始化方式 长度length, 长度不可变 引用类型 -> 堆 访问, index: 0~length-1 内存图: 非常重要 方法 修饰词 返回值类型 名字(参数列表) {方法体} ...数组排序 1.冒泡排序 1.1 原理 • 比

    Java 第三课回顾

    数组
    3种初始化方式
    长度length, 长度不可变
    引用类型 -> 堆
    访问, index: 0~length-1
    内存图: 非常重要
    方法
    修饰词 返回值类型 名字(参数列表) {方法体}
    方法签名: 方法名+参数列表
    返回值: return
    调用: 执行方法体
    JVM
    方法区: 类加载后的信息
    栈: 临时变量\局部变量
    堆: 引用的数据

    方法参数
    基本数据类型, 就是传递的是值
    引用类型, 传递的是引用-地址

    Java第四课

    数组排序

    1.冒泡排序

    1.1 原理
    • 比较相邻的元素,将小的放到前面。
    冒泡排序举例:{8 , 2 , 3 , 7 , 1}的排序过程如下所示:
    ary={8,2,3,7,1}
    ary={2,8,3,7,1}
    ary={2,3,8,7,1}
    ary={2,3,7,8,1}
    ary={2,3,7,1|8}
    ary={2,3,7,1|8}
    ary={2,3,7,1|8}
    ary={2,3,1|7,8}
    ary={2,3,1|7,8}
    ary={2,1|3,7,8}
    ary={1,2,3,7,8}

    1.2 过程分析

    • i 代表次数
    • j 代表比较位置
    在这里插入图片描述
    备注:
    • i 的取值范围是: i = 0 ~ <ary.length-1
    • j 的取值范围是: j = 0 ~ <ary.length - i -1

    1.3 参考代码
    在这里插入图片描述
    2.选择排序

    2.1 选择排序原理

    • 将数组中每个元素与第一个元素比较,如果这个元素小于第一个元素,则交换这两个元素
    • 循环第 1 条规则,找出最小元素,放于第 1 个位置
    • 经过 n-1 轮比较完成排序
    简单而言,每轮都找到最小的放到前面。举例:{8 , 2 , 3 , 7 , 1}的排序过程如下所示:
    数组: ary={8 , 2 , 3 , 7 , 1}
    第 1 轮: ary={1 | 8 , 3 , 7 , 2}
    第 2 轮: ary={1 , 2 | 8 , 7 , 3}
    第 3 轮: ary={1 , 2 , 3 | 8 , 7}
    第 4 轮: ary={1 , 2 , 3 , 7 | 8}
    第 5 轮: ary={1 , 2 , 3 , 7 | 8}

    2.2 过程分析

    • i 代表第一个数据的位置
    • j 代表后部每一个数据的位置
    在这里插入图片描述
    备注:
    • i 的范围是: 0 ~ <ary.length - 1
    • j 的范围是: i+1 ~ <ary.length

    2.3 参考代码
    在这里插入图片描述
    3.插入排序

    3.1 插入排序原理

    • 将数组分为两部分, 将后部分的第一个逐一与前部分每一个元素比较,在合理位置插入
    • 插入排序算法效率要高于选择排序和冒泡排序
    插入排序举例:{8 , 2 , 3 , 7 , 1}的排序过程如下所示:
    第 1 步,假设第一个元素是已排序的 {8|2,3,7,1}
    第 2 步,用 2 和"|“之前的所有元素比较,并插入 {8|2,3,7,1}
    取出 2(temp=2)
    temp 和 8 比,比 8 小,将 2 的位置赋值为大数(ary[1]=8) {8|8,3,7,1}
    因为已到边界,直接赋值(ary[0]=2) {2,8|3,7,1}
    2 和 8 排序完成
    第 3 步,用 3 和”|“之前的所有元素比较,并插入 {2,8|3,7,1}
    取出 3(temp=3)
    temp 和 8 比,比 8 小,3 的位置赋值给大数(ary[2]=8) {2,8|8,7,1}
    temp 和 2 比,比 2 大,插入 2 后面 (ary[1]=3) {2,3,8|7,1}
    3、2、8 排序完成
    第 4 步,用 7 和”|“之前的所以元素比较,并插入 {2,3,8|7,1}
    取出 7(temp=7)
    temp 和 8 比,比 8 小,7 的位置赋值给大数(ary[3]=8) {2,3,8|8,1}
    temp 和 3 比,比 3 大,插入 3 后面(ary[2]=7) {2,3,7,8|1}
    7、2、3、8 排序完成
    第 5 步,用 1 和”|"之前的所以元素比较,幵插入 {2,3,7,8|1}
    取出 1(temp=1)
    temp 和 8 比,比 8 小,1 的位置赋值给大数 8 {2,3,7,8|8}
    temp 和 7 比,比 7 小,8 的位置赋值给大数 7 {2,3,7,7|8}
    temp 和 3 比,比 3 小,7 的位置赋值给大数 3 {2,3,3,7|8}
    temp 和 2 比,比 2 小,3 的位置赋值给大数 2 {2,2,3,7|8}
    到边界,赋值(ary[0]=1) {1,2,3,7,8|}
    1、2、3、7、8 排序完成

    3.2 过程分析

    • temp 代表取出待插入的元素
    • i 代表后组待插入元素的位置
    • j 代表前组每个元素的位置
    在这里插入图片描述
    备注:
    • i 的取值范围是: i=1 ~ <ary.length i++
    • j 的取值范围是: j= i-1 ~ >=0, j-- j–

    3.3 参考代码
    在这里插入图片描述
    经典写法
    在这里插入图片描述

    面向对象:OOP ( Object Oriented Programming)

    一切皆对象, Java操作的基本单位就是对象
    类/类型: 所有同种对象共同的特征和行为, 抽象出来成为类
    对象: 符合类的实例化个体
    例子 :
    学生特征: - 属性/成员变量
    姓名 性别 年龄 课程方向 学号…
    学生行为: - 成员方法
    吃饭 学习 说话 睡觉
    以上抽象出一个概念: 类 - 学生, 实体类
    对象: 符合类的特征的独立个体
    类和对象的关系: 先定义/声明 类, 然后再创建对象

    class: 类 ,类型 和int功能一样

    使用对象的步骤:

    1.必须先有类
    class Student {
        成员变量 name age
        成员方法
    }
    2.才能创建对象 - main - 方法 - 存在于类中
        Student s = new Student();
    3.有了对象, 对象包含了成员变量(name和age)和成员方法
        使用, 用 . 来调用的
    

    局部变量和成员变量的区别

    1.声明位置
        局部变量: 方法中
        成员变量: 类中
    2.初始化
        局部变量: 使用前必须初始化
        成员变量: 可以初始化, 如果没有初始化, 会有默认初始值
    3.个数
        局部变量: 声明个数
        成员变量: 由对象决定, 有几个对象就有几个成员变量
    4.内存中的位置
        第一次使用类[创建类的对象]之前, 会先将类进行加载
        局部变量: 方法栈中, 方法结束, 局部变量消失
        成员变量: 跟对象一起, 在堆中
    

    在这里插入图片描述

    方法重载

    方法名一样, 参数列表不一样的几个方法
    跟返回值类型无关
    举例: println print
    参数列表不一样的情况: 个数不同\类型不同\顺序不同
        (int a)
        (double d)
        (int a, int b)
        (int b, int a) ×
        (int a, float b)
        (float b, int a)
    

    构造方法/构造器

    目的: 为了给成员变量初始化
    特点: 方法名要和类名一致
    没有返回值类型
    构造方法可以重载
    当类中没有定义构造方法时, 编译器会默认添加无参构造方法

    this
    表示当前对象 - 这个对象
    哪个对象调用方法, 就表示哪个对象
    this可以调用自己的成员变量, 当成员变量和临时变量重名时, this不能省
    this也可以调用自己的成员方法, this可以省略
    this也可以调用自己的构造方法, this(参数), this不能省
    只能放在构造方法的第一行

    NullPointerException: 空指针异常
    产生原因: 调用了null空值得 成员变量 或者 方法

    引用类型的数组

    使用步骤:
     1.给数组初始化
        Student[] ss = new Student[5]; // 默认值都是null
     2.给数组元素初始化
        ss[0] = new Student();
        ss[1] = new Student();
        ...
    

    在这里插入图片描述

    展开全文
  • JavaScript 数组去重

    2021-01-10 02:39:09
    <div><h1>Why underscore <p>(觉得这部分眼熟的可以直接跳到...但是如果数组元素全部基础类型的 Number 值,键值对法应该最高效的! 方法五 (ES6) <p>ES6 部署了 Set 以及 Array...
  • 几个高级排序算法之一,具体原理可以参考这个视频:归并排序算法讲解。基本原理就是使用分治的思想,将数组不断二分,分割成单个元素,然后从单个元素开始两两合并,将两个有序的数组片段合并为一个新的有序片段。...

    1. 归并排序

    几个高级排序算法之一,具体原理可以参考这个视频:归并排序算法讲解。基本原理就是使用分治的思想,将数组不断二分,分割成单个元素,然后从单个元素开始两两合并,将两个有序的数组片段合并为一个新的有序片段。最后将整个数组归为有序。

    基本步骤:

    1. 将数组不断二分,分割成只包含单个元素的片段;
    2. 对分割之后的片段进行两两合并,将两个片段合并为一个有序的大片段,最底层是对于单个元素的片段进行合并,单个元素肯定有序,合并只需要根据两个元素的大小进行片段的重排。需要使用额外的内存空间保存两个子片段,然后在原数组上存放合并之后的片段。
    3. 从最小的片段开始,归并到整个数组有序

    由上面的过程,知道归并排序需要使用递归来完成,先分割,分割到最底层了,然后开始合并

    因此递归函数可以这样写:

    void MergeSort(vector<int>& nums, int start, int end, vector<int>& tmp) {
    	if (nums.empty() || start >= end)return;
    
    	int mid = start + (end - start) / 2;
    	//将待排序区间从中间分割开
    	MergeSort(nums, start, mid, tmp);
    	MergeSort(nums, mid + 1, end, tmp);
    	//将分割开的元素进行合并
    	Merge(nums, start, mid, end, tmp);
    }

    其中Merge()函数是核心,负责将两个片段进行合并。Merge()函数中需要先将两个片段拷贝一份,然后按顺序将两个片段的内容写到源地址上。

    /**实现具体归并的函数
    *
    *该函数将两个有序的数组进行合并,合并为一个有序的数组
    *传入参数:第一个已排序序列[start, mid];第二个已排序序列[mid+1, end];临时存储数组tmp
    */
    void Merge(vector<int>& nums, int start, int mid, int end, vector<int>& tmp) {
    	int firstIdx = start;
    	int secondIdx = mid + 1;
    	int numsIdx = start;
    	//先将两个已排序序列复制到tmp中
    	for (int i = start; i <= mid; ++i)tmp[i] = nums[i];
    	for (int i = mid + 1; i <= end; ++i)tmp[i] = nums[i];
    	//然后将tmp中的两段数组合并到nums中
    	while (numsIdx <= end) {
    		if (secondIdx > end)nums[numsIdx++] = tmp[firstIdx++];
    		else if (firstIdx > mid)nums[numsIdx++] = tmp[secondIdx++];
    		else {
    			if (tmp[firstIdx] <= tmp[secondIdx])nums[numsIdx++] = tmp[firstIdx++];
    			else nums[numsIdx++] = tmp[secondIdx++];
    		}
    	}
    }

    带输入的完整程序如下:

    // MergeSort_Vector.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
    //
    
    #include <iostream>
    #include <vector>
    using namespace std;
    
    void Sort(vector<int>& nums);
    void MergeSort(vector<int>& nums, int start, int end, vector<int>& tmp);
    void Merge(vector<int>& nums, int start, int mid, int end, vector<int>& tmp);
    void printArray(vector<int>& nums);
    
    int main()
    {
    	vector<int> a({ 5,6,1,8,3,4,9,7,2,3 });
    	//打印a的初始值
    	cout << "Initial value of vecotr a:";
    	printArray(a);
    
    	Sort(a);
    	//打印排序后的a
    	cout << "Sorted value of vecotr a:";
    	printArray(a);
    
    	return 0;
    }
    //通用接口
    void Sort(vector<int>& nums) {
    	vector<int> tmp(nums.size());
    	MergeSort(nums, 0, nums.size() - 1, tmp);
    }
    //归并排序的入口
    void MergeSort(vector<int>& nums, int start, int end, vector<int>& tmp) {
    	if (nums.empty() || start >= end)return;
    
    	int mid = start + (end - start) / 2;
    	//将待排序区间从中间分割开
    	MergeSort(nums, start, mid, tmp);
    	MergeSort(nums, mid + 1, end, tmp);
    	//将分割开的元素进行合并
    	Merge(nums, start, mid, end, tmp);
    }
    /**实现具体归并的函数
    *
    *该函数将两个有序的数组进行合并,合并为一个有序的数组
    *传入参数:第一个已排序序列[start, mid];第二个已排序序列[mid+1, end];临时存储数组tmp
    */
    void Merge(vector<int>& nums, int start, int mid, int end, vector<int>& tmp) {
    	int firstIdx = start;
    	int secondIdx = mid + 1;
    	int numsIdx = start;
    	//先将两个已排序序列复制到tmp中
    	for (int i = start; i <= mid; ++i)tmp[i] = nums[i];
    	for (int i = mid + 1; i <= end; ++i)tmp[i] = nums[i];
    	//然后将tmp中的两段数组合并到nums中
    	while (numsIdx <= end) {
    		if (secondIdx > end)nums[numsIdx++] = tmp[firstIdx++];
    		else if (firstIdx > mid)nums[numsIdx++] = tmp[secondIdx++];
    		else {
    			if (tmp[firstIdx] <= tmp[secondIdx])nums[numsIdx++] = tmp[firstIdx++];
    			else nums[numsIdx++] = tmp[secondIdx++];
    		}
    	}
    }
    //vector的打印函数
    void printArray(vector<int>& nums) {
    	for (auto it = nums.begin(); it != nums.end();++it)cout << *it << " ";
    	cout << endl;
    }
    
    
    

    2. 使用函数模板和函数对象实现通用的归并排序算法

    使用函数模板可以将上面的针对int类型的归并排序拓展到不同的数据类型,使用函数对象可以将自定义的比较函数传入归并排序的算法中,实现对自定义数据类型的排序。对于基本数据类型,可以使用STL中自带的lessgreater函数对象。

    对排序函数使用函数对象进行元素之间的比较,默认使用STL的less,即实现升序排序。

    完整代码如下:

    /**
     * @file MergeSort.cpp
     * @brief 归并排序的基本原理就是使用分治的思想,将数组不断二分,分割成单个元素,然后从单个元素开始两两合并,将两个有序的数组片段合并为一个新的有序片段。最后将整个数组归为有序。
       1. 将数组不断二分,分割成只包含单个元素的片段;
       2. 对分割之后的片段进行两两合并,将两个片段合并为一个有序的大片段,最底层是对于单个元素的片段进行合并,单个元素肯定有序,合并只需要根据两个元素的大小进行片段的重排。
          需要使用额外的内存空间保存两个子片段,然后在原数组上存放合并之后的片段。
       3. 从最小的片段开始,归并到整个数组有序。
     * @author 好好学习
     * @version v1
     * @date 2020-08-08
     */
    
    #include <iostream>
    #include <vector>
    #include <queue>
    #include <string>
    using namespace std;
    
    template<typename T, typename _compare = std::less<T> >	//通用接口
    void MergeSort(vector<T>& nums, _compare cmp = std::less<T>());
    
    template<typename T, typename _compare = std::less<T>>		//归并排序的入口
    void MSort(vector<T>& nums, int start, int end, vector<T>& tmp, _compare cmp = std::less<T>());
    
    template<typename T, typename _compare = std::less<T>>		//实现具体归并的函数
    void Merge(vector<T>& nums, int start, int mid, int end, vector<T>& tmp, _compare cmp = std::less<T>());
    
    template<typename T>						//vector的打印函数
    void printArray(vector<T>& nums);
    
    /**
     * @brief 自定义仿函数,作为比较函数
     * @return bool 返回比较结果
     */
    template<typename T>
    struct cmp {
    	bool operator()(T& a, T& b) {
    		return a < b;
    	}
    };
    
    int main() {
    
    	vector<int> a({ 5,6,1,8,3,4,9,7,2,3 });
    	vector<string> b({ "hello","world","hahaha", "welcome", "goodbye","nice","apple" });
    	//打印a和b的初始值
    	cout << "Initial value of vecotr a:";
    	printArray<int>(a);
    
    	cout << "Initial value of vecotr b:";
    	printArray<string>(b);
    
    	//使用STL中的比较函数,less:升序排列;greator:降序排列
    	MergeSort<int>(a, less<int>());
    	//使用自定义的比较函数,可以支持自定义数据类型(或者针对自定义数据类型,重载"<"或">"运算符,可以使用less或者greater
    	MergeSort<string>(b, cmp<string>());
    	//打印排序后的a和b
    	cout << "Sorted value of vecotr a:";
    	printArray<int>(a);
    	cout << "Sorted value of vecotr b:";
    	printArray<string>(b);
    	system("pause");
    	return 0;
    }
    
    /**
     * @brief 归并排序的通用接口
     * @param[in]  nums   待排序元素序列
     * @param[in]  cmp  用于指定比较方式的函数对象,默认使用less<T>
     * @return
     */
    template<typename T, typename _compare >	
    void MergeSort(vector<T>& nums, _compare cmp) {
    
    	vector<T> tmp(nums.size());
    	MSort(nums, 0, nums.size() - 1, tmp, cmp);
    }
    
    /**
     * @brief 归并排序的入口
     * @param[in]  nums   待排序元素序列
     * @param[in]  cmp  用于指定比较方式的函数对象,默认使用less<T>
     * @param[in]  start  归并区间的左边界
     * @param[in]  end  归并区间的右边界(都是闭区间)
     * @param[in]  tmp  用于保存临时数据的临时容器
     * @return
     */
    template<typename T, typename _compare>
    void MSort(vector<T>& nums, int start, int end, vector<T>& tmp, _compare cmp) {
    	if (nums.empty() || start >= end)return;
    
    	int mid = start + (end - start) / 2;
    	//将待排序区间从中间分割开
    	MSort(nums, start, mid, tmp, cmp);
    	MSort(nums, mid + 1, end, tmp, cmp);
    	//将分割开的元素进行合并
    	Merge(nums, start, mid, end, tmp, cmp);
    }
    
    /**
     * @brief 实现具体归并的函数,该函数将两个有序的序列()进行合并,合并为一个更大的有序序列
     * @param[in]  nums   待排序元素序列
     * @param[in]  cmp  用于指定比较方式的函数对象,默认使用less<T>
     * @param[in]  start,mid,end  指定两个待合并区间的边界:[start, mid]和[mid+1, end]
     * @param[in]  tmp  用于保存临时数据的临时容器
     * @return
     */
    template<typename T, typename _compare>
    void Merge(vector<T>& nums, int start, int mid, int end, vector<T>& tmp, _compare cmp) {
    	int firstIdx = start;
    	int secondIdx = mid + 1;
    	int numsIdx = start;
    	//先将两个已排序序列复制到tmp中
    	for (int i = start; i <= mid; ++i)tmp[i] = nums[i];
    	for (int i = mid + 1; i <= end; ++i)tmp[i] = nums[i];
    	//然后将tmp中的两段数组合并到nums中
    	while (numsIdx <= end) {
    		if (secondIdx > end)nums[numsIdx++] = tmp[firstIdx++];
    		else if (firstIdx > mid)nums[numsIdx++] = tmp[secondIdx++];
    		else {
    			if (cmp(tmp[firstIdx], tmp[secondIdx]))nums[numsIdx++] = tmp[firstIdx++];
    			else nums[numsIdx++] = tmp[secondIdx++];
    		}
    	}
    }
    //vector的打印函数
    /**
     * @brief vector序列打印输出函数
     * @param[in]  nums   待输出序列
     * @return
     */
    template<typename T>
    void printArray(vector<T>& nums) {
    	for (auto it = nums.begin(); it != nums.end(); ++it)cout << *it << " ";
    	cout << endl;
    }
    
    
    

     

    展开全文
  • 其实sort()不光可以对数组进行排序, 基本数据类型数组都可以, 并且可以实现对对象数组排序。这个sort其实远比我们想象的更加智能,它会基于要排序的数据量选择性能更加优秀的排序算法来实现排序原理为什么...
  • Arrays.sort 主要用于数组排序,包括基本类型的数组和对象数组。 Collections.sort 对List等集合类进行排序. 底层实现(jdk1.8版本) Collections.sort 方法调用了list.sort方法 public static <T extends ...
  • 面试题

    2018-07-24 22:32:06
    1.var str = ‘asdasdasdafadadw’ 判断‘a'在str中出现的次数 判断str中出现次数最多的字符,并给出次数 2.把数字按照千分位划分 3.把多维数组拍平;...7.数组排序的方法,冒泡排序的实现原理 ...
  • javascript中sort方法的完整解析--排序

    千次阅读 2018-01-10 11:21:59
    说起对数组的排序,大家能想到的应该冒泡排序,快速排序,sort排序,以及希尔排序吧,但是可能对sort排序只停留再数组层面(每个元素均数字或者字符串),事实上,它还可以对对象进行排序原理是:不管元素...
  • 其实sort()不光可以对数组进行排序,基本数据类型数组都可以,并且可以实现对对象数组排序.接下来介绍一下用法. 1. 基本数据类型 (1)数字类型: int[] a = {1, 3, 4, 67, 78, 9, 90, 6, 3, 2}; Array
  • sort()Java中用来排序的一个方法,在我们专心学习各种经典排序算法的时候,其实在代码中一个sort()就可以解决,...其实sort()不光可以对数组进行排序,基本数据类型数组都可以,并且可以实现对对象数组排序.接下...
  • Vector原理及其用法

    2019-08-08 22:46:00
    可以简单的认为,向量一个能够存放任意类型的动态数组。 二、容器特性1.顺序序列顺序容器中的元素按照严格的线性顺序排序。可以通过元素在序列中的位置访问对应的元素。2.动态数组支持对序列中的任意元素进行...
  • 插入排序是数据结构中一种常见的排序方式,原理简单。把数组分为两部分,一部分为有序集合,一部分为无序集合。假设数组大小为N,有序集合大小为i,依次从无序集合中拿出一个数组向有序集合中加入,直至无序集合大小...
  • sort()Java中用来排序的一个方法,...其实sort()不光可以对数组进行排序,基本数据类型数组都可以,并且可以实现对对象数组排序.接下来介绍一下用法.1基本数据类型(1)数字类型:     &n...
  • 缓冲流、转换流、序列化流 第一章 缓冲流 都在基本的流对象基础之上创建而来的,相当于...缓冲流的基本原理在创建流对象时,会创建一个内置的默认大小的缓冲区数组,通过缓冲区读写,减少系统IO次数,从而提高读
  • 第三部分“排序”(第6~11章)按章节顺序分别讨论基本排序方法(如选择排序、插入排序、冒泡排序、希尔排序等)、快速排序方法、归并和归并排序方法、优先队列与堆排序方法、基数排序方法以及特殊用途的排序方法,...
  • 第二部分高级主题,包括面向对象语言和函数语言、垃圾收集、循环优化、SSA(静态单赋值)形式、循环调度、存储结构优化等,适合于后续课程或研究生教学。书中专门为学生提供了一个用C语言编写的实习项目,包括前端和...
  • 他的主要研究方向数据库系统、时间数据库、概念建模、面向对象数据库、Wed建模和本体论数据库模型和语言、DBMS系统实现、检索技术等。  Shamkant B.Navathe 世界知名的数据库学者。现任佐治亚理工学院计算学院...
  • javascript入门笔记

    2018-05-15 15:01:07
    条件一个boolean类型的数据,如果条件结果为true,则执行表达式1的内容,并将表达式1的结果作为整体表达式的结果。如果条件为false,则执行表达式2的内容,并将表达式2的结果作为整体表达式的结果 ex: var age ...
  • C# Primer Plus中文版

    热门讨论 2009-05-24 00:25:01
    17.3.2 对象类型转换 511 17.3.3 as操作符 514 17.4 最终的基类:System.Object 514 17.5 隐藏方法 518 17.6 用new和override关键字控制版本 520 17.7 多重继承 522 17.8 接口 523 17.8.1 定义接口 524 17.8.2 实现...
  • 前端面试宝典V3.0.docx

    2021-03-27 13:31:48
    26、如何实现数组的随机排序?(必会) 100 27、 Function foo() {}和 var foo = function() {}之间 foo 的用法上的区别?(必会) 101 28、索引有哪几种类型,有什么区别?(了解) 102 29、简述 Array.form 和 ...
  • 17.3.2 对象类型转换 511 17.3.3 as操作符 514 17.4 最终的基类:System.Object 514 17.5 隐藏方法 518 17.6 用new和override关键字控制版本 520 17.7 多重继承 522 17.8 接口 523 17.8.1 定义接口 524 17.8.2 实现...
  • // 打印出3,因为该是数组有3个元素 // 用一个语句定义一个数组并赋值 $myphonebook = array ( "sbabu" => "5348", "keith" => "4829", "carole" => "4533" ); // 噢,忘了教长吧,让我们添加一个元素 $myphonebook...
  • Objective-C2.0程序设计

    2013-04-14 19:22:27
    15.4.2 数组排序 15.5 词典对象 15.6 集合对象 15.7 练习 第16章 使用文件 16.1 管理文件和目录:NSFileManager 16.1.1 使用NSData类 16.1.2 使用目录 16.1.3 枚举目录中的内容 16.2 使用路径:NSPathUtilities.h ...
  • PHP入门到精通

    2013-12-02 15:58:03
    7.10数组排序 PHP与Web页面交互(教学录像:1小时4分33秒) 8.1Web页表单元素的组成 8.2在普通的Web页中插入表单 8.3获取表单数据的两种方法 8.4PHP传参的常用方法 8.5在Web页中嵌入PHP脚本 8.6在PHP中获取表单数据 ...
  • PHP入门到精通02

    2013-12-02 16:06:19
    7.10数组排序 PHP与Web页面交互(教学录像:1小时4分33秒) 8.1Web页表单元素的组成 8.2在普通的Web页中插入表单 8.3获取表单数据的两种方法 8.4PHP传参的常用方法 8.5在Web页中嵌入PHP脚本 8.6在PHP中获取表单数据 ...
  • 第二篇面向对象基础篇,主要介绍类、对象、字段、方法、流程控制、数组、继承、属性、运算符重载、接口等C#基本内容。第三篇应用技术篇,主要介绍的异常处理、文件和流、委托、事件、Lambda表达式、命名空间、...

空空如也

空空如也

1 2 3 4 5 ... 10
收藏数 186
精华内容 74
关键字:

数组是对象类型数组排序原理