1 链表(Linked List)
1.1 单项链表(Singly Linked List)
1.1.1 图例
1.1.2 Java实现
public class ListNode {
// 保存值
int val;
// 保存指针
ListNode next;
// 构造函数们
public ListNode() {
}
public ListNode(int val) {
this.val = val;
}
public ListNode(int val, ListNode next) {
this.val = val;
this.next = next;
}
// 重写toString方法方便输出
@Override
public String toString() {
return "ListNode{" +
"val=" + val +
", next=" + next +
'}';
}
}
1.1.3 常见方法
1) 测试类，创建单项链表并输出
public class ListNodeTest {
public static void main(String[] args) {
// 创建节点
ListNode node1 = new ListNode(1);
ListNode node2 = new ListNode(2);
ListNode node3 = new ListNode(3);
// 连起来
node1.next = node2;
node2.next = node3;
node3.next = null;
// 创建head指向链表头
ListNode head;
head = node1;
System.out.println(head);
}
}
// 输出：ListNode{val=1, next=ListNode{val=2, next=ListNode{val=3, next=null}}}
1.2 双向链表(Doubly Linked List)
1.2.1 图例
1.2.2 Java实现
public class Node {
Node prev;
int data;
Node next;
public Node() {
}
public Node(int data) {
this.data = data;
}
public Node(Node prev, int data, Node next) {
this.prev = prev;
this.data = data;
this.next = next;
}
@Override
public String toString() {
return "Node{" +
"prev=" + prev +
", data=" + data +
", next=" + next +
'}';
}
}
1.2.3 常见方法
1) 测试类，创建双向链表并输出
public class NodeTest {
public static void main(String[] args) {
// 创建节点
Node node1 = new Node(null, 1, null);
Node node2 = new Node(node1, 2, null);
Node node3 = new Node(node2, 3, null);
Node node4 = new Node(node3, 4, null);
// 连起来
node1.next = node2;
node2.next = node3;
node3.next = node4;
// 输出双向链表
// 定义临时node指向表头
Node tmp = node1;
while(tmp != null){
System.out.println(tmp.data);
tmp = tmp.next;
}
}
}
1.3 循环链表
2 二叉树(Binary tree)
2.1 图例
2.2 Java实现
public class TreeNodeTest {
public static void main(String[] args) {
// 创建二叉树并输出
// 创建节点
TreeNode root = new TreeNode(null, 1, null);
TreeNode left = new TreeNode(null,2, null);
TreeNode right = new TreeNode(null, 3, null);
// 连接成树
root.left = left;
root.right = right;
// 输出二叉树
// 先序遍历 中序遍历 后序遍历
}
}
3 栈(Stack FILO：先进后出)
3.1 图例
3.2 Java实现
可以基于数组或链表来构建
public class Stack {
// 数据
Object[] data;
// 当前栈大小
int size;
// 初始化栈
public Stack(int length) {
data = new Object[length];
}
// 入栈
public void push(Object ele){
if(size >= data.length){
throw new RuntimeException("栈已满");
}
data[size] = ele;
size++;
}
// 出栈
public Object pop(){
if(size <= 0){
throw new RuntimeException("栈已空");
}
Object obj = data[size - 1];
data[size - 1] = null;
size--;
return obj;
}
// 遍历输出栈
public void output(){
for(int i = size-1; i >= 0; i--){
System.out.println(data[i]);
}
}
}
3.3 测试类，创建栈并输出
public class StackTest {
public static void main(String[] args) {
// 初始化栈
Stack s = new Stack(3);
// 元素入栈
s.push('A');
s.push('B');
s.push('C');
// 超过容量
// s.push('D');
// 输出
s.output(); // C B A
// 元素出栈
s.pop();
s.pop();
// 输出
s.output(); // A
}
}
4 队列(Queue FIFO：先进先出)
4.1 图例
4.2 Java实现
public class Queue {
// 保存数据
Object[] values;
// 记录存储的元素个数
int size;
// 构造函数
public Queue(int length) {
values = new Object[length];
}
// 向队列中添加元素
public void add(Object ele) {
if(size >= values.length){
throw new RuntimeException("队列已满 添加失败");
}
values[size] = ele;
size++;
}
// 从队头删除元素
public Object get() {
if(size <= 0) {
throw new RuntimeException("队列已空 获取失败");
}
// 取队头元素
Object obj = values[0];
// do something
for(int i = 0; i < size-1; i++){
values[i] = values[i+1];
}
// 最后一个元素置空
values[size - 1] = null;
size--;
return obj;
}
// 输出队列内容
public void output() {
for(int i = 0; i < size; i++){
System.out.println(values[i]);
}
}
}
4.3 测试类，创建队列并输出
public class Queue {
// 保存数据
Object[] values;
// 记录存储的元素个数
int size;
// 构造函数
public Queue(int length) {
values = new Object[length];
}
// 向队列中添加元素
public void add(Object ele) {
if(size >= values.length){
throw new RuntimeException("队列已满 添加失败");
}
values[size] = ele;
size++;
}
// 从队头删除元素
public Object get() {
if(size <= 0) {
throw new RuntimeException("队列已空 获取失败");
}
// 取队头元素
Object obj = values[0];
// do something
for(int i = 0; i < size-1; i++){
values[i] = values[i+1];
}
// 最后一个元素置空
values[size - 1] = null;
size--;
return obj;
}
// 输出队列内容
public void output() {
for(int i = 0; i < size; i++){
System.out.println(values[i]);
}
}
}