2. 程式人生 > 實用技巧 >java-單鏈表

java-單鏈表

阿新 • • 發佈：2020-09-16

Node 類：

public class Node {
    public int data;
    public Node next=null;
    public Node(){
        data=2147483647;
        next=null;
    }
    //建構函式
    public Node(int data){
        this.data=data;
    }

}

MyLinkedList類

//連結串列操作

//1-基礎
//是否空
//連結串列長度-用成員變量表示，增刪操作同步（效果同調用函式遍歷）

//2-操作
//新增節點-末尾
//插入節點-索引

 
//根據索引刪除節點
//根據值-刪除節點（所有）
//根據值-刪除重複節點（除了第一個所有）
//根據值-刪除節點（第一個）
//更新節點
//清空連結串列

//3-查詢
//表中是否存在某值
//根據索引獲取某一節點值
//根據值獲取節點索引[陣列]
//根據值獲取第一個節點索引

//4-遍歷
//正向遍歷
//反轉連結串列
//反向遍歷

//5-判斷
//建立有環連結串列
//是否有環
//去除重複元素，

//連結串列排序

import java.util.ArrayList;

public class MyLinkedList {
    private int length=0;
    private Node head=new Node();

    
 
//建構函式預設就行，建立再新增節點

    //是否空
    public boolean isEmpty(){
        if(this.length==0)
            return true;
        else
            return false;
    }
    //新增節點-末尾
    public void add(int data){
        Node newNode=new Node(data);
        Node p=this.head;
        //空表
        if(length==0){
            head.next
 
=newNode;
        }
        //非空表
        else{
            //遍歷至連結串列尾部
            while(p.next!=null)
                p=p.next;
            p.next=newNode;
        }
        this.length++;
    }
    //插入節點-索引  [1-length+1]
    public void insert(int index,int data){
        Node p=this.head;
        Node newNode=new Node(data);
        //插入位置保錯
        if(index<1||index>length+1){
            System.out.println("插入位置出錯");
        }
        //插在末尾
        else if(index==length+1){
            this.add(data);
        }
        //插在表頭
        else if(index==1){
            newNode.next=head.next;
            head.next=newNode;
            length++;
        }
        else{
            //遍歷到插入位置前
            for(int i=0;i<index-1;i++){
                p=p.next;
            }
            newNode.next=p.next;
            p.next=newNode;
            length++;
        }
    }
    //根據索引刪除節點
    public void delete(int index){
        if(!isEmpty()){
            //插入位置保錯
            if(index<1||index>length){
                System.out.println("刪除位置出錯");
            }
            //刪除頭節點
            else if(index==1){
                Node p=head.next;
                head.next=p.next;
                length--;
            }
            else{
                //遍歷至待刪節點前
                Node p=head;
                for(int i=0;i<index-1;i++){
                    p=p.next;
                }

                Node dp=p.next;
                p.next=dp.next;
                length--;
            }
        }
        else
            System.out.println("連結串列空，無法進行刪除操作");
    }
    //根據值-刪除節點（所有）
    public void deleteall(int data){
        ArrayList<Integer> indexs=getAllIndex(data);
        if(indexs.size()==0){
            return;
        }else{
            //從後往前刪除，不用變index;
            for(int i=indexs.size()-1;i>=0;i--){
                delete(indexs.get(i));
            }
        }
    }//根據值-刪除重複節點（除了第一個所有）
    public void deletellARepeat(int data){
        ArrayList<Integer> indexs=getAllIndex(data);
        if(indexs.size()==0){
            return;
        }else{
            //從後往前刪除，不用變index;留下index[0]即可
            for(int i=indexs.size()-1;i>=1;i--){
                delete(indexs.get(i));
            }
        }
    }
    //根據值-刪除節點（第一個）
    public void deletefirst(int data){
        int index=getFirstIndex(data);
        if(index==-1){
            return;
        }else{
            delete(index);
        }
    }
    //更新節點
    public void update(int index,int data){
        if(!isEmpty()){
            //更新位置保錯
            if(index<1||index>length){
                System.out.println("更新位置出錯");
            }
            else if(index==1){
               head.next.data=data;
            }
            else{
                //遍歷至更新節點
                Node p=head;
                for(int i=0;i<index;i++){
                    p=p.next;
                }
                p.data=data;
            }
        }else
            System.out.println("連結串列空，無法進行更新操作");

    }
    //清空連結串列
    public void clear(){
        head.next=null;
        length=0;
    }
    //表中是否存在某值
    public boolean isHave(int data){
        if(!isEmpty()){
            Node p=head;
            while(p.next!=null){
                p=p.next;
                if(p.data==data)
                    return true;
            }
            return false;
        }else{
            System.out.println("連結串列空，無資料");
            return false;
        }
    }
    //根據索引獲取某一節點值
    public int getData(int index){
        if(!isEmpty()){
            if(index<1||index>length){
                System.out.println("index出錯");
                return -1;
            }
            else if(index==1){
                return head.next.data;
            }
            else{
                //遍歷至待刪節點前
                Node p=head;
                for(int i=0;i<index;i++){
                    p=p.next;
                }
                return p.data;
            }
        }else{
            System.out.println("連結串列空，無資料");
            return -1;
        }
    }
    //根據值獲取節點索引[陣列]
    public ArrayList<Integer> getAllIndex(int data){
        ArrayList<Integer> indexs=new ArrayList<Integer>();
        if(isHave(data)){
            Node p=head;
            int i=0;
            while(p.next!=null){
                p=p.next;
                i++;
                if(p.data==data)
                    indexs.add(i);
            }
            return indexs;
        }else {
            System.out.println("連結串列無此資料");
            ArrayList<Integer> in=new ArrayList<Integer>();
            return in;
        }
    }
    //根據值獲取第一個節點索引
    public int getFirstIndex(int data){
        if(isHave(data)){
            //遍歷到節點
            Node p=head;
            int i=0;
            while(p.next!=null){
                p=p.next;
                i++;
                if(p.data==data)
                    break;
            }
            return i;
        }else {
            System.out.println("連結串列無此資料");
            return -1;
        }
    }
    //正向遍歷
    public void print_1(){
        if(!isEmpty()){
            System.out.print("連結串列為：");
            Node p=head;
            while(p.next!=null){
                p=p.next;
                System.out.print(p.data+"->");
            }
            System.out.println("null");
        }else
            System.out.println("連結串列空，無資料，無輸出");
    }
    //反轉連結串列
    public MyLinkedList reverse(MyLinkedList myLinkedList){
        if(!isEmpty()){
            if(length==1)
                return myLinkedList;
            else{
                Node curNode=head.next;
                Node preNode=null;
                while(curNode!=null){
                    Node nextNode=curNode.next;
                    curNode.next=preNode;
                    preNode=curNode;
                    curNode=nextNode;
                }
                head.next=preNode;
                return myLinkedList;
            }
        }else{
            System.out.println("連結串列空，無法反轉");
            MyLinkedList mylist=new MyLinkedList();
            return mylist;
        }

    }
    //反向遍歷
    //反轉-正向遍歷
    //正向遍歷，入棧-出棧
    public void print_2(){
        if(!isEmpty()){
            MyLinkedList mylist1=reverse(this);
            MyLinkedList mylist=reverse(mylist1);
            System.out.print("反轉");
            mylist.print_1();
        }else
            System.out.println("連結串列空，無資料，無輸出");
    }

