2. 程式人生 > >java對單向單向連結串列的操作

java對單向單向連結串列的操作

阿新 • • 發佈：2018-11-15

概述：眾所周知，資料對於資料的儲存時連續的，也就是說在計算機的記憶體中是一個整體的、連續的、不間斷的ADT資料結構。伴隨的問題也會隨之出現，這樣其實對於記憶體的動態分配是不靈活的。而連結串列具備這個優點。因此連結串列對於資料的插入和刪除是方便的，但是對於資料的查詢是麻煩的。因為需要遍歷連結串列，而對於連結串列的遍歷確實極度的麻煩。

1 單向連結串列的定義

連結串列主要用來儲存引用型別的資料。其結構可以由下圖清楚的表示：
這裡寫圖片描述
連結串列結點的定義

class Node{
    // 連結串列中儲存的資料
    public Object obj;
    // 下一個結點的應用
 

    public Node next;
    // 該結點中儲存的資料
    public Node(Object obj){
        this.obj=obj;
    }
    public void  setNext(Node next){
        this.next=next;
    }
    public Node getNext(){
        return this.next;
    }
    public Object getObj(){
        return this.obj;
    }
}

連結串列的設定和取出

/**
 * 對連結串列設定資料和取出資料
 */
 

public class LinkDemo{
    public void static main(String[] args){
        //設定資料
        Node root= new Node("連結串列頭結點");
        Node n1=new Node("連結串列1");
        Node n2=new Node("連結串列2");
        Node n3=new Node("連結串列3");
        // 維護連結串列的關係
        root.setNext(n1);
        n1.setNext(n2);
        n2.setNext(n3);
        // 取出連結串列的資料
 

        Node currentNode=root;// 建立當前結點物件，將根結點賦值給當前結點
        // 判斷當前結點是不是為null,如果當前結點為null,則終止迴圈，否則繼續輸出
        while(currentNode != null){
            // 打印出當前結點的資料，然後修改當前結點的引用
            System.out.println(currentNode.getObj());
            // 將下一個結點設定為當前結點
            currentNode=currentNode.getNext();
        }
    }
}

結果測試如下：
這裡寫圖片描述
使用遞迴的方式優化輸出：

    /**
        *對連結串列設定資料和取出資料
     */
public class LinkDemo{
    public void static main(String[] args){
        //設定資料
        Node root= new Node("連結串列頭結點");
        Node n1=new Node("連結串列1");
        Node n2=new Node("連結串列2");
        Node n3=new Node("連結串列3");
        // 維護連結串列的關係
        root.setNext(n1);
        n1.setNext(n2);
        n2.setNext(n3);
        // 取出連結串列的資料
        Node currentNode=root;// 建立當前結點物件，將根結點賦值給當前結點
        // 判斷當前結點是不是為null,如果當前結點為null,則終止迴圈，否則繼續輸出
        print(root);
    }
    public static print(Node node){
        //遞迴的結束條件
        if(node == null){
            return;
        }else{
            System.out.println(node.getObj());
            print(node.getNext());
        }
    }
}

在實際的開發中，我們希望對於資料的儲存和輸出應該是由如下的形式出現的：

public class LinkDemo3{
    public static void main(){
        Link link=new Link();
        link.add("A");
        link.add("B");
        link.add("C");
        link.add("D");
        // 展示所有的資料
        link.print();
    }
}

此時我們希望讓Node結點類來負責對結點的操作，而Link類類負責對資料的操作。

// 節點類物件
class Node{
    // 結點中的資料
    public Object obj;
    // 結點的下一個引用
    public Node next;
    // 結點中儲存資料
    public Node(Object obj){
        return this.obj=obj;
    }
    public Node getNext(){
        return this.next;
    }
    public void setNext(Node next){
        this.next=next;
    }
    public Object getObj(){
        return this.obj;
    }
    // 新增結點
    public void addNode(Node node){
        // 對於新增結點來說，首先判斷頭節點是否存在下一個的引用，如果為null,此時就可以新增
        // 第一次呼叫該方法，this表示的就是Link.root物件
        if(this.next==null){
            //為空，那麼將該結點掛到頭結點的下一個引用上
            this.next=node;
        }else{
            //頭節點的下一個引用不為空，那麼應該是將當前結點的下一個引用為此node結點
            //遞迴迴圈
            this.next.addNode(node);
        }
    }    
    // 展示所有的結點
    public void printNode(){
        System.out.println(this.obj);
        if(this.next!=null){
            // 如果當前結點對於下一個結點的引用不為空,那麼當前結點物件遞迴呼叫列印方法。
            // 當前結點的下一個引用this.next
            this.next.printNode();
        }
    }
}
// 對連結串列的操作
class Link{
    // 初始化結點物件，即頭結點
    public Node root;
    // 新增資料
    public void add(Object obj){
        //建立當前結點物件，然後儲存資料
        Node currentNode=new Node(obj);
        // 如果要新增資料，就要首先判斷根結點是否為空
        if(root==null){
            //頭節點為空，則將建立的當前結點賦值給根結點
            root=currentNode;
        }else{
            //如果頭結點不為空，此時應該由結點自己來判斷
            //頭節點不為空值，要儲存的資料應該在之後的結點上，呼叫新增結點的方法
            root.addNode(currentNode);
        }
    }
    // 展示所有的資料
    public void print(){
            if(root!=null){
                root.printNode();
            }
    }
}

