Java，数据结构与集合源码，数据结构概述

package 数据结构.链表.单向链表;


public class Test
{
    public static void main(String[] args)
    {
        Node n1 = new Node("aaa");
        Node n2 = new Node("bbb");
        Node n3 = new Node("ccc");
        n1.next = n2;//记录下一个元素
        n2.next = n3;//记录下一个元素
        //尾节点没有下一个元素，next赋值为null
    }
}
class Node
{
    Object Data;//用于记录本节点的数据
    Node next;//用于记录下一个元素


    public Node()
    {
    }


    public Node(Object data)
    {
        Data = data;
    }
}

双向链表：每个节点有记录上一个节点的信息和记录上一个节点的信息。

模拟双向链表的代码如下：

package 数据结构.链表.双向链表;


public class Test
{
    public static void main(String[] args)
    {
        Node n1 = new Node("aaa");
        Node n2 = new Node("bbb");
        Node n3 = new Node("ccc");
        Node n4 = new Node("ddd");
        Node n5 = new Node("eee");
        n1.next = n2;//记录下一个元素
        //头节点没有上一个元素，prev赋值为null


        n2.next = n3;//记录下一个元素
        n2.prev = n1;//记录上一个元素


        n3.next = n4;//记录下一个元素
        n3.prev = n2;//记录上一个元素


        n4.next = n5;//记录下一个元素
        n4.prev = n3;//记录上一个元素


        n5.prev = n4;//记录上一个元素
        //尾节点没有下一个元素，next赋值为null
    }
}
class Node
{
    Object Data;//用于记录本节点的数据
    Node prev;//用于记录上一个元素
    Node next;//用于记录下一个元素


    public Node()
    {
    }


    public Node(Object data)
    {
        Data = data;
    }
}

二叉树：每个节点分别后来的两条节点，层层递进。

模拟二叉树的代码如下：

package 数据结构.二叉树;


public class Test
{
    public static void main(String[] args)
    {
        TreeNode t1 = new TreeNode("aaa");
        TreeNode t2 = new TreeNode("bbb");
        TreeNode t3 = new TreeNode("ccc");
        TreeNode t4 = new TreeNode("ddd");
        TreeNode t5 = new TreeNode("eee");
        TreeNode t6 = new TreeNode("fff");
        TreeNode t7 = new TreeNode("ggg");
        t1.left = t2;//左分支
        t1.right = t3;//右分支


        t2.parent = t1;//父节点
        t2.left = t4;//左分支
        t2.right = t5;//右分支


        t3.parent = t1;//父节点
        t3.left = t6;//左分支
        t3.right = t7;//右分支


        t4.parent = t2;//父节点
        t5.parent = t2;//父节点


        t6.parent = t3;//父节点
        t7.parent = t7;//父节点
    }
}
class TreeNode
{
    Object Data;//本节点信息
    TreeNode left;//左分支
    TreeNode right;//右分支
    TreeNode parent;//父节点


    public TreeNode()
    {
    }


    public TreeNode(Object data)
    {
        Data = data;
    }
}

结构图如图：

栈：（Stack）又称为堆栈或堆叠，是限制在表的一端进行插入和删除运算的线性表。

最先进入的数据被压入栈底，最后的数据在栈顶。每次删除（退栈），删除的总是当前栈中最后进入（进栈）的元素，而最先插入的数据在栈底，最后退栈。（后进先出，先进后出）

·属于抽象数据类型。

·可以使用数组或链表来构建

栈的模拟代码如下：

package 数据结构.栈;


import java.util.Arrays;


public class Test
{
    public static void main(String[] args)
    {
        Stack ss = new Stack(5);
        ss.push("abc");
        ss.push("def");
        ss.push("ghi");
        System.out.println(Arrays.toString(ss.values));
        ss.pop();
        System.out.println(Arrays.toString(ss.values));
    }
}
class Stack{
    Object[] values;//栈中的元素
    int size;//用来记录存储元素的个数


    public Stack(int length)
    {
        values = new Object[length];
    }
    //入栈
    public void push(Object ele)
    {
        if(size >= values.length)
        {
            throw new RuntimeException("栈空间已满");
        }
        values[size] = ele;
        size++;
    }
    //出栈
    public Object pop()
    {
        if(size <= 0)
        {
            throw new RuntimeException("栈空间已空");
        }
        Object o = values[size - 1];
        values[size - 1] = null;
        size--;
        return o;
    }
}

队列：（queue）

·属于抽象数据类型

·元素的添加获取满足“先进先出”。

队列的模拟代码如下：

package 数据结构.队列;


public class Test
{

}
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 o = values[0];
        //数据前移
        for (int i = 0; i < size - 1; i++)
        {
            values[i] = values[i + 1];
        }
        //最后一个元素置空
        values[size - 1] = null;
        return o;
    }
}

二狗mao

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java，数据结构与集合源码，数据结构概述

package 数据结构.链表.单向链表;//记录下一个元素//记录下一个元素//尾节点没有下一个元素，next赋值为nullclass Node//用于记录本节点的数据Node next;//用于记录下一个元素。
复制链接

扫一扫