JAVA 链表操作：单连表和双链表

主要讲述几点：

一、链表的简介

二、链表实现原理和必要性

三、单链表示例

四、双链表示例

　

一、链表的简介　

　　链表是一种比较常用的数据结构，链表虽然保存比较复杂，但是在查询时候比较便捷，在多种计算机语言都相应的应用，链表有多种类别，文章针对单链表和双链表进行分析。链表中数据就像被一个链条串联一起，轻易的可以实现数据的访问。

二、链表实现原理和必要性

　　这里只分析单链表和双链表。链表的实现过程是有些许复杂的，但是会带来许多好处。比如现在网购时代到来，商家发快递一般会将商品包装在盒子里并写上地址信息，快递公司就可以通过盒子上的信息找到买家，商品完整到达。如果没有盒子的保护，有可能在途中商品受损。而链表就好比那个写了地址信息的盒子，既保护了商品信息，同时又写好了物流信息。链表之中存在一个HEAD节点，类似“火车头”，只要找到相应HEAD节点，就可以对链表进行操作。此次分析中，HEAD节点只是做数据头，不保存有效数据。

　　单链表的实现原理如图：

　　

　　双链表实现原理：

　　

三、单链表示例　　

ICommOperate<T> 接口操作类：

package LinkListTest;
import java.util.Map;
public interface ICommOperate<T> {

    public boolean insertNode(T node) ;
    public boolean insertPosNode(int pos, T node) ;
    public boolean deleteNode(int pos) ;
    public boolean updateNode(int pos, Map<String, Object> map) ;
    public T getNode(int pos, Map<String, Object> map) ;
    public void printLink() ;
}

单链表节点：

package LinkListTest;
// 单连表节点
public class SNode {
    private String data;
    private SNode  nextNode;
    public SNode() {
    }
    public SNode(String data) {
        this.data = data;
        this.nextNode = new SNode();
    }

    public String getData() {
        return data;
    }
    public void setData(String data) {
        this.data = data;
    }
    public SNode getNextNode() {
        return nextNode;
    }
    public void setNextNode(SNode nextNode) {
        this.nextNode = nextNode;
    }
    @Override
    public String toString() {
        return "SNode [data=" + data + "]";
    }
}

单链接操作类：

package LinkListTest;

import java.util.HashMap;
import java.util.Map;

public class SingleLinkList implements ICommOperate<SNode>{
    private SNode head = new SNode("HEAD") ; // 公共头指针，声明之后不变
    private int size = 0 ;

    /*
     * 链表插入，每次往末端插入
     * */
    @Override
    public boolean insertNode(SNode node) {
        boolean flag = false ;
        SNode current = this.head ;
        SNode temp = null ;
        while( true ){
            temp = current ;
            if( (current=current.getNextNode())==null ){
                break ;
            }
        }
        temp.setNextNode(node) ;
        node.setNextNode(null) ;
        this.size++ ;
        flag = true ;

        return flag;
    }

    /*
     * 插入链表指定位置pos，从1开始,插入末端为链表(size+1)
     * */
    @Override
    public boolean insertPosNode(int pos, SNode node){
        boolean flag = false;
        SNode current = this.head.getNextNode() ;

        if( this.size==0 && current==null ){
            this.head.setNextNode(node) ;
            node.setNextNode(null) ;
            this.size++ ;
            flag = true ;
            System.out.println("原始链表无数据，节点已经插入链表中");
        }else if( pos<=0 || pos>this.size+1 ){
            System.out.println("位置信息错误");
        }else{
            // 1、找到要插入pos位置节点和前节点
            int find = 0;
            SNode preNode = this.head; // 前节点
            SNode currentNode = current; // 当前节点
            while( find<pos && currentNode!=null ){
                preNode = current ;                    // 前节点后移
                currentNode = currentNode.getNextNode() ; // 当前节点后移
                find++ ;
                if( find<pos && currentNode!=null ){ // 未结束寻找节点前，后移前节点
                    current = current.getNextNode() ;
                }
            }
//            System.out.println(preNode);
//            System.out.println(currentNode);
            // 2、插入节点
            preNode.setNextNode(node);
            node.setNextNode(currentNode);
            this.size++ ;
            flag = true ;
            System.out.println("节点已经插入链表中");
        }

        return flag;
    }