    //建立有環連結串列
    //將最後一個節點next指向前一個
    public void toRinged(){
        Node curNode=head;
        Node nextNode=curNode.next;
        while(curNode.next!=null&&curNode.next.next!=null){
            curNode=nextNode;
            nextNode=nextNode.next;
        }
        nextNode.next=curNode;
    }
    //是否有環
    //判斷連結串列是否有環：
    //設定快指標和慢指標，慢指標每次走一步，快指標每次走兩步
    //當快指標與慢指標相等時，就說明該連結串列有環
    public boolean isRinged(){
        if(!isEmpty()){
            if(length==1){
                System.out.println("連結串列長度=1，無環");
                return false;
            }else{
                Node slow=head;
                Node fast=head;
                while(fast.next!=null&&fast.next.next!=null){
                    slow=slow.next;
                    fast=fast.next.next;
                    if(fast==slow)
                        return true;
                }
                return false;
            }
        }else{
            System.out.println("連結串列空，無環");
            return false;
        }
    }
    //去除重複元素
    public void deleteRepeatData(){
        if(length<2){
            System.out.println("連結串列長度<2，無重複資料");
        }else{
            MyLinkedList mylist=new MyLinkedList();
            Node p=head.next;
            //將原連結串列中無重複資料新增到新連結串列；
            mylist.add(p.data);
            while(p.next!=null){
               p=p.next;
               //System.out.print(p.data+" "+!mylist.isHave(p.data)+ " ");
               if(!mylist.isHave(p.data))
                   mylist.add(p.data);
            }
            //對新連結串列的每一個data執行this(原連結串列).deleteAllRepeat(data)
            Node p1=mylist.head;
            while(p1.next!=null){
                p1=p1.next;
                //System.out.print(p1.data+" " );
                this.deletellARepeat(p1.data);
            }
        }
    }
    //排序-冒泡
    //交換函式
    public void swip(Node p1,Node p2){
        int a=p1.data;
        p1.data=p2.data;
        p2.data=a;
    }
    public void bubbleSort(){
        if(length<2){
            System.out.println("連結串列長度<2,無法排序");
        }else {

            for(int i=1;i<length;i++){
                //第一個迴圈，先遍歷到未排序序列首部
                Node p=head;
                for(int j=0;j<i;j++){
                    p=p.next;
                }
                //第二個迴圈比大小，交換，將最大值上浮至末尾
                Node curNode=p;
                Node nextNode=curNode.next;
                if(curNode.data>nextNode.data)
                    swip(curNode,nextNode);
                while(curNode.next!=null&&curNode.next.next!=null){
                    curNode=nextNode;
                    nextNode=nextNode.next;
                    if(curNode.data>nextNode.data)
                        swip(curNode,nextNode);
                }
                //將末尾最大值放到本層迴圈挑出來的，未排序的首部，下層未排序首部加1
                swip(p,nextNode);
            }
        }
    }
}
View Code

