1.数据结构与算法——从零开始学习（一）基础概念篇
2. 大话数据结构 – 整理归纳（1）
3. Java数据结构
线性表
public interface List<T> {
public void add(T t);
public void insert(T t, int index);
public T remove(int index);
public boolean isEmpty();
public T get(int index);
public void validate(int index);
public int size();
}
顺序线性表
/**
* 顺序线性表
* 底层由数组实现，存取速度快（通过下标直接获取），插入删除慢（需要扩容缩容）
* @param <T>
*/
public class ArrayList<T> implements List<T> {
public Object[] objects = {};
private int size;
public ArrayList() {
}
public ArrayList(int len) {
objects = new Object[len];
}
@Override
public void add(T t) {
size++;
objects = Arrays.copyOf(objects, size);
objects[size - 1] = t;
}
public void insert(T t, int index) {
if (index < 0 || index > size) {
throw new RuntimeException();
}
size++;
objects = Arrays.copyOf(objects, size + 1);
System.arraycopy(objects, index, objects, index + 1,
size - index - 1);
objects[index] = t;
}
public T remove(int index) {
validate(index);
T t = (T) objects[index];
System.arraycopy(objects, index + 1, objects, index,
size - index - 1);
size--;
objects = Arrays.copyOf(objects, size);
return t;
}
public boolean isEmpty() {
return size == 0;
}
public T get(int index) {
validate(index);
return (T) objects[index];
}
public void validate(int index) {
if (index < 0 || index > size - 1) {
throw new RuntimeException();
}
}
public int size() {
return size;
}
}
单链表
/**
* 单链表存储结构
* @param <E>
*/
@Getter
public class SingleNode<E> {
private E item;
private SingleNode<E> next;
public SingleNode(E element) {
this.item = element;
}
public SingleNode(SingleNode<E> next, E element) {
this.item = element;
this.next = next;
}
public static <E> void addData(E element, SingleNode head) {
//初始化要加入的节点
SingleNode newNode = new SingleNode(element);
//临时节点
SingleNode temp = head;
// 找到尾节点
while (temp.next != null) {
temp = temp.next;
}
// 已经包括了头节点.next为null的情况了～
temp.next = newNode;
}
}
双向链表
/**
* 双向链表
* @param <E>
*/
public class Node<E> {
E item;
Node<E> next;
Node<E> prev;
Node(E element) {
this.item = element;
}
Node(Node<E> prev, E element, Node<E> next) {
this.item = element;
this.prev = prev;
this.next = next;
}
}
/**
* 双向链表
* @param <T>
*/
public class LinkedList<T> implements List<T> {
transient Node<T> first;
transient Node<T> last;
private int size;
@Override
public void add(T t) {
final Node<T> l = last;
final Node<T> temp = new Node<>(l, t, null);
last = temp;
if (l == null) {
first = temp;
} else {
l.next = temp;
}
size++;
}
@Override
public void insert(T t, int index) {
// 获取index的节点
Node<T> temp = getNode(index);
// 创建新节点
Node nodeNew = new Node(temp.prev, t, temp);
temp.prev.next = nodeNew;
temp.prev = nodeNew;
size++;
}
@Override
public T remove(int index) {
// 获取index的节点
Node<T> temp = getNode(index);
temp.prev.next = temp.next;
temp.next.prev = temp.prev;
size--;
return temp.item;
}
@Override
public boolean isEmpty() {
return size == 0;
}
@Override
public T get(int index) {
Node<T> temp = getNode(index);
return temp.item;
}
private Node<T> getNode(int index) {
Node<T> temp;
validate(index);
if (index > size / 2) {
temp = last;
for (int i = size - 1; i > index; i--) {
temp = temp.prev;
}
} else {
temp = first;
for (int i = 1; i <= index; i++) {
temp = temp.next;
}
}
return temp;
}
@Override
public void validate(int index) {
if (index < 0 || index > size - 1) {
throw new RuntimeException();
}
}
@Override
public int size() {
return size;
}
public T getFirst() {
final Node<T> f = first;
if (f == null) {
throw new RuntimeException();
}
return f.item;
}
public T getLast() {
final Node<T> f = last;
if (f == null) {
throw new RuntimeException();
}
return f.item;
}
}
栈
public class Stack<T> implements List<T> {
private Node<T> top;
private Node<T> bottom;
private int size;
public Stack() {
}
public Stack(Node top, Node bottom) {
this.top = top;
this.bottom = bottom;
}
@Override
public void add(Object o) {
Node<T> t = top;
Node<T> newNode = new Node(null, o, t);
top = newNode;
if (t == null) {
bottom = newNode;
} else {
t.prev = newNode;
}
size++;
}
@Override
public void insert(T t, int index) {
// 获取index的节点
Node<T> temp = getNode(index);
// 创建新节点
Node nodeNew = new Node(temp.prev, t, temp);
temp.prev.next = nodeNew;
temp.prev = nodeNew;
size++;
}
@Override
public T remove(int index) {
// 获取index的节点
Node<T> temp = getNode(index);
temp.prev.next = temp.next;
temp.next.prev = temp.prev;
size--;
return temp.item;
}
@Override
public boolean isEmpty() {
return size == 0;
}
@Override
public T get(int index) {
Node<T> node = getNode(index);
return node.item;
}
@Override
public void validate(int index) {
if (index < 0 || index > size - 1) {
throw new RuntimeException();
}
}
@Override
public int size() {
return size;
}
public T getTop() {
final Node<T> f = top;
if (f == null) {
throw new RuntimeException();
}
return f.item;
}
public T getBottom() {
final Node<T> f = bottom;
if (f == null) {
throw new RuntimeException();
}
return f.item;
}
private Node<T> getNode(int index) {
Node<T> temp;
validate(index);
if (index > size / 2) {
temp = top;
for (int i = size - 1; i > index; i--) {
temp = temp.next;
}
} else {
temp = bottom;
for (int i = 1; i <= index; i++) {
temp = temp.prev;
}
}
return temp;
}
}
二叉树
线索二叉树
/**
* 二叉树
*
* 中序遍历
* 先访问根节点，然后访问左节点，最后访问右节点(根->左->右)
* 先序遍历
* 先访问左节点，然后访问根节点，最后访问右节点(左->根->右)
* 后序遍历
* 先访问左节点，然后访问右节点，最后访问根节点(左->右->根)
*
* @param <E>
*/
@Data
public class TreeNode<E> {
TreeNode<E> leftNode;
E item;
TreeNode<E> rightNode;
public TreeNode() {
}
public TreeNode(E item) {
this.item = item;
}
public TreeNode(TreeNode<E> leftNode, E item, TreeNode<E> rightNode) {
this.leftNode = leftNode;
this.item = item;
this.rightNode = rightNode;
}
/**
* 10
* 9 20
* 15 35
*/
/**
* 如果是中序遍历：10->9->20->15->35
*
* 如果是先序遍历：9->10->15->20->35
* 解释：访问完10节点过后，去找的是20节点，但20下还有子节点，因此先访问的是20的左节点15节点。
* 由于15节点没有子节点了。所以就返回20节点，访问20节点。最后访问35节点
*
* 如果是后序遍历：9->15->35->20->10
* 解释：先访问9节点，随后应该访问的是20节点，但20下还有子节点，因此先访问的是20的左节点15节点。
* 由于15节点没有子节点了。所以就去访问35节点，由于35节点也没有子节点了，所以返回20节点，最终返回10节点
*
* @param treeNode
*/
public static void inTraverseBTree(TreeNode treeNode) {
if (treeNode != null) {
System.out.println(treeNode);
//访问左节点
inTraverseBTree(treeNode.getLeftNode());
//访问右节点
inTraverseBTree(treeNode.getRightNode());
}
}
@Override
public String toString() {
return item.toString();
}
}
测试
public class Test1 {
public static void main(String[] args) {
// test(new ArrayList());
// test(new LinkedList());
// test(new Stack());
testTreeNode();
}
public static void testSingleNode() {
SingleNode<String> node = new SingleNode<String>("1");
for (int i = 2; i < 6; i++) {
SingleNode.addData(i + "", node);
}
SingleNode temp = node;
while (temp.getNext() != null) {
System.out.println(temp.getItem());
temp = temp.getNext();
}
}
public static void test(List list) {
System.out.println(list.size());
System.out.println(list.isEmpty());
for (int i = 1; i < 6; i++) {
list.add(i + "");
}
for (int i = 0; i < list.size(); i++) {
System.out.print(list.get(i) + ",");
}
System.out.println();
list.insert("7", 2);
for (int i = 0; i < list.size(); i++) {
System.out.print(list.get(i) + ",");
}
System.out.println();
list.remove(4);
for (int i = 0; i < list.size(); i++) {
System.out.print(list.get(i) + ",");
}
System.out.println();
System.out.println(list.size());
System.out.println(list.isEmpty());
if (list instanceof LinkedList) {
System.out.println(((LinkedList) list).getFirst());
System.out.println(((LinkedList) list).getLast());
}
if (list instanceof Stack) {
System.out.println(((Stack) list).getTop());
System.out.println(((Stack) list).getBottom());
}
System.out.println();
}
/**
* 10
* 9 20
* 15 35
*/
public static void testTreeNode() {
//根节点-->10
TreeNode treeNode1 = new TreeNode(10);
//左-->9
TreeNode TreeNode = new TreeNode(9);
//右-->20
TreeNode treeNode3 = new TreeNode(20);
//20的左-->15
TreeNode treeNode4 = new TreeNode(15);
//20的右-->35
TreeNode treeNode5 = new TreeNode(35);
treeNode1.setLeftNode(TreeNode);
treeNode1.setRightNode(treeNode3);
treeNode3.setLeftNode(treeNode4);
treeNode3.setRightNode(treeNode5);
TreeNode.inTraverseBTree(treeNode1);
}
}
