Java基础-06.总结二维数组,面向对象

1:二维数组(理解)

(1)元素是一维数组的数组。

(2)格式:

A:数据类型[][] 数组名 = new 数据类型[m][n];

B:数据类型[][] 数组名 = new 数据类型[m][];

C:数据类型[][] 数组名 = new 数据类型[][]{{...},{...},{...}};

D:数据类型[][] 数组名 = {{...},{...},{...}};

/*
 二维数组:就是元素为一维数组的一个数组。
 格式1:
 数据类型[][] 数组名 = new 数据类型[m][n];
 m:表示这个二维数组有多少个一维数组。
 n:表示每一个一维数组的元素有多少个。
 注意:
 A:以下格式也可以表示二维数组
 a:数据类型 数组名[][] = new 数据类型[m][n];
 b:数据类型[] 数组名[] = new 数据类型[m][n];
 B:注意下面定义的区别
 int x;
 int y;
 int x,y;
 int[] x;
 int[] y[];
 int[] x,y[];
*/
class Array2Demo {
 public static void main(String[] args) {
  //定义一个二维数组
  int[][] arr = new int[3][2];
  //定义了一个二维数组arr
  //这个二维数组有3个一维数组的元素
  //每一个一维数组有2个元素
  //输出二维数组名称
  System.out.println(arr); //地址值 [[I@175078b
  //输出二维数组的第一个元素一维数组的名称
  System.out.println(arr[0]); //地址值 [I@42552c
  System.out.println(arr[1]); //地址值 [I@e5bbd6
  System.out.println(arr[2]); //地址值 [I@8ee016
  //输出二维数组的元素
  System.out.println(arr[0][0]); //0
  System.out.println(arr[0][1]); //0
 }
}
/*
 格式2:
 数据类型[][] 数组名 = new 数据类型[m][];
 m:表示这个二维数组有多少个一维数组。
 列数没有给出,可以动态的给。这一次是一个变化的列数。
*/
class Array2Demo2 {
 public static void main(String[] args) {
 //定义数组
 int[][] arr = new int[3][];
 System.out.println(arr); //[[I@175078b
 System.out.println(arr[0]); //null
 System.out.println(arr[1]); //null
 System.out.println(arr[2]); //null
 //动态的为每一个一维数组分配空间
 arr[0] = new int[2];
 arr[1] = new int[3];
 arr[2] = new int[1];
 System.out.println(arr[0]); //[I@42552c
 System.out.println(arr[1]); //[I@e5bbd6
 System.out.println(arr[2]); //[I@8ee016
 System.out.println(arr[0][0]); //0
 System.out.println(arr[0][1]); //0
 //ArrayIndexOutOfBoundsException
 //System.out.println(arr[0][2]); //错误
 arr[1][0] = 100;
 arr[1][2] = 200;
 }
}
/*
 格式3:
 基本格式:
 数据类型[][] 数组名 = new 数据类型[][]{{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}};
 简化版格式:
 数据类型[][] 数组名 = {{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}};
 举例:
 int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
 int[][] arr = {{1,2,3},{4,5},{6}};
*/
class Array2Demo3 {
 public static void main(String[] args) {
 //定义数组
 int[][] arr = {{1,2,3},{4,5},{6}};
 System.out.println(arr);
 System.out.println(arr[0]);
 System.out.println(arr[1]);
 System.out.println(arr[2]);
 System.out.println(arr[0][0]); //1
 System.out.println(arr[1][0]); //4
 System.out.println(arr[2][0]); //6
 System.out.println(arr[0][1]); //2
 System.out.println(arr[1][1]); //5
 //越界
 System.out.println(arr[2][1]); //错误
 }
}

(3)案例(掌握):

A:二维数组的遍历

B:二维数组的求和

C:杨辉三角形