驗證類-test

public class linkedListTest {
    public static void main(String args[]) {
        //空？新增，正反遍歷
        MyLinkedList mylist=new MyLinkedList();
        System.out.println("isEmpty: "+mylist.isEmpty());
        mylist.add(6);
        mylist.add(5);
        mylist.add(4);
        mylist.add(3);
        System.out.println("isEmpty: "+mylist.isEmpty());
        mylist.print_1();
        mylist.print_2();
        //插入
        mylist.insert(1,14);
        mylist.print_1();
        mylist.insert(3,14);
        mylist.print_1();
        mylist.insert(17,14);
        mylist.print_1();
        //刪除
        mylist.delete(0);
        mylist.print_1();
        mylist.delete(4);
        mylist.print_1();
        mylist.delete(17);
        mylist.print_1();
        //刪除重複我-前提：獲取index陣列
        //mylist.deleteall(14);
       // mylist.deletellARepeat(14);
        mylist.deletefirst(14);
        mylist.print_1();

        //更新
        mylist.update(2,144);
        mylist.print_1();
        mylist.update(0,144);
        mylist.print_1();
        mylist.update(17,144);
        mylist.print_1();
        //清空
        //mylist.clear();
       // mylist.print_1();

        //get
        System.out.println(mylist.getData(0));
        System.out.println(mylist.getData(3));
        System.out.println(mylist.getData(17));
        //成環
//        mylist.toRinged();
//        System.out.println("isRinged: "+mylist.isRinged());
//        mylist.print_1();

        //去重複
        MyLinkedList mylist2=mylist;
        mylist2.add(6);
        mylist2.add(6);
        mylist2.add(17);
        mylist2.add(17);
        mylist2.add(8);
        mylist2.add(8);
        mylist2.print_1();

        mylist2.deleteRepeatData();
        mylist2.print_1();
        //排序
        mylist2.bubbleSort();
        mylist2.print_1();

    }
}
View Code

相關推薦

java-單鏈表