當我們建立結點物件的時候，對於儲存資料和輸出輸出，我們每次都會判斷根節點是不是空值。這個很重要。當前結點不是根節點這個應該注意到。進一步的優化，注意到我們不希望呼叫者直接操作結點物件，單純的Node類會被直接操作，這樣不符合Java的封裝思想，我們可以使用內部類，並且直接對Node內部類私有化

// 對連結串列的操作
class Link{
    // 初始化結點物件，即頭結點
    public Node root;
    // 新增資料
    public void add(Object obj){
        //建立當前結點物件，然後儲存資料
        Node currentNode=new Node(obj);
        // 如果要新增資料，就要首先判斷根結點是否為空
        if(root==null){
            //頭節點為空，則將建立的當前結點賦值給根結點
            root=currentNode;
        }else{
            //如果頭結點不為空，此時應該由結點自己來判斷
            //頭節點不為空值，要儲存的資料應該在之後的結點上，呼叫新增結點的方法
            root.addNode(currentNode);
        }
    }
    // 展示所有的資料
    public void print(){
            if(root!=null){
                root.printNode();
            }
    }
    // 節點類物件
    private class Node{
        // 結點中的資料
        public Object obj;
        // 結點的下一個引用
        public Node next;
        // 結點中儲存資料
        public Node(Object obj){
            return this.obj=obj;
        }
        // 新增結點
        public void addNode(Node node){
            // 對於新增結點來說，首先判斷頭節點是否存在下一個的引用，如果為null,此時就可以新增
            // 第一次呼叫該方法，this表示的就是Link.root物件
            if(this.next==null){
                //為空，那麼將該結點掛到頭結點的下一個引用上
                this.next=node;
            }else{
                //頭節點的下一個引用不為空，那麼應該是將當前結點的下一個引用為此node結點
                //遞迴迴圈
                this.next.addNode(node);
            }
        }   
        // 展示所有的結點
        public void printNode(){
            System.out.println(this.obj);
            if(this.next!=null){
                // 如果當前結點對於下一個結點的引用不為空,那麼當前結點物件遞迴呼叫列印方法。
                // 當前結點的下一個引用this.next
                this.next.printNode();
            }
        }
    }
}

確定連結串列的資料結構

class Link {
    // 需要結點物件
    private Node root;//根節點物件
    // 結點物件
    //***************內部類*******************
    private class Node {
        private Object obj;//結點中儲存的資料
        private Node next;//下一個結點的引用

        // 結點中的資料
        public Node(Object obj) {
            this.obj = obj;
        }
    }
    //***************內部類*******************
}

新增資料 public void add(Object obj);

class Link {
    // 需要結點物件
    private Node root;//根節點物件
    // 結點物件
    //***************內部類*******************
    private class Node {
        private Object obj;//結點中儲存的資料
        private Node next;//下一個結點的引用

        // 結點中的資料
        public Node(Object obj) {
            this.obj = obj;
        }
        //結點的新增
        public void addNode(Node node){
            if(this.next==null){
            //把當前結點賦值給this.next
                this.next=node;
            }else{
                //新增一個結點
                this.next.addNode(node);
            }
        }
    }
    //***************內部類*******************
    public void add(Object obj){
        //對於資料為null,是可以儲存的，在這裡我假設資料為null是不可以儲存的
        if(obj==null){
            return;
        }
        Node node=new Node(obj);
        if(this.root==null){
            root=node;
        }else{
            //注意：Link類負責根節點的維護和結點的建立，對於結點的具體操作，應該是Node類操作
            this.root.addNode(node);
        }
    }
}