    /*
     * 指定链表的节点pos，删除对应节点。方式：找到要删除节点的前后节点，进行删除。从1开始
     * */
    @Override
    public boolean deleteNode(int pos) {
        boolean flag = false;
        SNode current = this.head.getNextNode() ;
        if( pos<=0 || pos>this.size || current==null ){
            System.out.println("位置信息错误或链表无信息");
        }else{
            // 1、找到要删除节点的前后节点
            int find = 0;
            SNode preNode = this.head; // 前节点
            SNode nextNode = current.getNextNode(); // 后节点
            while( find<pos && nextNode!=null ){
                preNode = current ;                    // 前节点后移
                nextNode = nextNode.getNextNode() ; // 后节点后移
                find++ ;
                if( find<pos && nextNode!=null ){ // 未结束找节点前，后移"前节点"
                    current = current.getNextNode() ;
                }
            }
//            System.out.println(preNode);
//            System.out.println(nextNode);

            // 2、删除节点
            preNode.setNextNode(nextNode);
            System.gc();
            this.size-- ;
            flag = true ;
        }

        return flag;
    }

    /*
     * 指定链表的节点pos，修改对应节点。 从1开始
     * */
    @Override
    public boolean updateNode(int pos, Map<String, Object> map) {
        boolean flag = false ;
        SNode node = getNode(pos, map); // 获得相应位置pos的节点
        if( node!=null ){
            String data = (String) map.get("data") ;
            node.setData(data);
            flag = true ;
        }
        return flag;
    }

    /*
     * 找到指定链表的节点pos，从1开始
     * */
    @Override
    public SNode getNode(int pos, Map<String, Object> map) {
        SNode current = this.head.getNextNode() ;
        if( pos<=0 || pos>this.size || current==null ){
            System.out.println("位置信息错误或链表不存在");
            return null;
        }
        int find = 0 ;
        while( find<pos && current!=null  ){
            current = current.getNextNode() ;
            find++ ;
        }
        return current;
    }

    /*
     * 打印链表
     * */
    @Override
    public void printLink() {
        SNode current = this.head.getNextNode() ;
        int find = 0 ;
        System.out.println("总共有节点数: " + this.size +" 个");
        while( (current=current.getNextNode())!=null ){
            System.out.println("第 " + (++find) + " 个节点 ：" + current);
        }
    }

    public static void main(String[] args) {
        SingleLinkList sll = new SingleLinkList() ;
        SNode node1 = new SNode("节点1");
        SNode node2 = new SNode("节点2");
        SNode node3 = new SNode("节点3");
        SNode node4 = new SNode("节点4");
        SNode node5 = new SNode("节点5");
        SNode node6 = new SNode("插入指定位置");
        sll.insertNode(node1);
        sll.insertNode(node2);
        sll.insertNode(node3);
        sll.insertNode(node4);
        sll.insertNode(node5);

        System.out.println("*******************输出链表*******************");
        sll.printLink();

        System.out.println("*******************获得指定链表节点*******************");
        System.out.println("获取链表第 1 个位置数据 ："+sll.getNode(1, null));

        System.out.println("*******************向链表指定位置插入节点*******************");
        System.out.println("将数据插入第4个节点：");
        sll.insertPosNode(4, node6) ;
        sll.printLink();

        System.out.println("*******************删除链表指定位置节点*******************");
        System.out.println("删除第1个节点：");
        sll.deleteNode(1) ;
        sll.printLink();

        System.out.println("*******************修改链表指定位置节点*******************");
        System.out.println("修改第2个节点：");
        Map<String, Object> map = new HashMap<>() ;
        map.put("data", "this is a test") ;
        sll.updateNode(2, map) ;
        sll.printLink();
    }
}

