11 基本数据结构
code前要说的话
每次都是code后会有感想,这次却是code前有话要说。
“数据结构”是大学计算机里一个72课时的主干课程,教科书里的伪代码基本类似Pascal,也有用C来实现的。
而我现在要用Java来实现却遇到一点小问题。
首先,Java的基本API里面,各种数据结构非常完备,如果我只是抄袭一遍,将没有任何意义。然而,由于已经浏览过那些API,所以实现《算法导论》的数据结构伪代码时,不受Java底层API的影响,是不可能的。
其次,如果是C,那么很多都是指针操作,我反而不用去考虑指针指向的那个区域是什么类型(一般是个struct)。而Java这种面向对象的语言,到了现在又支持泛型。
我以前的排序算法的Java实现里,尽量都支持了泛型。但是现在,考虑到很多的数据结构的存储都是用数组,数组加泛型,我尽量去做,但是会不会遇到问题?我实在没有把握。
11.1 栈和队列
伪代码:
STACK-EMPTY(S)
Java代码:
10 9 8 7 6 5 4 3 2 1 0
code后感
用Java实现的时候,我以伪代码为基准,同时参照了java.util.Stack和java.util.Vector的源代码。
《算法导论》的原文里有一句“不考虑栈溢出的问题”,但是我的实现却不能不考虑。毕竟现在这些代码不仅仅是研究用的,大部分可以直接运用在实际项目中。
所以,ensureCapacityHelper这个函数被我原封不动的copy过来用。这个函数的作用就是,当栈上溢的时候,扩张栈的大小。类似的操作,在别的数据结构里还会出现。
在参考了Java底层的API之后,我们会发现:当栈上溢的时候,ensureCapacityHelper被调用,但是当pop被调用时,栈的大小不会被变小,虽然有这么一句“objs[count] = null;”,GC会释放栈元素占用的内存,但是栈本身占用的空间不会缩小。
所以在实际运用中,如果是使用Java的API的话,Stack一旦被用完,最好释放掉,不要重复利用。如果是自己动手实现Stack,最好在pop之后,有个timing,按照capacityIncrement,去减小数据区的大小。
伪代码:
Java代码:
输出:
0 1 2 3 4 5 6 7 10 11 12 13 14 15 16 17 18
code后感
简短的伪代码的Java实现如此冗长,原因在于要考虑溢出。
入队时,如果溢出,我也使用了ensureCapacityHelper来扩张objs数组,并且调整指针head,以及移动相应的数组内容。
出队和栈的pop一样,如果objs数组被扩张过,也不会恢复。所以,也一样可以考虑在某个timing缩小objs数组。
11.2 链表
Java代码:
输出:
1
4
code后感
我仿照了LinkedList的代码,定义了内部类Entry。因为Java没有指针,所以在一个实体上加类Entry类型的next和previous,来指向前一个实体和后一个实体。
哨兵(Sentinels)
Java代码:
忽略
code后感
我忽略了哨兵的链表的Java实现,却要写code后感,看上去有点滑稽。
实际上,前面非哨兵的链表Java程序里,header这个Entry在伪代码里是个函数,它恰好就可以充当哨兵nil[L],所以只要稍微改写一下前面的代码,就可以把一个双向链表变成一个双向环链表。除非后面的应用有需要环链表,否则我不打算实现这段伪代码了。
code前要说的话
每次都是code后会有感想,这次却是code前有话要说。
“数据结构”是大学计算机里一个72课时的主干课程,教科书里的伪代码基本类似Pascal,也有用C来实现的。
而我现在要用Java来实现却遇到一点小问题。
首先,Java的基本API里面,各种数据结构非常完备,如果我只是抄袭一遍,将没有任何意义。然而,由于已经浏览过那些API,所以实现《算法导论》的数据结构伪代码时,不受Java底层API的影响,是不可能的。
其次,如果是C,那么很多都是指针操作,我反而不用去考虑指针指向的那个区域是什么类型(一般是个struct)。而Java这种面向对象的语言,到了现在又支持泛型。
我以前的排序算法的Java实现里,尽量都支持了泛型。但是现在,考虑到很多的数据结构的存储都是用数组,数组加泛型,我尽量去做,但是会不会遇到问题?我实在没有把握。
11.1 栈和队列
伪代码:
STACK-EMPTY(S)
1 if top[S] = 0
2 then return TRUE
3 else return FALSE
PUSH(S, x)
1 top[S] ← top[S] + 1
2 S[top[S]] ← x
POP(S)
1 if STACK-EMPTY(S)
2 then error "underflow"
3 else top[S] ← top[S] - 1
4 return S[top[S] + 1]
Java代码:
import java.util.Arrays;
import java.util.EmptyStackException;
public class Stack<E> {
private int count;
private Object[] objs;
private int capacityIncrement;
private int top() {
return count;
}
private void ensureCapacityHelper(int minCapacity) {
int oldCapacity = objs.length;
if (minCapacity > oldCapacity) {
int newCapacity = (capacityIncrement > 0) ? (oldCapacity + capacityIncrement)
: (oldCapacity * 2);
if (newCapacity < minCapacity) {
newCapacity = minCapacity;
}
objs = Arrays.copyOf(objs, newCapacity);
}
}
public boolean isEmpty() {
return top() == 0;
}
public synchronized E push(E item) {
ensureCapacityHelper(count + 1);
objs[count++] = item;
return item;
}
@SuppressWarnings("unchecked")
public synchronized E pop() {
if (isEmpty())
throw new EmptyStackException();
else {
Object obj = (E) objs[count - 1];
count--;
objs[count] = null;
return (E) obj;
}
}
public Stack() {
this(10);
}
public Stack(int initialCapacity) {
this(initialCapacity, 0);
}
public Stack(int initialCapacity, int capacityIncrement) {
objs = new Object[initialCapacity];
}
public static void main(String[] args) {
Stack<Integer> stack = new Stack<Integer>();
for (int i = 0; i < 11; i++) {
stack.push(i);
}
while (!stack.isEmpty()) {
System.out.print(stack.pop() + " ");
}
}
}
10 9 8 7 6 5 4 3 2 1 0
code后感
用Java实现的时候,我以伪代码为基准,同时参照了java.util.Stack和java.util.Vector的源代码。
《算法导论》的原文里有一句“不考虑栈溢出的问题”,但是我的实现却不能不考虑。毕竟现在这些代码不仅仅是研究用的,大部分可以直接运用在实际项目中。
所以,ensureCapacityHelper这个函数被我原封不动的copy过来用。这个函数的作用就是,当栈上溢的时候,扩张栈的大小。类似的操作,在别的数据结构里还会出现。
在参考了Java底层的API之后,我们会发现:当栈上溢的时候,ensureCapacityHelper被调用,但是当pop被调用时,栈的大小不会被变小,虽然有这么一句“objs[count] = null;”,GC会释放栈元素占用的内存,但是栈本身占用的空间不会缩小。
所以在实际运用中,如果是使用Java的API的话,Stack一旦被用完,最好释放掉,不要重复利用。如果是自己动手实现Stack,最好在pop之后,有个timing,按照capacityIncrement,去减小数据区的大小。
伪代码:
ENQUEUE(Q, x)
1 Q[tail[Q]] ← x
2 if tail[Q] = length[Q]
3 then tail[Q] ← 1
4 else tail[Q] ← tail[Q] + 1
DEQUEUE(Q)
1 x ← Q[head[Q]]
2 if head[Q] = length[Q]
3 then head[Q] ← 1
4 else head[Q] ← head[Q] + 1
5 return x
Java代码:
import java.util.Arrays;
import java.util.NoSuchElementException;
public class Queue<E> {
private int head = 0;
private int tail = 0;
private Object[] objs;
private int capacityIncrement;
public boolean isEmpty() {
return head == tail;
}
public synchronized void enqueue(E item) {
objs[tail] = item;
if (tail == objs.length - 1)
tail = 0;
else
tail++;
if (tail == head) {
int oldLength = objs.length;
ensureCapacityHelper(objs.length + 1);
for (int i = tail; i < oldLength; i++) {
objs[i + objs.length - oldLength] = objs[i];
}
head += objs.length - oldLength;
}
}
@SuppressWarnings("unchecked")
public synchronized E dequeue() {
if (isEmpty())
throw new NoSuchElementException();
Object obj = objs[head];
if (head == objs.length - 1)
head = 0;
else
head++;
return (E) obj;
}
private void ensureCapacityHelper(int minCapacity) {
int oldCapacity = objs.length;
if (minCapacity > oldCapacity) {
int newCapacity = (capacityIncrement > 0) ? (oldCapacity + capacityIncrement)
: (oldCapacity * 2);
if (newCapacity < minCapacity) {
newCapacity = minCapacity;
}
objs = Arrays.copyOf(objs, newCapacity);
}
}
public Queue() {
this(10);
}
public Queue(int initialCapacity) {
this(initialCapacity, 0);
}
public Queue(int initialCapacity, int capacityIncrement) {
objs = new Object[initialCapacity];
}
public static void main(String[] args) {
Queue<Integer> queue = new Queue<Integer>();
for (int i = 0; i < 8; i++)
queue.enqueue(i);
for (int i = 0; i < 4; i++)
System.out.print(queue.dequeue() + " ");
for (int i = 0; i < 9; i++)
queue.enqueue(i + 10);
while (!queue.isEmpty())
System.out.print(queue.dequeue() + " ");
}
}
输出:
0 1 2 3 4 5 6 7 10 11 12 13 14 15 16 17 18
code后感
简短的伪代码的Java实现如此冗长,原因在于要考虑溢出。
入队时,如果溢出,我也使用了ensureCapacityHelper来扩张objs数组,并且调整指针head,以及移动相应的数组内容。
出队和栈的pop一样,如果objs数组被扩张过,也不会恢复。所以,也一样可以考虑在某个timing缩小objs数组。
11.2 链表
LIST-SEARCH(L, k)
1 x ← head[L]
2 while x ≠ NIL and key[x] ≠ k
3 do x ← next[x]
4 return x
LIST-INSERT(L, x)
1 next[x] ← head[L]
2 if head[L] ≠ NIL
3 then prev[head[L]] ← x
4 head[L] ← x
5 prev[x] ← NIL
LIST-DELETE(L, x)
1 if prev[x] ≠ NIL
2 then next[prev[x]] ← next[x]
3 else head[L] ← next[x]
4 if next[x] ≠ NIL
5 then prev[next[x]] ← prev[x]
Java代码:
public class List<E> {
private transient Entry<E> header = new Entry<E>(null);
public static class Entry<E> {
E element;
Entry<E> next;
Entry<E> previous;
Entry(E element) {
this.element = element;
}
}
public Entry<E> search(E x) {
if (x == null)
return null;
Entry<E> entry = header;
while (entry != null && !x.equals(entry.element))
entry = entry.next;
return entry;
}
public Entry<E> insert(E x) {
Entry<E> newEntry = new Entry<E>(x);
newEntry.next = header;
if (header != null)
header.previous = newEntry;
header = newEntry;
newEntry.previous = null;
return newEntry;
}
public void delete(E x) {
Entry<E> entry = search(x);
if (entry.previous != null)
entry.previous.next = entry.next;
else
header = entry.next;
if (entry.next != null)
entry.next.previous = entry.previous;
}
public static void main(String[] args) {
List<Integer> ll = new List<Integer>();
ll.insert(1);
ll.insert(2);
ll.insert(3);
ll.insert(4);
ll.delete(3);
Entry<Integer> e = ll.search(2);
System.out.println(e.next.element);
System.out.println(e.previous.element);
}
}
输出:
1
4
code后感
我仿照了LinkedList的代码,定义了内部类Entry。因为Java没有指针,所以在一个实体上加类Entry类型的next和previous,来指向前一个实体和后一个实体。
哨兵(Sentinels)
LIST-DELET′ (L, x)
1 next[prev[x]] ← next[x]
2 prev[next[x]] ← prev[x]
LIST-SEARC′(L, k)
1 x ← next[nil[L]]
2 while x ≠ nil[L] and key[x] ≠ k
3 do x ← next[x]
4 return x
LIST-INSER′ (L, x)
1 next[x] ← next[nil[L]]
2 prev[next[nil[L]]] ← x
3 next[nil[L]] ← x
4 prev[x] ← nil[L]
Java代码:
忽略
code后感
我忽略了哨兵的链表的Java实现,却要写code后感,看上去有点滑稽。
实际上,前面非哨兵的链表Java程序里,header这个Entry在伪代码里是个函数,它恰好就可以充当哨兵nil[L],所以只要稍微改写一下前面的代码,就可以把一个双向链表变成一个双向环链表。除非后面的应用有需要环链表,否则我不打算实现这段伪代码了。