/*  练习题(1)
 需求:二维数组遍历
 外循环控制的是二维数组的长度,其实就是一维数组的个数。
 内循环控制的是一维数组的长度。
*/
class Array2Test {
 public static void main(String[] args) {
 //定义一个二维数组
 int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
 //请问谁代表{1,2,3}
 //arr[0]就是第一个数组
 //arr[0] = {1,2,3};
 for(int x=0; x<arr[0].length; x++) {
 System.out.println(arr[0][x]);
 }
 System.out.println("--------------");
 for(int x=0; x<arr[1].length; x++) {
 System.out.println(arr[1][x]);
 }
 System.out.println("--------------");
 for(int x=0; x<arr[2].length; x++) {
 System.out.println(arr[2][x]);
 }
 System.out.println("--------------");
 //用循环改进
 for(int x=0; x<3; x++) {
 for(int y=0; y<arr[x].length; y++) {
 System.out.print(arr[x][y]+" ");
 }
 System.out.println();
 }
 System.out.println("--------------");
 //这个时候,注意了,3是我们根据上面的代码得出来的
 //但是,它不能针对任何的数组都可以这样
 //所以,我们应该想办法改进
 //其实,外面的这个循环的长度就是二维数组的长度
 for(int x=0; x<arr.length; x++) {
 for(int y=0; y<arr[x].length; y++) {
 System.out.print(arr[x][y]+" ");
 }
 System.out.println();
 }
 System.out.println("--------------");
 //用方法改进
 //调用方法
 printArray2(arr);
 System.out.println("--------------");
 //我们再来一个列数是变化的
 int[][] arr2 = {{1,2,3},{4,5},{6}};
 printArray2(arr2);
 }
 /*
 需求:遍历二维数组
 两个明确:
 返回值类型:void
 参数列表:int[][] arr
 */
 public static void printArray2(int[][] arr) {
 for(int x=0; x<arr.length; x++) {
 for(int y=0; y<arr[x].length; y++) {
 System.out.print(arr[x][y]+" ");
 }
 System.out.println();
 }
 }
}
/*  练习题(2)
 公司年销售额求和
 某公司按照季度和月份统计的数据如下:单位(万元)
 第一季度:22,66,44
 第二季度:77,33,88
 第三季度:25,45,65
 第四季度:11,66,99
 分析:
 A:把题目的数据用二维数组来表示
 int[][] arr = {{22,66,44},{77,33,88},{25,45,65},{11,66,99}};
 B:如何求和呢?
 求和其实就是获取到每一个元素,然后累加即可。
 C:定义一个求和变量sum,初始化值是0。
 D:通过遍历就可以得到每一个二维数组的元素。
 E:把元素累加即可。
 F:最后输出sum,就是结果。
*/
class Array2Test2 {
 public static void main(String[] args) {
 //把题目的数据用二维数组来表示
 int[][] arr = {{22,66,44},{77,33,88},{25,45,65},{11,66,99}};
 //定义一个求和变量sum,初始化值是0。
 int sum = 0;
 //通过遍历就可以得到每一个二维数组的元素。
 for(int x=0; x<arr.length; x++) {
 for(int y=0; y<arr[x].length; y++) {
 //把元素累加即可。
 sum += arr[x][y];
 }
 }
 //最后输出sum,就是结果。
 System.out.println("一年的销售额为:"+sum+"万元");
 }
}
/*  练习题(3)
 需求:打印杨辉三角形(行数可以键盘录入)
 1
 1 1 
 1 2 1
 1 3 3 1
 1 4 6 4 1 
 1 5 10 10 5 1
 分析:看这种图像的规律
 A:任何一行的第一列和最后一列都是1
 B:从第三行开始,每一个数据是它上一行的前一列和它上一行的本列之和。
 步骤:
 A:首先定义一个二维数组。行数如果是n,我们把列数也先定义为n。
   这个n的数据来自于键盘录入。
 B:给这个二维数组任何一行的第一列和最后一列赋值为1
 C:按照规律给其他元素赋值
 从第三行开始,每一个数据是它上一行的前一列和它上一行的本列之和。
 D:遍历这个二维数组。
*/
import java.util.Scanner;
class Array2Test3 {
 public static void main(String[] args) {
 //创建键盘录入对象
 Scanner sc = new Scanner(System.in);
 //这个n的数据来自于键盘录入。
 System.out.println("请输入一个数据:");
 int n = sc.nextInt();
 //定义二维数组
 int[][] arr = new int[n][n];
 //给这个二维数组任何一行的第一列和最后一列赋值为1
 for(int x=0; x<arr.length; x++) {
 arr[x][0] = 1; //任何一行第1列
 arr[x][x] = 1; //任何一行的最后1列
 }
 //按照规律给其他元素赋值
 //从第三行开始,每一个数据是它上一行的前一列和它上一行的本列之和。
 for(int x=2; x<arr.length; x++) {
 //这里如果y<=x是有个小问题的,就是最后一列的问题
 //所以这里要减去1
 //并且y也应该从1开始,因为第一列也是有值了
 for(int y=1; y<=x-1; y++) {
 //每一个数据是它上一行的前一列和它上一行的本列之和。
 arr[x][y] = arr[x-1][y-1] + arr[x-1][y];
 }
 }
 //遍历这个二维数组。
 /*
 for(int x=0; x<arr.length; x++) {
 for(int y=0; y<arr[x].length; y++) {
 System.out.print(arr[x][y]+"\t");
 }
 System.out.println();
 }
 */
 //这个时候,要注意了,内循环的变化必须和曾经讲过的九九乘法表类似
 for(int x=0; x<arr.length; x++) {
 for(int y=0; y<=x; y++) {
 System.out.print(arr[x][y]+"\t");
 }
 System.out.println();
 }
 }
}