四、双链表示例

ICommOperate<T> 接口操作类：

package LinkListTest;
import java.util.Map;
public interface ICommOperate<T> {
    public boolean insertNode(T node) ;
    public boolean insertPosNode(int pos, T node) ;
    public boolean deleteNode(int pos) ;
    public boolean updateNode(int pos, Map<String, Object> map) ;
    public T getNode(int pos, Map<String, Object> map) ;
    public void printLink() ;
}

双链表节点：

package LinkListTest;
// 双连表节点
public class DNode {
    private DNode  priorNode;
    private String data;
    private DNode  nextNode;

    public DNode(){
    }
    public DNode(String data) {
        this.priorNode = new DNode() ;
        this.data = data ;
        this.nextNode = new DNode() ;
    }

    public DNode getPriorNode() {
        return priorNode;
    }
    public void setPriorNode(DNode priorNode) {
        this.priorNode = priorNode;
    }

    public String getData() {
        return data;
    }
    public void setData(String data) {
        this.data = data;
    }

    public DNode getNextNode() {
        return nextNode;
    }
    public void setNextNode(DNode nextNode) {
        this.nextNode = nextNode;
    }

    @Override
    public String toString() {
        return "DNode [data=" + data + "]";
    }
}

双链表实现类：

package LinkListTest;

import java.util.HashMap;
import java.util.Map;

public class DoubleLinkList implements ICommOperate<DNode>{
    private DNode head = new DNode("HEAD");
    private int size = 0 ;

    /*
     * 链表插入，每次往末端插入
     * */
    @Override
    public boolean insertNode(DNode node) {
        boolean flag = false;
        DNode current = this.head ;
        DNode priorNode = null;
        while( true ){
            priorNode = current ;
            if( (current=current.getNextNode())==null ){
                break ;
            }
        }
        priorNode.setNextNode(node);
        node.setNextNode(null);
        node.setPriorNode(priorNode);
        this.size++ ;
        flag = true ;

        return flag;
    }

    /*
     * 插入链表指定位置pos，从1开始,插入末端为链表(size+1)
     * */
    @Override
    public boolean insertPosNode(int pos, DNode node) {
        boolean flag = false;
        DNode current = this.head.getNextNode() ;

        if( this.size==0 && current==null ){ // 链表为空
            this.head.setNextNode(node) ;
            node.setNextNode(null) ;
            node.setPriorNode(this.head);
            this.size++ ;
            flag = true ;
            System.out.println("原始链表无数据，节点已经插入链表中");
        }else if( pos<=0 || pos>this.size+1 ){
            System.out.println("位置信息错误");
        }else{
            // 1、找到要插入位置pos节点
            int find = 0;
            DNode temp = current ;
            while( find<pos && current!=null ){
                if( find<pos && (current=current.getNextNode())!=null ){
                    temp = temp.getNextNode() ;
                }
                find++ ;
            }
            // 2、插入节点
            if( temp.getNextNode()==null ){ // 尾节点
                node.setPriorNode(temp);
                node.setNextNode(null);
                temp.setNextNode(node);
            } else if( temp.getNextNode()!=null ) {  //中间节点
                node.setPriorNode(temp.getPriorNode());
                node.setNextNode(temp);
                temp.getPriorNode().setNextNode(node);
                temp.setPriorNode(node);
            }
            this.size++ ;
            flag = true ;
            System.out.println("节点已经插入链表中");
        }
        return flag;
    }

