Java简单数据结构

线性表

顺序存储

理解：一组元素，从逻辑上连续，且存储在连续的物理地址上。在高级编程语言中就是数组。

定义数组arrays，长度为4，初始值都是0。arrays=[0, 0, 0, 0]

int[] arrays = new int[4];

添加元素。arrays=[2, 7, 5, 9]

arrays[0]=2;
arrays[1]=7;
arrays[2]=5;
arrays[3]=9;

插入元素，在位置2插入元素"3"，后面元素后移。arrays1=[2, 7, 3, 5, 9]

//新建数组arrays1
int[] arrays1 = new int[arrays.length+1];
System.arraycopy(arrays,0,arrays1,0,arrays.length);
//元素后移
for(int i=arrays1.length-2;i>1;i--){
    arrays1[i+1] = arrays1[i];
}
//插入元素3
arrays1[2]=3;

删除元素"7"，后面元素前移。arrays=[2, 3, 5, 9]

for(int i=2;i<arrays1.length;i++){
    arrays1[i-1] = arrays1[i];
}
System.arraycopy(arrays1,0,arrays,0,arrays.length);

链式存储

理解：每个元素都有当前类型的引用，来指向下一个元素。

单链表

定义一个单链对象

class ListNode{
    int value; //保存的值
    ListNode next; //下一个元素
}

添加节点，rootNode -> node1 -> node2

ListNode rootNode = new ListNode();
rootNode.value=0;
ListNode node1 = new ListNode();
node1.value=1;
rootNode.next = node1;
ListNode node2 = new ListNode();
node2.value=2;
node1.next = node2;

遍历节点

ListNode currNode = rootNode;
while (currNode!=null){
    System.out.println(currNode.value);
    currNode = currNode.next;
}

删除节点，原理：把待删元素的上一个元素的next指向下一个元素。rootNode -> node2

rootNode.next = node2;//删除node1

循环链表

理解：链表中的最后一个元素的next指向第一个元素，使之头尾相接。

node2.next = rootNode;

双向链表

理解：每个元素都有两个当前类型的引用(prev，next)，prev指向上一个元素，next指向下一个元素。

class ListNode{
    int value;
    ListNode prev;
    ListNode next;
}

栈

理解：仅在一个线性表的一端做操作

定义栈对象

class ListStack{
    String[] data = new String[10];//初始栈深为10
    int top = -1; //初始指针为-1
}

入栈

//入栈
ListStack listStack = new ListStack();
listStack.data[++listStack.top]="A";
listStack.data[++listStack.top]="B";
listStack.data[++listStack.top]="C";

出栈

String topData = listStack.data[listStack.top--];

队列

理解：一个线性表，一端做添加，另一端做删除。

定义队列

class ListQueue{
    String[] data = new String[10];//初始队列长度为10
    int front = -1; //头指针为-1
    int rear = -1; //尾指针为-1
}

入队

//入队
ListQueue queue = new ListQueue();
queue.front = ++queue.rear;
queue.data[queue.rear]="A";
queue.data[++queue.rear]="B";
queue.data[++queue.rear]="C";
queue.data[++queue.rear]="D";

出队

String data = queue.data[queue.front++];

多维数组

理解：就是数组嵌套

定义二维数组

int[][] arrays = {{11,12,13,14},{15,16,17,18},{19,20,21,22},{23,24,25,26},{27,28,29,30},{31,32,33,34}};

//打印
11 12 13 14 
15 16 17 18 
19 20 21 22 
23 24 25 26 
27 28 29 30 
31 32 33 34

数组转置

int[][] reverse = new int[4][6];
for (int i=0;i< arrays.length;i++){
    for(int j=0;j<arrays[i].length;j++){
        //reverse[arrays[i].length-1-j][i]=arrays[i][j];//这个是逆转90度
        reverse[j][i]=arrays[i][j];//这个是转置
    }
}

//打印
11 15 19 23 27 31 
12 16 20 24 28 32 
13 17 21 25 29 33 
14 18 22 26 30 34

矩阵压缩存储

广义表

一组元素中，每个元素不一定必须是原子级数据，形如：[“A”,“B”,“C”,1,2,3,4]。
典型的HashMap就是数组+链表，或者数组+树，形如：[(node -> node1 -> node2)，(二叉树)，(红黑树)]

定义Node对象

class Node{
    int hashCode;
    String key;
    String value;
    Node next;
    Node(String key,String value,Node next){
        this.hashCode = key.hashCode();
        this.key = key;
        this.value = value;
        this.next=next;
        System.out.println(this.hashCode+" "+ this.key);
    }
}

Node数组

Node[] arrays = new Node[10];//长度为10的数组

数组中添加两个Node

arrays[0]= new Node("Aa","Aa-value",null);
arrays[1]= new Node("CC","CC-value",null);

再添加一个Node，此key的hashcode与arrays[0]的一样，需后插node

arrays[0].next=new Node("BB","BB-value",null);

遍历

for(int i =0;i<arrays.length;i++){
    Node node = arrays[i];
    if(node!=null)System.out.println("当前数组下标："+ i);
    Node curr = node;
    for(;curr!=null;curr=curr.next){
        System.out.println(curr.hashCode+" "+ curr.key+" "+curr.value);
    }
}

//打印
当前数组下标：0
2112 Aa Aa-value
2112 BB BB-value
当前数组下标：1
2144 CC CC-value

树

二叉树

理解：

定义ListNode，具有左右node节点。

class ListNode{
    String value;
    ListNode left;
    ListNode right;
}

添加数据，构建一颗树（待增加一张图片，看起来更直观）

ListNode nodeA= new ListNode();
nodeA.value = "A";
ListNode nodeB= new ListNode();
nodeB.value = "B";
nodeA.left=nodeB;

ListNode nodeC= new ListNode();
nodeC.value = "C";
nodeA.right=nodeC;

ListNode nodeD= new ListNode();
nodeD.value = "D";
nodeB.left=nodeD;

ListNode nodeE= new ListNode();
nodeE.value = "E";
nodeB.right=nodeE;

ListNode nodeF= new ListNode();
nodeF.value = "F";
nodeC.left=nodeF;

ListNode nodeG= new ListNode();
nodeG.value = "G";
nodeC.right=nodeG;

ListNode nodeH= new ListNode();
nodeH.value = "H";
nodeD.right=nodeH;

ListNode nodeI= new ListNode();
nodeI.value = "I";
nodeE.right=nodeI;

ListNode nodeJ= new ListNode();
nodeJ.value = "J";
nodeI.left=nodeJ;

ListNode nodeK= new ListNode();
nodeK.value = "K";
nodeI.right=nodeK;

前序遍历，ABDHEIJKCFG

public void preList(ListNode node){
    if(node!=null){
        System.out.print(node.value);
        preList(node.left);
        preList(node.right);
    }
}

中序遍历，DHBEJIKAFCG

public void inList(ListNode node){
    if(node!=null){
        inList(node.left);
        System.out.print(node.value);
        inList(node.right);
    }
}

后序遍历，HDJKIEBFGCA

public void postList(ListNode node){
    if(node!=null){
        postList(node.left);
        postList(node.right);
        System.out.print(node.value);
    }
}

森林

哈夫曼树

图

​