2:两个思考题(理解)

(1)Java中的参数传递问题

Java中只有值传递。

基本类型:形式参数的改变不影响实际参数

引用类型:形式参数的改变直接影响实际参数

(2)数据加密问题

综合的小案例。

/*
 思考题1:看程序写结果,然后分析为什么是这个样子的。并画图讲解。最后总结Java中参数传递规律。
 Java中的参数传递问题:
 基本类型:形式参数的改变对实际参数没有影响。
 引用类型:形式参数的改变直接影响实际参数。
*/
class ArgsDemo {
 public static void main(String[] args) {
 int a = 10;
 int b = 20;
 System.out.println("a:"+a+",b:"+b); //a:10,b:20
 change(a,b);
 System.out.println("a:"+a+",b:"+b); //??? a:10,b:20
 int[] arr = {1,2,3,4,5}; 
 change(arr);
 System.out.println(arr[1]); //??? 4
 }
 public static void change(int a,int b) { //a=10,b=20
 System.out.println("a:"+a+",b:"+b); //a:10,b:20
 a = b; //a=20
 b = a + b; //b=40
 System.out.println("a:"+a+",b:"+b); //a:20,b:40
 }
 public static void change(int[] arr) { //arr={1,2,3,4,5};
 for(int x=0; x<arr.length; x++) {
 if(arr[x]%2==0) {
 arr[x]*=2;
 }
 }
 //arr={1,4,3,8,5};
 }
}
/*

某个公司采用公用电话传递数据信息,数据是小于8位的整数,为了确保安全,

在传递过程中需要加密,加密规则如下:

首先将数据倒序,然后将每位数字都加上5,再用和除以10的余数代替该数字,

最后将第一位和最后一位数字交换。 请任意给定一个小于8位的整数,

然后,把加密后的结果在控制台打印出来。

题目要求:

A:数据是小于8位的整数

定义一个int类型的数据

int number = 123456;

B:加密规则

a:首先将数据倒序

结果 654321

b:然后将每位数字都加上5,再用和除以10的余数代替该数字

结果 109876

c:最后将第一位和最后一位数字交换

结果 609871

C:把加密后的结果输出在控制台

通过简单的分析,我们知道如果我们有办法把这个数据变成数组就好了。

不是直接写成这个样子的:

int[] arr = {1,2,3,4,5,6};

如何把数据转成数组呢?

A:定义一个数据

int number = 123456;

B:定义一个数组,这个时候问题就来了,数组的长度是多少呢?

int[] arr = new int[8]; //不可能超过8

在赋值的时候,我用一个变量记录索引的变化。

定义一个索引值是0

int index = 0;

C:获取每一个数据

 int ge = number%10
 int shi = number/10%10
 int bai = number/10/10%10
 arr[index] = ge;
 index++;
 arr[index] = shi;
 index++;
 arr[index] = bai;
 ...
*/
class JiaMiDemo {
 public static void main(String[] args) {
 //定义一个数据
 int number = 123456;
 //定义一个数组
 int[] arr = new int[8];
 //把数据中每一位上的数据获取到后存储到数组中
 /*
 int index = 0;
 arr[index] = number%10; //arr[0]=6;
 index++;
 arr[index] = number/10%10; //arr[1]=5;
 index++;
 arr[index] = mumber/10/10%10; //arr[2]=4;
 */
 //通过观察这个代码,我们发现应该是可以通过循环改进的
 int index = 0;
 while(number > 0) { //number=123456,number=12345,number=1234,number=123,number=12,number=1,number=0
 arr[index] = number%10; //arr[0]=6,arr[1]=5,arr[2]=4,arr[3]=3,arr[4]=2,arr[5]=1
 index++;//index=1,index=2,index=3,index=4,index=5,index=6
 number/=10;//number=12345,number=1234,number=123,number=12,number=1,number=0
 }
 //然后将每位数字都加上5,再用和除以10的余数代替该数字
 for(int x=0; x<index; x++) {
 arr[x] += 5;
 arr[x] %= 10;
 }
 //最后将第一位和最后一位数字交换
 int temp = arr[0];
 arr[0] = arr[index-1];
 arr[index-1] = temp;
 //输出数据
 for(int x=0; x<index; x++) {
 System.out.print(arr[x]);
 }
 System.out.println();
 }
}
/*
 把刚才的代码改进一下:
 A:把数据改进为键盘录入
 B:把代码改进为方法实现
 另一个数据的测试:
 number:1234567
 第一步:7654321
 第二步:2109876
 第三步:6109872
 知识点:
 变量
 数据类型
 运算符
 键盘录入
 语句
 方法
 数组
*/
import java.util.Scanner;
class JiaMiDemo2 {
 public static void main(String[] args) {
 //创建键盘录入对象
 Scanner sc = new Scanner(System.in);
 //请输入一个数据
 System.out.println("请输入一个数据(小于8位):");
 int number = sc.nextInt();
 //写功能实现把number进行加密
 //调用
 String result = jiaMi(number);
 System.out.println("加密后的结果是:"+result);
 }
 /*
 需求:写一个功能,把数据number实现加密。
 两个明确:
 返回值类型:String 做一个字符串的拼接。
 参数列表:int number
 */
 public static String jiaMi(int number) {
 //定义数组
 int[] arr = new int[8];
 //定义索引
 int index = 0;
 //把number中的数据想办法放到数组中
 while(number > 0) {
 arr[index] = number%10;
 index++;
 number /= 10;
 }
 //把每个数据加5,然后对10取得余数
 for(int x=0; x<index; x++) {
 arr[x] += 5;
 arr[x] %= 10;
 }
 //把第一位和最后一位交换
 int temp = arr[0];
 arr[0] = arr[index-1];
 arr[index-1] = temp;
 //把数组的元素拼接成一个字符串返回
 //定义一个空内容字符串
 String s = "";
 for(int x=0; x<index; x++) {
 s += arr[x];
 }
 return s;
 }
}