Node 類： public class Node { public int data; public Node next=null; public Node(){ data=2147483647; next=null;

java單鏈表反轉 詳細講述

reverse1 遍歷法:在連結串列遍歷的過程中將指標順序置換 public static Node reverse1(Node head) {

Java 單鏈表資料結構的增刪改查教程

我就廢話不多說了，大家還是直接看程式碼吧~ package 連結串列; /** * *1）單鏈表的插入、刪除、查詢操作；

Java單鏈表的簡單操作實現教程

前言 用Java實現單鏈表的簡單操作，閱讀本文和上一篇文章體會Java中類與C++中結構體指標的區別

(Java)單鏈表的反轉

技術標籤：演算法java單鏈表連結串列面試 Java_單鏈表的反轉 迭代(雙指標)遞迴

JAVA模擬新增順序表及單鏈表

最近在回顧大學學的資料結構，這裡給大家用java模擬順序表和單鏈表的新增 1順序表新增

java實現單鏈表的增刪改以及排序

使用java程式碼模擬單鏈表的增刪改以及排序功能 程式碼如下：package com.seizedays.linked_list;

java 資料結構單鏈表的操作

一、手寫一個單鏈表 　　 public class ListNode<T>{ /** * 資料 */ public T obj; /** * tail 指標

用java簡單的實現單鏈表的基本操作

packagecom.tyxh.link; //節點類 publicclassNode{ protectedNodenext;//指標域 protectedintdata;//資料域

【Java資料結構】帶頭節點單鏈表的反轉，從尾到頭輸出，輸出倒數第k個節點

Java單鏈表的三個面試題： 1、將單鏈表反轉 2、從尾到頭輸出單鏈表 3、輸出單鏈表的倒數第k個節點

資料結構 - 單鏈表的建立、插入、修改、刪除和遍歷(Java實現)

單鏈表的插入   尾插法：使用一個臨時結點直接找到最後一個結點 \\(temp\\)，然後 \\(temp.next = newNode, newNode.next = null\\)

有趣的兩位數和單鏈表處理——Java解法

有趣的兩位數 有數學家發現⼀些兩位數很有意思，⽐如， 34 * 86 = 43 * 68 也就是說，如果把他們的十位數和個位數交換，二者乘積不變。 程式設計求出滿足該性質的兩位數組合。 提示，暴力解法非最優解。

Java實現單鏈表常見操作

一、概述： 本文主要總結單鏈表常見操作的實現，包括連結串列結點新增、刪除；連結串列正向遍歷和反向遍歷、連結串列排序、判斷連結串列是否有環、是否相交、獲取某一結點等。

JAVA筆記整理-集合框架-單鏈表-佇列結構-棧結構

一、集合框架 有關LinkedList的集合的，它是一個連結串列結構的集合 1、連結串列結構

Java 8實現任意引數的單鏈表

本文例項為大家分享了Java 8實現任意引數的單鏈表，供大家參考，具體內容如下

用JAVA實現單鏈表，檢測字串是否是迴文串

一.需求 使用JAVA實現單鏈表，使用單鏈表檢測字串是否是迴文串 二.需求分析 迴文串最重要的就是對稱，那麼最重要的問題就是找到那個中心，用快指標每步走兩格，當他到達連結串列末端的時候，慢指標剛好到達中心，慢

經典面試題： java實現單鏈表翻轉

技術標籤：資料結構和演算法資料結構 經典面試題： java實現單鏈表翻轉 思路分析：

單鏈表結構及連結串列反轉操作java程式碼實現

連結串列 單向連結串列 單向連結串列是連結串列的一種，它由多個結點組成，每個結點都由一個數據域和一個指標域組成，資料域用來儲存資料， 指標域用來指向其後繼結點。連結串列的頭結點的資料域不儲存資料，指標域

資料結構與演算法Java版：單鏈表的反轉

技術標籤：資料結構Java版連結串列資料結構演算法java public class LinkedList { Node head;

【Java資料結構】單鏈表的手動實現及部分操作

技術標籤：筆記資料結構連結串列java演算法 連結串列是一種物理儲存結構上非連續儲存結構，資料元素的邏輯順序是通過連結串列中的引用連結次序實現的 。