1.1节的内容主要为介绍Java的基本语法以及书中会用到的库。java
下图为一个Java程序示例和相应的注解:算法
int
为32位,double
为64位int
和double
之外的其余初始数据类型:
++i
等价于i = i + 1
和i += 1
,即先+1,再进行运算;而i++
是先运算再+1。下面演示一下:public class i_test { public static void main(String[] args) { int i = 0; int j = 0; System.out.printf("%s: %d%n","++i",++i); System.out.printf("%s: %d%n","i++",j++); } } /**输出: ++i: 1 i++: 0 */
double[] a; a = new double[N]; for (int i = 0; i < N; i++) a[i] = 0.0
double[] a = new double[N]; int[] a = {1,1,2,3,6}
double[][] a = new double[M][N];
数组名表示的是整个数组,若是将一个数组变量赋给另一个变量,则两个变量将会指向同一个数组:编程
int[] a = new int[N]; a[i] = 1234; int[] b = a; b[i] = 5678 // a[i]也变成5678, 不改变原数组的复制方法见下文
1)找最大值数组
double max = a[0]; for (int i = 1;i < a.length; i++) if (a[i] > max) max = a[i];
2)计算平均值数据结构
int N = a.length; double sum = 0.0; for (int i = 0; i < N; i++) sum += a[i]; double average = sum / N;
3)复制数组函数
int N = a.length; double[] b = new double[N]; for (int i = 0; i < N; i++) b[i] = a[i];
4)反转数组中元素oop
int N = a.length; for (int i = 0; i < N/2; i++) { double temp = a[i]; a[i] = a[N-i-1]; a[N-i-1] = temp; }
5)矩阵乘法性能
int N = a.length; double[][] c = new double[N][N]; for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) {// Compute dot product of row i and column j for (int k = 0; k < N; k++) c[i][j] += a[i][k]*b[k][j]; }
典型的静态方法以下图所示:测试
1)判断是否为素数网站
public static boolean isPrime(int N) { if (N < 2) return false; for (int N = 2; i*i <= N; i++) if (N % i == 0) return false; return true; }
2)计算调和级数
public static double H(int N) { double sum = 0.0; for (int i = 1; i < N; i++) sum += 1.0 / i; return sum; }
"<" 表示从文件读取,">"表示写入文件
数据类型是指一组值和一组对值的操做的集合,对象是可以存储任意该数据类型的实体,或数据类型的实例。
一个数据类型的例子:
抽象数据类型和静态方法的相同点:
不一样点:
实例方法和静态方法 :
Java中,全部非原始数据类型的值都是对象。对象的三大特性:状态、标识、行为。
引用 (reference) 是访问对象的一种方式,如图所示:
要建立 (或实例化) 一个对象,用关键字new并紧跟类名以及 () 来触发它的构造函数。每当用例调用new (),系统都会:1. 为新对象分配内存空间。 2. 调用构造函数初始化对象中的值。 3. 返回该对象的一个引用。
建立一个对象,并经过声明语句将变量与对象的引用关联起来:
组成部分:私有实例变量 (private instance variable),构造函数 (constructor),实例方法 (instance method) 和一个测试用例(client) 。
每一个Java类都至少含有一个构造函数以建立一个对象的标识。通常来讲,构造函数的做用是初始化实例变量。若是没有定义构造函数,类将会隐式将全部实例变量初始化为默认值,原始数字类型默认值为0,布尔型为false,引用类型变量为null。
在方法中调用实例变量,若出现二义性,可以使用 this 来区别:
链表是一种递归的数据结构,它或者为空 (Null),或者是指向一个结点 (Node) 的引用,该结点包含一个泛型元素和一个指向另外一条链表的引用。
private class Node { Item item; Node next; }
一个Node对象包含两个实例变量,类型分别为Item (参数类型) 和Node,经过new Node () 触发构造函数来建立一个Node类型的对象。调用的对象是一个指向Node对象的引用,它的实例变量均被初始化为null。
构造一条含有元素to、be和or的链表,首先为每一个元素建立结点:
Node first = new Node(); Node second = new Node(); Node third = new Node();
将每一个结点的item域设为所需的值:
first.item = "to"; second.item = "be"; third.item = "or";
而后用next域构造链表:
first.next = second; second.next = third;
将first指向first.next:
通常数组a[] 的遍历:
for (int i = 0; i < N; i++) { // Process a[i]. }
链表的遍历:
for (Node x = first; x != null; x = x.next) { // Process x.item. }
栈是一种基于后进先出 (LIFO) 策略的集合类型。
public class Stack<Item> { private Node first; private int N; private class Node { Item item; Node next; } public boolean isEmpty() { return first == null; } public int size() { return N; } public void push(Item item) { Node oldfirst = first; first = new Node(); first.item = item; first.next = oldfirst; N++; } public Item pop() { Item item = first.item; first = first.next; N--; return item; } }
栈测试用例:
public static void main(String[] args) { // Create a stack and push/pop strings as directed on StdIn. Stack<String> s = new Stack<String>(); while (!StdIn.isEmpty()) { String item = StdIn.readString(); if (!item.equals("-")) s.push(item); else if (!s.isEmpty()) StdOut.print(s.pop() + " "); } StdOut.println("(" + s.size() + " left on stack)"); }
用链表实现栈的优势:
队列是一种基于先进先出(FIFO)策略的集合类型。
public class Queue<Item> { private Node first; private Node last; private int N; private class Node { Item item; Node next; } public boolean isEmpty() { return first == null; } public int size() { return N; } public void enqueue(Item item) { Node oldlast = last; last = new Node(); last.item = item; last.next = null; if (isEmpty()) first = last; else oldlast.next = last; N++; } public Item dequeue() { Item item = first.item; first = first.next; if (isEmpty()) last = null; N--; return item; } }
队列测试用例:
public static void main(String[] args) { // Create a queue and enqueue/dequeue strings. Queue<String> q = new Queue<String>(); while (!StdIn.isEmpty()) { String item = StdIn.readString(); if (!item.equals("-")) q.enqueue(item); else if (!q.isEmpty()) StdOut.print(q.dequeue() + " "); } StdOut.println("(" + q.size() + " left on queue)"); }
背包是一种不支持从中删除元素的集合数据类型,它的目的是收集元素并迭代遍历全部收集到的元素。使用背包说明元素的处理顺序不重要。
import java.util.Iterator; public class Bag<Item> implements Iterable<Item> { private Node first; private class Node { Item item; Node next; } public void add(Item item) { Node oldfirst = first; first = new Node(); first.item = item; first.next = oldfirst; } public Iterator<Item> iterator() { return new ListIterator(); } private class ListIterator implements Iterator<Item> { private Node current = first; public boolean hasNext() { return current != null; } public void remove() { } public Item next() { Item item = current.item; current = current.next; return item; } } }
基于Java中的currentTimeMillis() 方法,该方法能返回以毫秒计数的当前时间。
本书使用成本模型来评估算法的性质,这个模型定义了算法中的基本操做。例如3-sum问题的成本模型是访问数组元素的次数。
1. 肯定输入模型,定义问题的规模 2. 识别内循环 3. 根据内循环中的操做肯定成本模型 4. 对于给定的输入,判断这些操做的执行频率