目 录
P10-2.8栈
1、MyStack.java【int】
package demo2;
public class MyStack {
// 栈的底层我们使用数组来存储数据
int[] elements;
public MyStack() {
elements = new int[0];
}
// 压入元素
public void push(int element) {
// 创建一个新的数组
int[] newArr = new int[elements.length + 1];
// 把原数组中的元素复制到新数组中
for (int i = 0; i < elements.length; i++) {
newArr[i] = elements[i];
}
// 把添加的元素放入新数组中
newArr[elements.length] = element;
// 使用新数组替换旧数组
elements = newArr;
}
// 取出栈顶元素
public int pop() {
// 栈中没有元素
if (elements.length == 0) {
throw new RuntimeException("stack is empty");
}
// 取出数组的最后一个元素
int element = elements[elements.length - 1];
// 创建一个新的数组
int[] newArr = new int[elements.length - 1];
// 原数组中除了最后一个元素的其它元素都放入新的数组中
for (int i = 0; i < elements.length - 1; i++) {
newArr[i] = elements[i];
}
// 替换数组
elements = newArr;
// 返回栈顶元素
return element;
}
// 查看栈顶元素
public int pick() {
// 栈中没有元素
if (elements.length == 0) {
throw new RuntimeException("stack is empty");
}
return elements[elements.length - 1];
}
// 判断栈是否为空
public boolean isEmpty() {
return elements.length == 0;
}
}2、MyStack.java【String】
package demo2;
public class MyStack2 {
// 栈的底层我们使用数组来存储数据
String[] elements;
String[] str;// = new String[] {""};
public MyStack2() {
elements = new String[0];
}
// 压入元素
public void push(String element) {
// 创建一个新的数组
String[] newArr = new String[elements.length + 1];
// 把原数组中的元素复制到新数组中
for (int i = 0; i < elements.length; i++) {
newArr[i] = elements[i];
}
// 把添加的元素放入新数组中
newArr[elements.length] = element;
// 使用新数组替换旧数组
elements = newArr;
}
// 取出栈顶元素
public String pop() {
// 栈中没有元素
if (elements.length == 0) {
throw new RuntimeException("stack is empty");
}
// 取出数组的最后一个元素
String element = elements[elements.length - 1];
// 创建一个新的数组
String[] newArr = new String[elements.length - 1];
// 原数组中除了最后一个元素的其它元素都放入新的数组中
for (int i = 0; i < elements.length - 1; i++) {
newArr[i] = elements[i];
}
// 替换数组
elements = newArr;
// 返回栈顶元素
return element;
}
// 查看栈顶元素
public String pick() {
// 栈中没有元素
if (elements.length == 0) {
throw new RuntimeException("stack is empty");
}
return elements[elements.length - 1];
}
// 判断栈是否为空
public boolean isEmpty() {
return elements.length == 0;
}
}3、TestMyStack.java
package demo2.test;
import demo2.MyStack;
import demo2.MyStack2;
public class TestMyStack {
public static void main(String[] args) {
// 创建一个栈
MyStack ms = new MyStack();
// 压入数组
ms.push(9);
ms.push(8);
ms.push(7);
// 取出栈顶元素
System.out.println(ms.pop());
System.out.println(ms.pop());
System.out.println(ms.pop());
// 查看栈顶元素
// System.out.println(ms.pick());
System.out.println(ms.isEmpty());
System.out.println("/**------------------------------------------*/");
MyStack2 ms2 = new MyStack2();
ms2.push("1one");
ms2.push("2two");
ms2.push("3three");
System.out.println(ms2.pick());
System.out.println(ms2.pop());
System.out.println(ms2.pop());
System.out.println(ms2.pop());
System.out.println(ms.isEmpty());
}
}
P11-2.9队列
1、MyQueue.java
package demo2;
public class MyQueue {
int[] elements;
public MyQueue() {
elements = new int[0];
}
// 入队
public void add(int element) {
// 创建一个新的数组
int[] newArr = new int[elements.length + 1];
// 把原数组中的元素复制到新数组中
for (int i = 0; i < elements.length; i++) {
newArr[i] = elements[i];
}
// 把添加的元素放入新数组中
newArr[elements.length] = element;
// 使用新数组替换旧数组
elements = newArr;
}
// 出队
public int poll() {
// 把数组中的第0个元素取出来
int element = elements[0];
// 创建一个新的数组
int[] newArr = new int[elements.length - 1];
// 复制原数组中的元素到新数组中
for (int i = 0; i < newArr.length; i++) {
newArr[i] = elements[i + 1];
}
// 替换数组
elements = newArr;
return element;
}
// 判断队列是否为空
public boolean isEmpty() {
return elements.length == 0;
}
}2、TestMyQueue.java
package demo2.test;
import demo2.MyQueue;
public class TestMyQueue {
public static void main(String[] args) {
// 创建一个队列
MyQueue mq = new MyQueue();
// 入队
mq.add(9);
mq.add(8);
mq.add(7);
// 出队
System.out.println(mq.poll());
mq.add(6);
System.out.println(mq.poll());
System.out.println(mq.poll());
System.out.println(mq.isEmpty());
System.out.println(mq.poll());
}
}
P12-2.10单链表
java中 对象类型的引用中存储的数据，是 下一个对象的地址。
1、Node.java
package demo2;
//一个节点
public class Node {
// 节点内容
int data;
// 下一个节点
Node next;
public Node(int data) {
this.data = data;
}
// 为节点追回节点
public Node append(Node node) {
// 当前节点
Node currentNode = this;
// 循环向后找
while (true) {
// 取出下一个节点
Node nextNode = currentNode.next;
// 如果下一个节点为null,当前节点已经是最后一个节点
if (nextNode == null) {
break;
}
// 赋给当前节点
currentNode = nextNode;
}
// 把需要追回的节点追加为找到的当前节点的下一个节点
currentNode.next = node;
return this;
}
// 插入一个节点做为当前节点的下一个节点
public void after(Node node) {
// 取出下一个节点，作为下下一个节点
Node nextNext = next;
// 把新节点作为当前节点的下一个节点
this.next = node;
// 把下下一个节点设置为新节点的下一个节点
node.next = nextNext;
}
// 显示所有节点信息
public void show() {
Node currentNode = this;
while (true) {
System.out.print(currentNode.data + " ");
// 取出下一个节点
currentNode = currentNode.next;
// 如果是最后一个节点
if (currentNode == null) {
break;
}
}
System.out.println();
}
// 删除下一个节点
public void removeNext() {
// 取出下下一个节点
Node newNext = next.next;
// 把下下一个节点设置为当前节点的下一个节点。
this.next = newNext;
}
// 获取下一个节点
public Node next() {
return this.next;
}
// 获取节点中的数据
public int getData() {
return this.data;
}
// 当前节点是否是最后一个节点
public boolean isLast() {
return next == null;
}
}2、TestNode.java
package demo2.test;
import demo2.Node;
public class TestNode {
public static void main(String[] args) {
// 创建节点
Node n1 = new Node(1);
Node n2 = new Node(2);
Node n3 = new Node(3);
// 追加节点
n1.append(n2).append(n3).append(new Node(4));
// 取出下一个节点的数据
System.out.println(n1.next().next().next().getData());
// 判断节点是否为最后一个节点
System.out.println(n1.isLast());
System.out.println(n1.next().next().next().isLast());
// 显示所有节点内容
n1.show();
// 删除一个节点
n1.next().removeNext();
// 显示所有节点内容
n1.show();
// 插入一个新节点
Node node = new Node(5);
n1.next().after(node);
n1.show();
}
}
P13-2.11删除单链表中的节点
P14-2.12往单链表中插入节点
节点4 插入到 2、3之间！
P15-2.13循环链表
1、LoopNode.java
package demo2;
//一个节点
public class LoopNode {
// 节点内容
int data;
// 下一个节点
LoopNode next = this;
public LoopNode(int data) {
this.data = data;
}
// 插入一个节点做为当前节点的下一个节点
public void after(LoopNode node) {
// 取出下一个节点，作为下下一个节点
LoopNode nextNext = next;
// 把新节点作为当前节点的下一个节点
this.next = node;
// 把下下一个节点设置为新节点的下一个节点
node.next = nextNext;
}
// 删除下一个节点
public void removeNext() {
// 取出下下一个节点
LoopNode newNext = next.next;
// 把下下一个节点设置为当前节点的下一个节点。
this.next = newNext;
}
// 获取下一个节点
public LoopNode next() {
return this.next;
}
// 获取节点中的数据
public int getData() {
return this.data;
}
}2、TestLoopNode.java
package demo2.test;
import demo2.LoopNode;
public class TestLoopNode {
public static void main(String[] args) {
LoopNode n1 = new LoopNode(1);
LoopNode n2 = new LoopNode(2);
LoopNode n3 = new LoopNode(3);
LoopNode n4 = new LoopNode(4);
// 增加节点
n1.after(n2);
n2.after(n3);
n3.after(n4);
System.out.println(n1.next().getData());
System.out.println(n2.next().getData());
System.out.println(n3.next().getData());
System.out.println(n4.next().getData());
}
}
P16-2.14双向循环链表
1、图解
2、DoubleNode.java
package demo2;
public class DoubleNode {
// 上一个节点
DoubleNode pre = this;
// 下一个节点
DoubleNode next = this;
// 节点数据
int data;
public DoubleNode(int data) {
this.data = data;
}
// 增节点
public void after(DoubleNode node) {
// 原来的下一个节点
DoubleNode nextNext = next;
// 把新节点做为当前节点的下一个节点
this.next = node;
// 把当前节点做新节点的前一个节点
node.pre = this;
// 让原来的下一个节点作新节点的下一个节点
node.next = nextNext;
// 让原来的下一个节点的上一个节点为新节点
nextNext.pre = node;
}
// 下一个节点
public DoubleNode next() {
return this.next;
}
// 上一个节点
public DoubleNode pre() {
return this.pre;
}
// 获取数据
public int getData() {
return this.data;
}
}3、TestDoubleNode.java
package demo2.test;
import demo2.DoubleNode;
public class TestDoubleNode {
public static void main(String[] args) {
// 创建节点
DoubleNode n1 = new DoubleNode(1);
DoubleNode n2 = new DoubleNode(2);
DoubleNode n3 = new DoubleNode(3);
System.out.println(n1.pre().getData());
System.out.println(n1.getData());
System.out.println(n1.next().getData());
// 追加节点
n1.after(n2);
n2.after(n3);
// 查看上一个、自己、下一个节点的内容
System.out.println(n2.pre().getData());
System.out.println(n2.getData());
System.out.println(n2.next().getData());
System.out.println(n3.next().getData());
System.out.println(n1.pre().getData());
}
}
P17-2.15递归和斐波那契
1、TestRecursive.java
package demo3;
public class TestRecursive {
public static void main(String[] args) {
print(10);
}
// 递归
public static void print(int i) {
// if (i > 0) {
System.out.println(i);
print(i - 1);
// }
}
}2、TestFebonacci.java
package demo3;
public class TestFebonacci {
public static void main(String[] args) {
// 斐波那契数列：1 1 2 3 5 8 13
int i = febonacci(7);
System.out.println(i);
}
// 打印第n项斐波那契数列
public static int febonacci(int i) {
if (i == 1 || i == 2) {
return 1;
} else {
return febonacci(i - 1) + febonacci(i - 2);
}
}
}P18-2.16汉诺塔问题
汉诺塔小游戏：http://www.4399.com/flash/109504_1.htm
无论有多少个盘子，都认为只有两个！上面的所有盘子和最下面一个盘子。
package demo3;
public class TestHanoi {
public static void main(String[] args) {
hanoi(5, 'A', 'B', 'C');
}
/**
* @param n 共有N个盘子
* @param from 开始的柱子
* @param in 中间的柱子
* @param to 目标柱子 无论有多少个盘子，都认为只有两个。上面的所有盘子和最下面一个盘子。
*/
public static void hanoi(int n, char from, char in, char to) {
// 只有一个盘子。
if (n == 1) {
System.out.println("第1个盘子从" + from + "移到" + to);
// 无论有多少个盘子，都认为只有两个。上面的所有盘子和最下面一个盘子。
} else {
// 移动上面所有的盘子到中间位置
hanoi(n - 1, from, to, in);
System.out.println("第" + n + "个盘子从" + from + "移到" + to);
// 移动下面的盘子
// 把上面的所有盘子从中间位置移到目标位置
hanoi(n - 1, in, from, to);
}
}
}蟹蟹观看~~~