    /*
     * 指定链表的节点pos，删除对应节点，从1开始
     * */
    @Override
    public boolean deleteNode(int pos) {
        boolean flag = false;
        DNode current = this.head.getNextNode() ;
        if( pos<=0 || pos>this.size || current==null ){
            System.out.println("位置信息错误或链表不存在");
        }else{
            // 1、找到要删除位置pos节点
            int find = 0;
            while( find<pos && current!=null ){
                current = current.getNextNode() ;
                find++ ;
            }
            // 2、删除节点
            if( current.getNextNode()==null ){ // 尾节点
                current.getPriorNode().setNextNode(null) ;
            } else if( current.getNextNode()!=null ) {  //中间节点
                current.getPriorNode().setNextNode(current.getNextNode()) ;
                current.getNextNode().setPriorNode(current.getPriorNode()) ;
            }
            System.gc();
            this.size-- ;
            flag = true ;
        }
        return flag;
    }

    /*
     * 指定链表的节点pos，修改对应节点。 从1开始
     * */
    @Override
    public boolean updateNode(int pos, Map<String, Object> map) {
        boolean flag = false ;
        DNode node = getNode(pos, map);
        if( node!=null ){
            String data = (String) map.get("data") ;
            node.setData(data);
            flag = true ;
        }
        return flag;
    }

    /*
     * 找到指定链表的节点pos，从1开始
     * */
    @Override
    public DNode getNode(int pos, Map<String, Object> map) {
        DNode current = this.head.getNextNode() ;
        if( pos<=0 || pos>this.size || current==null ){
            System.out.println("位置信息错误或链表不存在");
            return null;
        }
        int find = 0 ;
        while( find<pos && current!=null  ){
            current = current.getNextNode() ;
            find++ ;
        }
        return current;
    }

    /*
     * 打印链表
     * */
    @Override
    public void printLink() {
        DNode current = this.head.getNextNode() ;
        int find = 0 ;
        System.out.println("总共有节点数: " + this.size +" 个");
        while( (current=current.getNextNode())!=null ){
            System.out.println("第 " + (++find) + " 个节点 ：" + current);
        }
    }

    public static void main(String[] args) {
        DoubleLinkList dll = new DoubleLinkList() ;
        DNode node1 = new DNode("节点1");
        DNode node2 = new DNode("节点2");
        DNode node3 = new DNode("节点3");
        DNode node4 = new DNode("节点4");
        DNode node5 = new DNode("节点5");
        DNode node6 = new DNode("插入指定位置");
        dll.insertNode(node1);
        dll.insertNode(node2);
        dll.insertNode(node3);
        dll.insertNode(node4);
        dll.insertNode(node5);

        System.out.println("*******************输出链表*******************");
        dll.printLink();

        System.out.println("*******************获得指定链表节点*******************");
        System.out.println("获取链表第 1 个位置数据 ："+dll.getNode(1, null));

        System.out.println("*******************向链表指定位置插入节点*******************");
        System.out.println("将数据插入第4个节点：");
        dll.insertPosNode(4, node6) ;
        dll.printLink();

        System.out.println("*******************删除链表指定位置节点*******************");
        System.out.println("删除第1个节点：");
        dll.deleteNode(1) ;
        dll.printLink();

        System.out.println("*******************修改链表指定位置节点*******************");
        System.out.println("修改第2个节点：");
        Map<String, Object> map = new HashMap<>() ;
        map.put("data", "this is a test") ;
        dll.updateNode(2, map) ;
        dll.printLink();
    }

}
时间： 2024-11-05 22:32:20

JAVA 链表操作：单连表和双链表的相关文章

java数据结构与算法之改良顺序表与双链表类似ArrayList和LinkedList（带Iterator迭代器与fast-fail机制）

转载请注明出处(请尊重原创!谢谢~): http://blog.csdn.net/javazejian/article/details/53073995 出自[zejian的博客] 关联文章: java数据结构与算法之顺序表与链表设计与实现分析 java数据结构与算法之双链表设计与实现 java数据结构与算法之改良顺序表与双链表类似ArrayList和LinkedList(带Iterator迭代器与fast-fail机制) ??这篇是数据结构与算法的第3篇,通过前两篇的介绍,对应顺序表和链表已有

解决erlang和java同时操作一张表，造成锁表问题

