java编程（一）链表

最新推荐文章于 2024-08-17 08:59:42 发布
最新推荐文章于 2024-08-17 08:59:42 发布
阅读量178 收藏
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/L19942013/article/details/89110597
版权

1.单链表

package unLinkedList;

package unLinkedList;

public interface IList {

    //判断是否为空
    public boolean isEmpty();

    //插入元素
    public void insert(int index,Object o)throws Exception;

    //删除元素
    public void delete(int index)throws Exception;

    //获取链表长度
    public int getLength();

    //获取元素
    public Object get(int index)throws Exception;



}

//单向链表
public class UNode {

    //数据域
    Object obj;
    //指针
    UNode next;

    public UNode(UNode nextval){
        this.next=nextval;
    }

    public UNode(Object obj,UNode nextval){
        this.next=nextval;
        this.obj=obj;
    }

    public UNode getNext(){
        return this.next;
    }

    public void setNext(UNode nextval){
        this.next=nextval;
    }

    public Object getObj(){
        return this.obj;
    }

    public void setObj(Object obj){
        this.obj=obj;
    }


    public String toString(){
        return this.obj.toString();
    }
}

package unLinkedList;

//单向链表
public class UnLinkedList implements IList{
    //头指针
    UNode head;
    //当前节点对象
    UNode cur;
    int size;

    //初始化
    public UnLinkedList(){
        this.head=cur=new UNode(null);
        this.size=0;
    }

    //指针定位，定位到插入节点之前的一个节点
    public void index(int index)throws Exception{
        if(index<-1 || index>size-1){
            System.out.println("错误！");
        }
        //头结点
        if(index==-1)
            return;
        cur=head.next;
        int j=0;
        while (cur!=null && j<index){
            cur=cur.next;
            j++;
        }
    }

    @Override
    public boolean isEmpty() {
        return size==0;
    }

    @Override
    public void insert(int index, Object o) throws Exception {
        if(index<0 || index>size){
            throw new Exception("参数错误！");
        }
        //插入节点的前一个节点
        index(index-1);
        cur.setNext(new UNode(o,cur.next));
        size++;
    }

    @Override
    public void delete(int index) throws Exception {
        if(isEmpty()){
            throw new Exception("链表为空，删除错误！");
        }
        if(index<0 || index>size){
            throw new Exception("传入参数错误！");
        }
        //定位到删除节点之前的一个节点
        index(index-1);
        cur.setNext(cur.next.next);
        size--;
    }

    @Override
    public int getLength() {
        return this.size;
    }

    @Override
    public Object get(int index) throws Exception {
        if (index<-1 || index>size-1){
            throw new Exception("传入参数错误！");
        }
        index(index);
        return cur.getObj();
    }

    public static void main(String[] args)throws Exception{
        UnLinkedList list=new UnLinkedList();
        for (int i = 0; i < 5; i++) {
            int temp=((int)(Math.random() * 1000)) * 1000;
            list.insert(i,temp);
            System.out.println(temp+"--");
        }

        list.delete(4);
        System.out.println("---------------------");
        for (int i = 0; i <list.size ; i++) {
            System.out.println(list.get(i)+"--");
        }

    }
}

2.双向循环链表

package unLinkedList;


//双向链表
public class DNode {
    //数据域
    Object obj;
    //后继针域
    DNode next;
    //前驱指针域
    DNode prior;

    public DNode(DNode nextval){
        this.next=nextval;
    }

    public DNode(Object obj, DNode nextval){
        this.next=nextval;
        this.obj=obj;
    }

    public DNode getNext(){
        return this.next;
    }

    public void setNext(DNode nextval){
        this.next=nextval;
    }

    public Object getObj(){
        return this.obj;
    }

    public void setObj(Object obj){
        this.obj=obj;
    }

    public DNode getPrior(){
        return this.prior;
    }

    public void setPrior(DNode priorval){
        this.prior=priorval;
    }

    public String toString(){
        return this.obj.toString();
    }
}
package unLinkedList;

//双向链表
public class DLinkedList implements IList{

    //头指针
    DNode head;
    //当前节点对象
    DNode cur;
    int size;