3:面向对象(掌握)

(1)面向对象

面向对象是基于面向过程的编程思想

(2)面向对象的思想特点

A:是一种更符合我们思考习惯的思想

B:把复杂的事情简单化

C:让我们从执行者变成了指挥者

举例:

买电脑

洗衣服

做饭

...

万事万物皆对象

(3)把大象装进冰箱(理解)

A:面向过程实现

B:面向对象实现

注意:如何让我们的操作更符合面向对象思想呢?

A:有哪些类

B:每个类有哪些成员

C:类与类的关系

(4)类与对象

A:现实生活中存在的东西,叫事物

属性 事物的基本描述 (外在特征) 姓名,年龄,性别

行为 事物的功能 (能做什么事情) 吃饭,睡觉,学习

B:Java语言中最基本的单位是类。所以,我们要用类来体现事物

C:类

成员变量 事物属性

成员方法 事物行为

D:类:

是一组相关的属性和行为的集合。是一个抽象的概念。

class类名(……)

对象:

是该类事物的具体存在,是一个具体的实例。(对象)

举例:

学生:类

班长:对象

(5)类的定义及使用

A:类的定义

成员变量 定义格式和以前一样,就是位置不同,在类中,方法外。

成员方法 定义格式和以前一样,就是去掉了static。

