算法——線性表之鏈式存儲結構

單鏈表：

概念：

1、由於線性表的順序存儲在插入與刪除時需要移動大量元素，適用於不經常改變元素的情況，那么當我們需要經常操作元素時該怎么辦，這就有了接下來的線性表的鏈式存儲結構

2、單鏈表在內存的存儲位置不一定是一段連續的位置，它可以存放在內存中任何地方

3、單鏈表中除了用於存放數據的數據域外，還有存放指針的指針域，指針域的作用是指向鏈表的下一個節點（因為鏈表的元素在內存中的存放時任意位置的，所以需要指向下一個節點）

4、單鏈表第一個節點存儲的位置叫做頭指針，整個單鏈表的存取都是從頭指針開始，單鏈表的最后一個節點是指針指向空（NULL）

 

單鏈表的操作：

package com.alibaba.test03;

import org.junit.jupiter.api.Test;


/**
 * 1.  單鏈表的具體實現及操作
 * @author wydream
 *
 */

public class SingLeLinkedList {

    private int size;//鏈表節點的個數
    private Node head;//頭結點
    
    public SingLeLinkedList() {
        size=0;
        head=null;
    }
    
    //鏈表中的每個節點類
    private class Node{
        private Object data;//每個節點的數據
        private Node next;//每個節點指向下一個節點的連接
        
        public Node(Object data){
            this.data=data;
        }
    }
    
    //在表頭添加元素
    public Object addHead(Object obj) {
        Node newHead=new Node(obj);
        
        if(size==0) {
            head=newHead;
        }else {
            newHead.next=head;
            head=newHead;
        }
        size++;
        return obj;
    }
    
    //在鏈表頭刪除元素
    public Object deleteHead() {
        Object obj=head.data;
        head=head.next;
        size--;
        return obj;
    }
    
    //查找指定元素，找到了返回元素Node，找不到返回Null
    public Node find(Object obj) {
        Node current=head;
        int tempSize=size;
        while(tempSize>0) {
            if(obj.equals(current.data)) {
                return current;
            }else {
                current=current.next;
            }
            tempSize--;
        }
        return null;
    }
    
    
    //刪除指定的元素，刪除成功則返回true
    public boolean delete(Object value) {
        
        if(size==0) {
            return false;
        }
        
        Node current=head;
        Node previous=head;
        while(current.data!=value) {
            if(current.next==null) {
                return false;
            }else {
                previous=current;
                current=current.next;
            }
        }
        
        //如果刪除的是第一個節點
        if(current==head) {
            head=current.next;
            size--;
        }else {//刪除的不是第一個節點
            previous.next=current.next;
            size--;
        }
        return true;
    }
    
    //判斷鏈表是否為空
    public boolean isEmpty() {
        return size==0;
    }
    
    //顯示節點信息
    public void display() {
        if(size>0) {
            Node node=head;
            int tempSize=size;
            if(tempSize==1) {//當前鏈表只有一個節點
                System.out.println("["+node.data+"]");
                return;
            }
            while(tempSize>0) {
                if(node.equals(head)) {
                    System.out.print("["+node.data+"->");
                }else if(node.next==null){
                    System.out.print(node.data+"]");
                }else {
                    System.out.print(node.data+"->");
                }
                node=node.next;
                tempSize--;
            }
            System.out.println();
        }else {//如果鏈表一個節點都沒有，直接打印
            System.out.print("[]");
        }
    }
    
    @Test
    public void test() {
        SingLeLinkedList s=new SingLeLinkedList();
        s.addHead("1");
        s.addHead("2");
        s.addHead("3");
        s.addHead("4");
        s.deleteHead();
        s.display();
    }
    
    
    
    
}

 

有序鏈表：

概念：

• 前面的鏈表實現插入數據都是無序的，在有些應用中需要鏈表中的數據有序，這稱為有序鏈表。
• 在有序鏈表中，數據是按照關鍵值有序排列的。一般在大多數需要使用有序數組的場合也可以使用有序鏈表。有序鏈表優於有序數組的地方是插入的速度（因為元素不需要移動），另外鏈表可以擴展到全部有效的使用內存，而數組只能局限於一個固定的大小中。

 