    //初始化
    public DLinkedList(){
        this.head=cur=new DNode(null);
        this.size=0;
        this.head.next=head;
        this.head.prior=head;
    }

    //指针定位，定位到插入节点之前的一个节点
    public void index(int index)throws Exception{
        if(index<-1 || index>size-1){
            System.out.println("错误！");
        }
        //头结点
        if(index==-1)
            return;
        cur=head.next;
        int j=0;
        while (cur!=head && j<index){
            cur=cur.next;
            j++;
        }
    }

    @Override
    public boolean isEmpty() {
        return size==0;
    }

    @Override
    public void insert(int index, Object o) throws Exception {
        if(index<0 || index>size){
            throw new Exception("参数错误！");
        }
        //插入节点的前一个节点
        index(index-1);
        cur.setNext(new DNode(o,cur.next));
        cur.next.setPrior(cur.next);
        cur.next.next.setPrior(cur.next);
        size++;
    }

    @Override
    public void delete(int index) throws Exception {
        if(isEmpty()){
            throw new Exception("链表为空，删除错误！");
        }
        if(index<0 || index>size){
            throw new Exception("传入参数错误！");
        }
        //定位到删除节点之前的一个节点
        index(index-1);
        cur.setNext(cur.next.next);
        cur.next.setPrior(cur);
        size--;
    }

    @Override
    public int getLength() {
        return this.size;
    }

    @Override
    public Object get(int index) throws Exception {
        if (index<-1 || index>size-1){
            throw new Exception("传入参数错误！");
        }
        index(index);
        return cur.getObj();
    }


    public static void main(String[] args)throws Exception{
        DLinkedList list=new DLinkedList();
        for (int i = 0; i < 5; i++) {
            int temp=((int)(Math.random() * 1000)) * 1000;
            list.insert(i,temp);
            System.out.println(temp+"--");
        }

        list.delete(4);
        System.out.println("---------------------");
        for (int i = 0; i <list.size ; i++) {
            System.out.println(list.get(i)+"--");
        }
    }
}

3.链表反转

package unLinkedList;


public class reverseList {
    public static UNode reverseList(UNode head){
        //前一个节点的指针
        UNode preNode=null;
        //当前节点指针
        UNode curNode=head;
        //下一个节点指针
        UNode nextNode=null;

        //如果首节点为空
        if(head==null || head.getNext()==null){
            return head;
        }

        //首节点不为空
        while (curNode!=null){
            //前后节点交换
            nextNode=curNode.getNext();
            curNode.setNext(preNode);
            preNode=curNode;
            curNode=nextNode;
        }

        return preNode;
    }
}

4.合并链表、求链表中间节点

package unLinkedList;

package unLinkedList;

public class MNode {

        //数据域
        int obj;
        //指针
        MNode next;

        public MNode(int obj){
            this.obj=obj;
        }

        public MNode(int obj,MNode nextval){
            this.next=nextval;
            this.obj=obj;
        }

        public MNode getNext(){
            return this.next;
        }

        public void setNext(MNode nextval){
            this.next=nextval;
        }

        public Object getObj(){
            return this.obj;
        }

        public void setObj(int obj){
            this.obj=obj;
        }




}


//将两个有序链表合并
/*
*@param node1有序链表1
*@param node2有序链表2
*@return 合并后的链表
* */
public class mergeList {
    public static MNode mergeList(MNode node1, MNode node2) {

        //使用递归的方式进行合并，终止条件
        if (node1 == null && node2 == null) {
            return null;
        }
        if (node1 == null) {
            return node2;
        }
        if (node2 == null) {
            return node1;
        }


        //合并后的链表
        MNode node = null;
        //为了方便，这里将数据类型转换为Int
        if ((int) node1.obj > (int) node2.obj) {
            //小的放在前面
            node = node2;
            node.next = mergeList(node1, node2.next);
        } else {
            node = node1;
            node.next = mergeList(node2, node1.next);
        }

        return node;
    }

    //求链表中间节点
    public static MNode middleNode(MNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        MNode slow = head;
        MNode fast = head.next;
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        return fast == null ? slow : slow.next;
    }