B:使用类的内容

a:创建对象? 格式

类名 对象名 = new 类名();

b:如何使用成员变量和成员方法呢

对象名.成员变量

对象名.成员方法()

(6)案例:

A:学生类的定义和使用

B:手机类的定义和使用

(7)内存图

A:一个对象的内存图

B:二个对象的内存图

C:三个对象的内存图

(8)Java程序的开发,设计和特征

A:开发:就是不断的创建对象,通过对象调用功能

B:设计:就是管理和维护对象间的关系

C:特征

a:封装

b:继承

c:多态

1:面向对象思想

面向对象:是基于面向过程的编程思想。

面向过程:强调的是每一个功能的步骤

面向对象:强调的是对象,然后由对象去调用功能

2:面向对象的思想特点

A:是一种更符合我们思想习惯的思想

B:可以将复杂的事情简单化

C:将我们从执行者变成了指挥者

举例:

买电脑:

面向过程:我的了解电脑--了解我自己的需求--找对应的参数信息--去中关村买电脑--讨价还价--买回电脑

面向对象:我知道我要买电脑 -- 班长去给我买 -- 班长就买回来了

洗衣服:

面向过程:把衣服脱下--找一个盆--放点洗衣粉--加点水--把衣服扔进去--搓一搓--清洗衣服--拧干--晾起来

面向对象:把衣服脱下--打开全自动洗衣机--扔进去--一键即可--晾起来

吃饭:

面向过程:去超市买菜--摘菜--洗菜--切菜--炒菜--盛起来--吃

面向对象:上饭店吃饭,你--服务员(点菜)--厨师(做菜)--服务员(端菜)--吃

家常事物,买洗衣机和去饭店太不划算了,所以,找个对象。

但是,你不跟我好好学习,你将来4000,你对象8000。

3:把大象装进冰箱

面向过程:

动作有哪些呢?

A:打开冰箱门

B:装进大象

C:关闭冰箱门

代码体现;

 class Demo {
 public static void main(String[] args) {
 /*
 System.out.println("打开冰箱门");
 //打开冰箱门的东西,我现在仅仅是为了演示,就写了一个输出语句
 //其实,它可能需要做很多操作。
 //这个时候代码就比较多一些了
 //假设我要多次打开冰箱门,
 //代码一多,每次都写一遍,麻烦不
 //我们就应该用方法改进
 System.out.println("装进大象");
 System.out.println("关闭冰箱门");
 */
 //写了方法以后,调用就改变了
 open();
 in();
 close();
 }
 public static void open() {
 System.out.println("打开冰箱门");
 }
 public static void in() {
 System.out.println("装进大象");
 }
 public static void close() {
 System.out.println("关闭冰箱门");
 }
 }

面向对象:

我们怎么才能更符合面向对象思想呢?

A:有哪些类呢?

B:每个类有哪些东西呢?