獲取連結串列的長度 public int size();

每一次的資料儲存都需要長度加1.因此我們在Link類中新增組成員變數size.儲存時讓它自增運算；

class Link {
    // 需要結點物件
    private Node root;//根節點物件
    private int size;//連結串列的長度
    // 結點物件
    //***************內部類*******************
    private class Node {
        private Object obj;//結點中儲存的資料
        private Node next;//下一個結點的引用

        // 結點中的資料
        public Node(Object obj) {
            this.obj = obj;
        }
        //結點的新增
        public void addNode(Node node){
            if(this.next==null){
            //把當前結點賦值給this.next
                this.next=node;
            }else{
                //新增一個結點
                this.next.addNode(node);
            }
        }
    }
    //***************內部類*******************
    /**資料的新增*/
    public void add(Object obj){
        //對於資料為null,是可以儲存的，在這裡我假設資料為null是不可以儲存的
        if(obj==null){
            return;
        }
        Node node=new Node(obj);
        if(this.root==null){
            root=node;
        }else{
            //注意：Link類負責根節點的維護和結點的建立，對於結點的具體操作，應該是Node類操作
            this.root.addNode(node);
        }
        this.size++;//長度自增運算
    }
    /**
        *連結串列的長度
        */
    public int size(){
        return this.size;
    }

}

判斷連結串列是否為null,public boolean isEmpty();

  1. 原理1：如果root為null,則連結串列的長度為null

  2. 原理2：如果連結串列的size==0.則連結串列的長度為空

class Link {
    // 需要結點物件
    private Node root;//根節點物件
    private int size;//連結串列的長度
    // 結點物件
    //***************內部類*******************
    private class Node {
        private Object obj;//結點中儲存的資料
        private Node next;//下一個結點的引用

        // 結點中的資料
        public Node(Object obj) {
            this.obj = obj;
        }
        //結點的新增
        public void addNode(Node node){
            if(this.next==null){
            //把當前結點賦值給this.next
                this.next=node;
            }else{
                //新增一個結點
                this.next.addNode(node);
            }
        }
    }
    //***************內部類*******************
    /**資料的新增*/
    public void add(Object obj){
        //對於資料為null,是可以儲存的，在這裡我假設資料為null是不可以儲存的
        if(obj==null){
            return;
        }
        Node node=new Node(obj);
        if(this.root==null){
            root=node;
        }else{
            //注意：Link類負責根節點的維護和結點的建立，對於結點的具體操作，應該是Node類操作
            this.root.addNode(node);
        }
        this.size++;//長度自增運算
    }
    /**
        *連結串列的長度
        */
    public int size(){
        return this.size;
    }
    /**
        *判讀連結串列是否為空
    */
    public boolean isEmpty(){
        return this.size==0?true:flase;
    } 
}

判斷連結串列中是否存在某個元素 public boolean contains(Object obj);

物件的匹配可以使用equals()方法，但是對於自定義物件而言，需要寫compare()方法來自定義匹配結果。
這裡寫圖片描述

class Link {
    // 需要結點物件
    private Node root;//根節點物件
    private int size;//連結串列的長度

    public void add(Object obj) {
        // 建立結點物件，並且儲存資料
        Node newNode = new Node(obj);
        if (root == null) {
            root = newNode;
        } else {
            //此時根節點不為空，需要新增結點
            root.addNode(newNode);
        }
        this.size++;//每次儲存資料，連結串列自增
    }

    /**
     * 連結串列的長度
     * @return
     */
    public int size(){
        return this.size;
    }

    /**
     * 判斷連結串列是否為空
     * @return
     */
    public boolean isEmpty(){
       return this.size==0?true:false;
    }
    public boolean contains(Object obj){
        if(obj==null || this.root==null){
            return false;
        }else {
            // 此時的判斷應該交給Node結點完成
            return root.containsNode(obj);
        }
    }

    public void print() {
        if (root != null) {
            root.printNode();
        }
    }
    private class Node {
        private Object obj;//結點中儲存的資料
        private Node next;//下一個結點的引用

        // 結點中的資料
        public Node(Object obj) {
            this.obj = obj;
        }
        // 結點的儲存
        public void addNode(Node node) {
            if (this.next == null) {//當前結點的下一個結點為空，此時就可以新增結點
                this.next = node;
            } else {
                //否則，此時應該迴圈遞迴新增結點
                // 當前結點物件應該新增新的結點
                this.next.addNode(node);
            }
        }