    public static void main(String[] args) throws Exception {

        MNode node1 = new MNode(1);
        MNode node2 = new MNode(2);
        MNode node3 = new MNode(3);
        MNode node4 = new MNode(4);
        MNode node5 = new MNode(5);

        node1.next = node3;
        node3.next = node5;
        node2.next = node4;

        MNode node = mergeList(node2, node1);
        while (node != null) {
            System.out.print(node.obj + " ");
            node = node.next;

        }
    }
}

 

vegetableChick
关注
专栏目录
java链表
04-19
NULL 博文链接：https://wuzexin530.iteye.com/blog/1860709
Java编程删除链表中重复的节点问题解决思路及源码分享
08-29
"Java编程删除链表中重复的节点问题解决思路及源码分享" 本文主要介绍了Java编程删除链表中重复的节点问题解决思路及源码分享，旨在帮助读者了解如何删除链表中的重复节点。下面将详细介绍相关知识点： 一、链表...
Java链表
xiangsuixinsheng的专栏
06-11 7165
使用Java实现链表，首先定义链表的数据结构，也就是定义一个类，LinkedListNode。这个定义了链表的节点，链表节点分两部分，数据info和链接link。public class LinkedListNode {   public int info;   public LinkedListNode link;//这里就是链接，指向下一个节点的内存地址}link开始没看懂，怎么l
Java“链表“——数据结构（这一篇就够了）
最新发布
m0_73158088的博客
08-17 1437
本篇对数据结构中的"链表"进行详细的讲解 本期会分成一下五部分进行讲解： 1.链表的概念 2.链表的种类 3.链表的实现方法 4.代码实现链表 5.链表的常见使用场景
JAVA链表
banglun5623的博客
03-10 223
写一个大家都比较熟悉的数据结构：单向链表。 不过先告诉大家一个小秘密，java的API里面已经提供了单向链表的类，大家可以直接拿来用，不过学习数据结构课程的时候想必大家也已经知道，虽然系统会给我们提供一些常用的数据结构，但是自定义的总是能够带来不同的喜感的，而且通过自己的编写也更能够让我们了解其中实现的过程，而且我们还可以写一些比较个性化的方法作为属于自己的数据结构。这里主要是介绍一些...
java链表编程题总结
basycai的博客
07-09 691
转自：http://www.jb51.net/article/71885.htm 这份笔记整理了整整一个星期，每一行代码都是自己默写完成，并测试运行成功，同时也回顾了一下《剑指offer》这本书中和链表有关的讲解，希望对笔试和面试有所帮助。本文包含链表的以下内容：　　1、单链表的创建和遍历　　2、求单链表中节点的个数　　3、查找单链表中的倒数第k个结点（剑指offer，题15）　　4、查找单链表
Java编程实现递增排序链表的合并
08-29
Java编程实现递增排序链表的合并是指将两个单调递增的链表合并成一个新的链表，并且新的链表仍然满足单调不减规则。这种问题经常出现在算法面试中，考察候选人的编程能力和算法设计能力。 解决这个问题的主要思路有...
java编程题之合并两个排序的链表
08-26
"java编程题之合并两个排序的链表" 本文主要介绍了java编程题之合并两个排序的链表，以供大家参考。下面是对该知识点的详细说明： 链表基本概念 在计算机科学中，链表是一种基本的数据结构。它是一种动态的数据...
链表的原理及java实现代码示例
08-28
"链表的原理及Java实现代码示例" 链表是一种基本的数据结构，它的实现原理不同...链表的实现原理和应用场景是非常重要的知识点，对于程序员来说，掌握链表的实现原理和应用场景可以大大提高编程效率和解决问题的能力。
JAVA 数据结构链表操作循环链表
09-01
在Java编程中，数据结构是程序设计的基础，链表是一种常用的数据结构，它不依赖于数组的物理位置，而是通过节点间的引用关系进行组织。循环链表是链表的一种变体，它的特点是最后一个节点指向了链表的第一个节点，...
非常有用的java链表编程
09-13
java链表，非常易于理解，能帮助你快速掌握链表编程
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值