java版算法研究~~~

数据结构：包括线性结构和非线性结构

线性结构：

一、概念

线性结构作为最常用的数据结构，其特点是数据元素之间存在一对一的线性关系。
线性结构拥有两种不同的存储结构，即顺序存储结构和链式存储结构。顺序存储的线性表称为顺序表，顺序表中的存储元素是连续的，链式存储的线性表称为链表，链表中的存储元素不一定是连续的，元素节点中存放数据元素以及相邻元素的地址信息。
线性结构中存在两种操作受限的使用场景，即队列和栈。栈的操作只能在线性表的一端进行，就是我们常说的先进后出（FILO），队列的插入操作在线性表的一端进行而其他操作在线性表的另一端进行，先进先出（FIFO），由于线性结构存在两种存储结构，因 此队列和栈各存在两个实现方式。

非线性结构

 

1 稀疏数组

2 队列

队列是一个有序列表，可以用数组或是链表来实现。 遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入的要后取出

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

链表模型（一个节点既包括数据，也包含指向下一个节点指针也是节点）

单向链表

 一个节点指向另一个节点：

public class Node {//一个节点
    int data;
    Node next;//下一个节点
    
    public Node(int data) {//创建节点的时候赋值
        this.data = data;
    }
//    为节点追加节点
    
       
    public void append(Node node){
        Node currNode=this;
        while (true){
            Node nextNode = currNode.next;
           
            if(nextNode==null){
             break;
            }
            currNode=nextNode;
    
        }
        //跳出while循环当前节点最后没有节点
        currNode.next=node;

    }
    
//    获取下一个节点
    public Node next(){
        return  next;
    }
//删除下一个节点

public void removeNext(){//取出下下个节点，设为当前节点
  Node nextNode =next().next;
   this.next=nextNode;

}

//追加某个节点到当前节点的下一个位置
 public void after(Node node){
        Node next=this.next;//取出当前节点的下一个节点
        this.next=node;//当前节点的下一个节点指向新的节点
        node.next=next;//新的节点下一个节点指向第一步取出的节点
    }
    

    
    public static void main(String[] args) {
        Node node=new Node(1);
        Node node2=new Node(2);
        Node node3=new Node(3);
        node.append(node2);
        node.append(node3);
        System.out.println(node.next().next().data);//3
        node.removeNext();
        System.out.println(node.next().data);//3
        
    }

循环链表

链表是循环的没有最后一个节点。

比如只有一个节点的时候，链表的next指向自身

public class LoopNode {//一个节点
    int data;
    Node next=this;//下一个节点指向自身（开始是一个节点，但是过后肯定要用这一个节点追加节点）
    
//追加某个节点到一个节点之后

public void after(Node node){
Node next =this.next;//取出当前节点的下一个节点,作为下下个节点
this.next=node;//当前节点的下一个节点指向追加的节点
node.next=next;
}
 public static void main(String[] args) {
        Node node=new Node(1);
        Node node2=new Node(2);
       
        node.after(node2);
        System.out.println(node.next.data);//2
        System.out.println(node2.next.data);//1
}
}

 双向链表

 

public class DoubleNode {
    DoubleNode pre=this;// 上一个节点  循环链表时：一个节点的时候都指向自身
    DoubleNode next=this;
    int data;
    public DoubleNode next(){
        return this.next;
    }
    public DoubleNode(int data) {
        this.data = data;
    }
    public void after(DoubleNode node){//赋值语句左边指向右边
        //当前节点的下一个节点
        DoubleNode next = this.next;
        node.pre=this;//node.pre→this 意思是新节点的前一个节点指向当前节点
        this.next=node;
        node.next=next;
        next.pre=node;
    }
    
    public static void main(String[] args) {
    DoubleNode doubleNode=new DoubleNode(1);
    DoubleNode doubleNode2=new DoubleNode(2);
    DoubleNode doubleNode3=new DoubleNode(3);
    doubleNode.after(doubleNode2);
    doubleNode2.after(doubleNode3);
        System.out.println(doubleNode.next.data);//2
        System.out.println(doubleNode.pre.data);//3
        System.out.println(doubleNode3.pre.data);//2
    }
   
}