C:类与类直接的关系是什么呢?

把大象装进冰箱的分析? (如何分析有哪些类呢?UML。名词提取法。)

A:有哪些类呢?

大象

冰箱

Demo

B:每个类有哪些东西呢?

大象:

进去

冰箱:

开门

关门

Demo:

main方法

C:类与类直接的关系是什么呢?

Demo中使用大象和冰箱类的功能。

代码体现:

 class 大象 {
 public static void in() {
 System.out.println("装进大象");
 }
 }
 class 冰箱 {
 public static void open() {
 System.out.println("打开冰箱门");
 }
 public static void close() {
 System.out.println("关闭冰箱门");
 }
 }
 class Demo {
 public static void main(String[] args) {
 冰箱调用开门
 大象调用进去
 冰箱调用关门
 }
 }
4:开发,设计,特征
面向对象开发
 就是不断的创建对象,使用对象,指挥对象做事情。
面向对象设计
 其实就是在管理和维护对象之间的关系。
面向对象特征
 封装(encapsulation)
 继承(inheritance)
 多态(polymorphism)
/*  手机类::
 手机事物:
 属性:品牌,价格,颜色...
 行为:打电话,发短信,玩游戏...
 手机类:
 成员变量:品牌,价格,颜色
 成员方法:打电话,发短信,玩游戏
*/
class Phone {
 //品牌
 String brand;
 //价格
 int price;
 //颜色
 String color;
 //打电话的方法
 public void call(String name) {
 System.out.println("给"+name+"打电话");
 }
 //发短信的方法
 public void sendMessage() {
 System.out.println("群发短信");
 }
 //玩游戏的方法
 public void playGame() {
 System.out.println("玩游戏");
 }
}
/*
 手机类的测试
*/
class Phone {
 //品牌
 String brand;
 //价格
 int price;
 //颜色
 String color;
 //打电话的方法
 public void call(String name) {
 System.out.println("给"+name+"打电话");
 }
 //发短信的方法
 public void sendMessage() {
 System.out.println("群发短信");
 }
 //玩游戏的方法
 public void playGame() {
 System.out.println("玩游戏");
 }
}
class PhoneDemo {
 public static void main(String[] args) {
 //创建手机对象
 //类名 对象名 = new 类名();
 Phone p = new Phone();
 //直接输出成员变量值
 System.out.println(p.brand+"---"+p.price+"---"+p.color);
 //给成员变量赋值
 p.brand = "诺基亚";
 p.price = 100;
 p.color = "灰色";
 //再次输出
 System.out.println(p.brand+"---"+p.price+"---"+p.color);
 //调用方法
 p.call("林青霞");
 p.sendMessage();
 p.playGame();
 }
}
/*   学生类::
 在一个java文件中写两个类:一个基本的类,一个测试类。
 注意:文件名称和测试类名称一致。
 如何使用呢?
 创建对象使用。
 如何创建对象呢?
 格式:类名 对象名 = new 类名();
 如何使用成员变量呢?
 对象名.变量名
 如何使用成员方法呢?
 对象名.方法名(...)
*/
//这是学生类
class Student {
 //姓名
 String name; //null
 //年龄
 int age; //0
 //地址
 String address; //null
 //学习
 public void study() {
 System.out.println("学生爱学习");
 }
 //吃饭
 public void eat() {
 System.out.println("学习饿了,要吃饭");
 }
 //睡觉
 public void sleep() {
 System.out.println("学习累了,要睡觉");
 }
}
//这是学生测试类
class StudentDemo {
 public static void main(String[] args) {
 //类名 对象名 = new 类名();
 Student s = new Student();
 //输出成员变量值
 //System.out.println(s.name);
 //System.out.println(s.age);
 //System.out.println(s.address);
 //改进写法
 System.out.println(s.name+"---"+s.age+"---"+s.address);
 //给成员变量赋值
 s.name = "林青霞";
 s.age = 27;
 s.address = "北京";
 //赋值后的输出
 System.out.println(s.name+"---"+s.age+"---"+s.address);
 //调用方法
 s.study();
 s.eat();
 s.sleep();
 }
}
/*
 事物:
 属性 事物的信息描述
 行为 事物的功能
 类:
 成员变量 事物的属性
 成员方法 事物的行为
 定义一个类,其实就是定义该类的成员变量和成员方法。
 案例:我们来完成一个学生类的定义。
 学生事物:
 属性:姓名,年龄,地址...
 行为:学习,吃饭,睡觉...
 把事物要转换为对应的类:
 学生类:
 成员变量:姓名,年龄,地址...
 成员方法:学习,吃饭,睡觉...
 成员变量:和以前变量的定义是一样的格式,但是位置不同,在类中方法外。
 成员方法:和以前的方法定义是一样的格式,但是今天把static先去掉。
 首先我们应该定义一个类,然后完成类的成员。
*/
//这是我的学生类
class Student {
 //定义变量
 //姓名
 String name;
 //年龄
 int age;
 //地址
 String address;
 //定义方法
 //学习的方法
 public void study() {
 System.out.println("学生爱学习");
 }
 //吃饭的方法
 public void eat() {
 System.out.println("学习饿了,要吃饭");
 }
 //睡觉的方法
 public void sleep() {
 System.out.println("学习累了,要睡觉");
 }
}