有序鏈表的實現：

/**
 * 
 * @author wydream
 *
 */

public class OrderLinkedList {
    
    private Node head;

    private class Node{
        private int data;
        private Node next;
        
        public Node(int data) {
            this.data=data;
        }
    }
    
    public OrderLinkedList() {
        head=null;
    }
    
    //插入節點，並按從小到大的順序排列
    public void insert(int value) {
        Node node=new Node(value);
        Node pre=null;
        Node current=head;
        while(current!=null&&value>current.data) {
            pre=current;
            current=current.next;
        }
        if(pre==null) {
            head=node;
            head.next=current;
        }else {
            pre.next=node;
            node.next=current;
        }
    }
    
    //刪除頭節點
    public void deleteHead() {
        head=head.next;
    }
    
    public void display() {
        Node current=head;
        while(current!=null) {
            System.out.println(current.data+" ");
            current=current.next;
        }
        System.out.println("");
    }
    
    
    
}

 

雙向鏈表： 

概念：

我們知道單向鏈表只能從一個方向遍歷，那么雙向鏈表它可以從兩個方向遍歷。

 

雙向鏈表的實現：

import org.junit.jupiter.api.Test;

/**
 *  雙向鏈表的實現
 * @author wydream
 *
 */

public class TwoWayLinkedList {
    
    private Node head;//鏈表頭
    private Node tail;//鏈表尾
    private int size;//鏈表長度
    

    private class Node{
        private Object data;
        private Node next;
        private Node prev;
        
        public Node(Object obj){
            this.data=obj;
        }
        
    }
    
    public TwoWayLinkedList(){
        size=0;
        head=null;
        tail=null;
    }
    
    //在表頭添加新節點
    public void addHead(Object obj) {
        Node node=new Node(obj);
        //如果鏈表長度為零，則添加的這個元素就是頭節點和尾節點
        if(size==0) {
            head=node;
            tail=node;
        }else {
            head.prev=node;
            node.next=head;
            head=node;
        }
        
        size++;
    }
    
    //在鏈表尾添加新節點
    public void addEnd(Object obj) {
        Node newNode=new Node(obj);
        if(size==0) {
            head=newNode;
            tail=newNode;
        }else {
            tail.next=newNode;
            newNode.prev=tail;
            tail=newNode;
        }
        size++;
    }
    
    //刪除鏈表頭
    public Node deleteHead() {
        Node temp=head;
        if(size!=0) {
            head=head.next;
            head.prev=null;
            size--;
        }
        return temp;
    }
    
    
    //刪除鏈表尾
    public void deleteEnd() {
        Node end=tail;
        if(size!=0) {
            tail=tail.prev;
            tail.next=null;
            size--;
        }
    }
    
    
    //獲取鏈表節點個數
    public int getLength() {
        return size;
    }
    
    //判斷鏈表是否為空
    public boolean isEmpty() {
        if(size>0) {
            return true;
        }
        return false;
    }
    
    //顯示節點信息
    public void display() {
        if(size>0) {
            Node node=head;
            int tempSize=size;
            if(tempSize==1) {
                System.out.println("["+node.data+"]");
                return;
            }
            while(tempSize>0) {
                if(node.equals(head)) {
                    System.out.print("["+node.data+"->");
                }else if(node.equals(tail)) {
                    System.out.print(node.data+"]");
                }else {
                    System.out.print(node.data+"->");
                }
                node=node.next;
                tempSize--;
            }
            System.out.println();
        }else {
            System.out.println("[]");
        }
        
    }
    
    @Test
    public void test() {
        TwoWayLinkedList tl=new TwoWayLinkedList();
        tl.addEnd("1");
        tl.addEnd("2");
        tl.addEnd("3");
        tl.addEnd("4");
        tl.deleteHead();
        tl.deleteEnd();
        tl.display();
    }
    
    
}