        // 輸出一個結點
        public void printNode() {
            //列印資料
            System.out.println(this.obj);
            if (this.next != null) {
                this.next.printNode();//遞迴呼叫輸出
            }
        }

        /**
         * 判斷連結串列中受否包含某個元素
         * @param obj
         * @return
         */
        public boolean containsNode(Object obj) {
            if(this.next==null){
                return false;
            }else {
                // 連結串列結點不為空。此時要判斷元素是否匹配
                if(this.obj.equals(obj)){
                    return true;
                }else {
                    return this.next.containsNode(obj);
                }
            }
        }
    }
}

根據索引查詢元素

然後定義get方法；

  1. 查詢有多次，但是每一次的查詢都要將foot屬性設定為0；
  2. 如果當前查詢的索引大於Link類的編號size.此時查詢不到
public Object get(int index){
        //如果當前要查詢的索引大於連結串列的額size.那麼直接返回null
        if(index>this.size){
            return null;
        }
        // 每一的查詢都要將foot從0開始
        this.foot=0;
        // 此後交給Node結點來判斷
        return this.root.getNode(index);
}

getNode(index)的實現

public Object getNode(int index) {
            //外部類Link呼叫內部物件this.foot，外部類直接對內部類的訪問
            // 如果當前結點的編號自增==當前索引
            if(Link.this.foot++==index){
                // 返回資料
                return this.obj;
            }else {
                return this.next.getNode(index);
            }
}

修改連結串列元素，和上述的查詢實現基本一致 public void set(int index,Object obj)； 

public void  set(int index,Object obj){
        if(index>this.size){
            return;
        }
        this.foot=0;
        this.root.setNode(index,obj);
}
public void setNode(int index, Object obj) {
            if(Link.this.foot++==index){
                this.obj=obj;//資料的設定
            }else {
                this.next.setNode(index,obj);
            }
}

總結

NO 方法名稱 型別 備註
1 public void add(Object obj) 普通方法 向連結串列之中新增數
2 public int size() 普通方法 取得連結串列的長度
3 public boolean isEmpty() 普通方法 判斷連結串列是否為空
4 public boolean contains(Object obj) 普通方法 判斷連結串列是否存在某個元素
3 public Object get(int index) 普通方法 根據連結串列索引查詢某個元素
3 public void set(int index,Object obj) 普通方法 修改某個元素

相關推薦

資料結構(三)——單向迴圈連結串列的java實現

單向迴圈連結串列結構就是連結串列的最後一個指標不再是null，而是指向整個連結串列的第一個結點，使連結串列形成一個環。 上程式碼 package likend; /** * Created by yxf on 2018/3/27. * 單向迴圈連結串列 */ publ

單向迴圈連結串列的基本操作

‘’’ 說明：連結串列的本質是列表 連結串列的簡單操作： 基礎方法： is_empty()—判斷是否為空 length（）—測量長度 travel（）—遍歷連結串列 增： add()—頭部插入 1append（）—尾部插入 insert（）—中間某個位置插入 刪

Java 單向連結串列和單向迴圈連結串列的程式碼實現

這個連結串列，以前上學的時候，學c語言，還是資料結構的時候，學過。也許也實現過吧。下面我就簡單記錄下這個連結串列的實現。 單向連結串列跟單向迴圈連結串列的差別就是：單向連結串列是有結束位的，指向null的時候，就到結尾了，但是單向迴圈連結串列，他就是一個圈，要是不設定指定位

單向無頭節點連結串列操作

#include<stdio.h> #include<malloc.h> #include<stdlib.h>  #include<stdbool.h> #define MALLOC(name,type1,type2)\ i

python 資料結構與演算法 day02 單向迴圈連結串列

1. 實現單向迴圈連結串列 class Node(): """定義結點""" def __init__(self,item): self.item=item self.next=None class SingleLoopLinkList(object):

帶有頭結點的單向迴圈連結串列

題目：         建立帶有頭結點的迴圈連結串列，實現插入 、查詢 、 刪除等功能 。 原始碼： #include<iostream> #include<malloc.h> using namespace std; ty

用Python實現單向迴圈連結串列

直接看程式碼，有詳細註解 class Node(object): """節點""" def __init__(self, elem): self.elem = elem self.next = None class SingleCycl

約瑟夫環（使用C語言單向迴圈連結串列來解決）

題目描述 編號為1，2，…，n的n個人按順時針方向圍坐在一張圓桌周圍，每人持有一個密碼（正整數）。一 開始任選一個正整數m作為報數上限值，從第一個人開始按順時針方向自1開始報數，報到m時停止報數，報m的那 個人出列，將他的密碼作為新的m值，從他順時針方向的下一個人開始重新從1報數，