原文发布于微信公众号 - Java帮帮(javahelp)

原文发表时间:2016-11-26

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏数据结构与算法

1083 Cantor表

题目描述 Description 现代数学的著名证明之一是Georg Cantor证明了有理数是可枚举的。他是用下面这一张表来证明这一命题的: 1/1 1/2 ...

3137
来自专栏Python专栏

浅尝Python快速排序

1384
来自专栏数据结构与算法

cf314E. Sereja and Squares(dp)

给你一个擦去了部分左括号和全部右括号的括号序列,括号有25种,用除x之外的小写字母a~z表示。求有多少种合法的括号序列。答案对4294967296取模。 合法序...

1557
来自专栏ml

向前字典排序

          next_permutation算法对区间元素进行一次组合排序,使之字典顺序大于原来的排序,有如下两个使用原形,对迭代器区间[first,l...

2689
来自专栏JavaEdge

设计模式实战 - 解释器模式(Interpreter Pattern)

● 公式可以运行时编辑,并且符合正常算术书写方式,例如a+b-c ● 高扩展性,未来增加指数、开方、极限、求导等运算符号时较少改动 ● 效率可以不用考虑,晚...

1082
来自专栏编程之旅

唠唠快速排序算法

每一个从事计算机相关方向工作的同学一定听说过快速排序算法,在面试的准备过程中,快排也一定是一个必须要牢牢掌握的算法。那么今天就来唠唠快速排序算法。

1082
来自专栏程序员叨叨叨

5.2 数组类型

在着色程序中,数组通常的使用目的是:作为从外部应用程序传入大量参数到 Cg 的顶点程序中的形参接口,例如与皮肤形变相关的矩阵数组,或者光照参数数组等。

621
来自专栏Python小屋

哈夫曼编码原理与Python实现代码(附手动推导过程原稿真迹)

哈夫曼编码依据字符出现概率来构造异字头(任何一个字符的编码都不是其他字符的前缀)的平均长度最短的码字,通过构造二叉树来实现,出现频次越多的字符编码越短,出现频次...

7028
来自专栏计算机视觉与深度学习基础

Leetcode 287. Find the Duplicate Number

Given an array nums containing n + 1 integers where each integer is between 1 a...

2565
来自专栏Python小屋

Python模拟大整数乘法的小学竖式计算过程

让我们先看个图回顾一下小学学过的计算整数乘法的竖式计算过程 ? 然后再来看如何使用Python来模拟上面的过程,虽然在Python中计算任意大的数字乘法都没有问...

3395

扫码关注云+社区

领取腾讯云代金券