作者:张昌昌 1.问题描述 Erlang端通过odbc去写oracle一张表,同时java通过jdbc驱动也去写这张表,当同时多次发生这种写操作时,这个表就被锁. 2.问题解决 思路:利用适配器原理,适配erlang和java的数据库连接,让erlang端对数据表的操作与java端对该数据表的操作,分时序顺序进行,其中一端在进行写操作时上锁 另一端就不能操作,直到他操作完成释放锁,另一端才能操作. 该适配器采用java编写,通过otp.jar让erlang与java进行通信,erlang和jav

线性表之双链表

#include<iostream> using namespace std; struct LinkNode { int value; LinkNode* next; LinkNode* pre; }; LinkNode* createDoubleLinkList() { LinkNode* head = (LinkNode*)malloc(sizeof(LinkNode)); head->next=NULL; head->pre=NULL; head->value=0;

【C++】实现双向链表的所有操作，包括逆置双链表(三种方法)

建立源文件List.cpp include "List.h" int main() {     Test();     system("pause");     return 0; } 建立头文件List.h #ifndef __LISH_H__ #define __LISH_H__ #include<iostream> using namespace std; typedef int DataType; struct ListNode {     Li

java数据结构与算法之双链表设计与实现

转载请注明出处(万分感谢!): http://blog.csdn.net/javazejian/article/details/53047590 出自[zejian的博客] 关联文章: 关联文章: java数据结构与算法之顺序表与链表设计与实现分析 java数据结构与算法之双链表设计与实现 java数据结构与算法之改良顺序表与双链表类似ArrayList和LinkedList(带Iterator迭代器与fast-fail机制) ??上一篇文章分析顺序表和单链表,本篇就接着上篇继续聊链表,在单链表

10、单链表操作

单链表操作 单链表操作1 /*单链表的类型定义*/ typedef int DataType; typedef struct node { DataType data; struct node * next; }LinkNode, *LinkList; /*单链表的定位运算*/ LinkNode *Locate(LinkNode *L, int k)//????为什么此处是LinkNode *Locate()类型,表示什么意思 { LinkNode *p; int i; i= 1; p = L-

浅谈单链表与双链表的区别

昨天面试官面试的时候问了我一道关于链表的问题:情境如下 面试官:请说一下链表跟数组的区别? 我:数组静态分配内存,链表动态分配内存:数组在内存中连续,链表不连续:数组利用下标定位,时间复杂度为O(1),链表定位元素时间复杂度O(n):数组插入或删除元素的时间复杂度O(n),链表的时间复杂度O(1). 根据以上分析可得出数组和链表的优缺点如下: 数组的优点 随机访问性强(通过下标进行快速定位) 查找速度快数组的缺点 插入和删除效率低(插入和删除需要移动数据) 可能浪费内存(因为是连续的,所以每次申

双链表操作

处理完了单链表,这次处理双链表. 在一个双链表中,每个节点都包含两个指针,指向前一个节点的指针和指向后一个节点的指针.这可以使我们以任何方式遍历双链表,甚至可以忽略前后地在双链表中访问.下面的图示展示了一个双链表: 下面是节点类型的声明文件: double_linked_list_node.h #ifndef _DOUBLE_LINKED_LIST #define _DOUBLE_LINKED_LIST typedef struct NODE{ struct NODE * fwd; struct

双链表内部迁移操作

说明:本文仅供学习交流,转载请标明出处,欢迎转载! 所谓双链表的迁移操作指的是将双链表中一部分连续的结点迁移到另外一个结点之前,为了说明这个定义,我们从下图来解释. 我们将[first,last)对应的结点迁移到position所指向的位置之前?那该怎么做呢?这不是一个算法设计题,因为不需要什么特别有效率的技巧,我只是想理清这个思路而已,因为双链表的增删操作如果不理清思路会很容易产生混乱. 下面我们给出该双链表结点的定义: template<class T> struct node { <