python資料結構與演算法-單向迴圈連結串列

單向迴圈列表與單鏈表的區別是：讓原有單鏈表的尾節點的指標區指向頭結點 單向迴圈連結串列的初始構造：   class SingleLinkList(object): #單向迴圈連結串列 def __init__(self,node=None)

資料結構之鏈式表的實現--單向迴圈連結串列(C語言)

 學習參考: 嚴蔚敏: 《資料結構-C語言版》 單向迴圈連結串列的基本操作 單向迴圈連結串列的建立 單向迴圈連結串列新增結點(頭插法) 單向迴圈連結串列新增結點(尾插法) 單向迴圈連結串列

常見連結串列操作-刪除連結串列倒數第n個節點（JAVA實現）

問題 給出一個單向連結串列，刪除該連結串列倒數第n個節點，並返回頭節點。 例如： 給出連結串列 1->2->3->4->5，n=2 返回連結串列 1->2->3->5 解題思路 最容易想到的演算法： 先遍歷一次連結串列，

常見連結串列操作-求連結串列的中間節點（JAVA實現）

問題 給出任意單向連結串列，找出並返回該連結串列的中間節點。 奇數長度的連結串列，例如：1->2->3->4->5 返回節點 3 偶長度的連結串列，例如：1->2->3->4->5->6 返回節點 4 解題思

利用單向迴圈連結串列結構實現如下記憶體頁置換策略CLOCK Algorithm

利用單向迴圈連結串列結構實現如下記憶體頁置換策略CLOCK Algorithm： 假設緩衝池有6個緩衝頁，以單向迴圈連結串列結構組織，結構如下圖所示。緩衝池初始狀態：所有緩衝頁可用，指標P指向下一個即將被分配的緩衝頁。緩衝池包含的緩衝頁數作為程式執行引數設定，該引數的有效設

資料結構與演算法-----單向線性連結串列（逆轉和反向列印）

單向連結串列沒有前指標，所以實現反向列印還是比較麻煩，我們這裡使用遞迴原理解決此問題。 這裡提到逆轉，也就是將單鏈表的next指標指向前一個節點，我們也使用遞迴實現。 // 練習：實現單向線性連

6. 帶哨兵的單向迴圈連結串列

《演算法導論》10.2-5 使用單向迴圈連結串列實現字典操作 INSERT、DELETE、SEARCH,並給出執行時間。 #include <iostream> #include <string.h> template<typename Object> clas

資料結構作業程式碼儲存-2.1 單向迴圈連結串列的建立，插入和刪除，和指標移動

在此感謝我親愛的大神同學們！一個Z妹子講情了思路，一個M妹子提供了更高階的雙向迴圈連結串列的程式碼借鑑（雖然有些還是沒怎麼看懂。。。 我的作業就完成啦！儲存程式碼當個紀念！ 1，往操作位置順時針的下一位插入一個元素，並將操作位置移到新元素上。 2，刪掉操作位置順時針方

python單向迴圈連結串列

單向迴圈連結串列 單鏈表的一個變形是單向迴圈連結串列，連結串列中最後一個節點的next域不再為None，而是指向連結串列的頭節點。 操作 is_empty() 判斷連結串列是否為空 length() 返回連結串列的長度 travel() 遍歷 add(it

【資料結構】單向迴圈連結串列

寫的中間發現一個問題，我試了一下，final修飾的引用是指該引用只能指向一個物件不能更改指向其他物件，但是該引用調該物件的方法進行內部資訊修改是OK的 package 連結串列.迴圈連結串列; import java.util.NoSuchElement

python 實現單向迴圈連結串列

單向迴圈連結串列 特點： 若連結串列為空，則頭結點的next結點還是指向其本身，即head.next=head； 尾節點的next指標指向head結點，即頭尾相連； 判斷是否遍歷了完，直接判斷next==head即可； 由單鏈表變化的迴圈也成為單向迴圈連結串列

約瑟夫環 單向迴圈連結串列實現

約瑟夫環 已知n個人（以編號1，2，3...n分別表示）圍坐在一張圓桌周圍。從編號為k的人開始報數，數到m的那個人出列；他的下一個人又從1開始報數，數到m的那個人又出列；依此規律重複下去，直到圓桌周圍的人全部出列。 ///迴圈連結串列實現 #include<bits/stdc++.h>