使用java实现单链表----(java中的引用就是指针)转载自:https://www.cnblogs.com/zhongyimeng/p/9945332.html

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
//一直以为java中没有指针,其实java的引用就是指针,只不过堆栈中的引用储存了在堆中的地址,可以看做java中的指针。<br>public class sibgleLink<E> {
    // 结点内部类
    private class Node {
        private Object data;
        private Node next = null;
 
        public Node() {
            data = null;
        }
 
        // 带数据的构造函数
        public Node(E data) {
            this.data = data;
        }
 
    }
 
    private Node head; // 头引用(指针)
    private Node rear; // 尾引用(指针)
    private Node point; // 临时引用(指针)
    private int length = 1; // 链表长度
 
    // 带参数的构造函数
    public sibgleLink(E e) {
        head = new Node();
        head.data = e;
        rear = head;
        length = 1;
    }
 
    // 尾插法
    public void add(E elem) {
        point = new Node(elem);
        rear.next = point;
        rear = point;
        length++;
 
    }
 
    // 遍历节点
    public void traverse() {
        point = head; // 移动临时引用到头结点
        if (head != null)
            System.out.print("[" + head.data + "]");
        while (point.next != null) {
            System.out.print("->[" + point.next.data + "]");
            point = point.next;
        }
        System.out.println();
    }
 
    // 返回长度
    public int length() {
        return this.length;
    }
 
    // 清除
    public boolean clear() {
        while (head.next.next != null) {
 
            head.next = head.next.next;
        }
 
        head.next = null;
        rear = head;
        point = null;
        length = 1;
        return true;
 
    }
 
    // 插入元素
    public boolean insert(int x, E data) {
        // 工作节点
        point = head;
        int wz = 1;
        if (x == 1) {
            Node n = new Node(data);
            n.next = head;
            head = n;
            length++;
            return true;
 
        }
 
        if (x < 1 || x > this.length) {
            return false;
 
        } else {
 
            while (point.next != null && wz < x - 1) {
                point = point.next;
                wz++;
            }
 
            // 放入一个节点
            Node n = new Node(data);
            n.next = point.next;
            point.next = n;
            length++;
 
            return true;
 
        }
 
    }
 
    // 删除
    public boolean del(int x) {
        point = head;
        int wz = 1;
        if (x < 0 || x > length) {
            return false;
 
        } else if (x == length) {
            point = head;
            while (point.next != null) {
                point = rear;
                point.next = null;
                length--;
 
            }
 
        } else {
 
            while (point.next != null && wz < x - 1) {
                point = point.next;
                wz++;
            }
            Node d = point.next;
            point.next = point.next.next;
            d = null;
 
            return true;
 
        }
 
        return false;
 
    }
 
    // 更改
    public boolean change(int x, E data) {
        point = head;
        int wz = 1;
        if (x < 0 || x > length) {
            return false;
 
        } else {
 
            while (point.next != null && wz < x) {
                point = point.next;
                wz++;
            }
            point.data = data;
 
            return true;
 
        }
 
    }
 
    // 移动指针
    private Node movePoint(int position) {
        if (position < 0)
            return head;
        if (position > length)
            return rear;
 
        if (position >= 0 && position <= length) {
            point = head;
            while (point != null) {
                if (position == 0)
                    break;
                position--;
                point = point.next;
            }
        }
 
        return point;
 
    }
 
    public E find(int position) {
        if (position >= 0 && position < length) {
            Node tmp = movePoint(position);
            return (E) tmp.next.data;
        }
        return null;
    }
 
    // test
    public static void main(String[] args) {
 
        sibgleLink<Integer> si = new sibgleLink<Integer>(0);
        si.add(5);
        si.add(6);
        si.insert(2, 2);
        si.traverse();
        si.del(3);
        si.traverse();
        si.change(3, 77);
        si.traverse();
        System.out.println(si.length());
 
    }
 
}

  结果:

1
2
3
4
[0]->[2]->[5]->[6]
[0]->[2]->[6]
[0]->[2]->[77]
4

使用java实现单链表(转载自:https://www.cnblogs.com/zhongyimeng/p/9945332.html)的更多相关文章

  1. Java实现单链表的各种操作

    Java实现单链表的各种操作 主要内容:1.单链表的基本操作 2.删除重复数据 3.找到倒数第k个元素   4.实现链表的反转   5.从尾到头输出链表 6.找到中间节点 7.检测链表是否有环 8.在 ...

  2. java实现单链表的增删功能

    JAVA 实现单链表的增删功能 package linked; class LinkedTable{ } public class LinkedTableTest { public static vo ...

  3. JAVA数据结构——单链表

    链表:一. 顺序存储结构虽然是一种很有用的存储结构,但是他有如下几点局限性:1. 因为创造线性表的时候已经固定了空间,所以当需要扩充空间时,就需要重新创建一个地址连续的更大的存储空间.并把原有的数据元 ...

  4. Java实现单链表反转操作

    单链表是一种常见的数据结构,由一个个节点通过指针方式连接而成,每个节点由两部分组成:一是数据域,用于存储节点数据.二是指针域,用于存储下一个节点的地址.在Java中定义如下: public class ...

  5. Java实现单链表的快速排序和归并排序

    本文描述了LeetCode 148题 sort-list 的解法. 题目描述如下: Sort a linked list in O(n log n) time using constant space ...

  6. Java解释单链表中的头插法以及尾插法

    单链表属于数据结构中的一种基本结构,是一种线性结构,在此使用Java对其中的头插法以及尾插法进行解释. 首先定义好链表中的节点类: 其中,data代表节点所存放的数据,next代表指向下一节点 对于单 ...

  7. 用Java实现单链表的基本操作

    笔试题中经常遇到单链表的考题,下面用java总结一下单链表的基本操作,包括添加删除节点,以及链表转置. package mars; //单链表添加,删除节点 public class ListNode ...

  8. java实现单链表常见操作

    一.概述: 本文主要总结单链表常见操作的实现,包括链表结点添加.删除:链表正向遍历和反向遍历.链表排序.判断链表是否有环.是否相交.获取某一结点等. 二.概念: 链表: 一种重要的数据结构,HashM ...

  9. 数据结构——Java实现单链表

    一.分析 单链表是一种链式存取的数据结构,用一组地址任意的存储单元存放线性表中的数据元素.链表中的数据是以结点来表示的,每个结点由元素和指针构成.在Java中,我们可以将单链表定义成一个类,单链表的基 ...

随机推荐

  1. UVA10779 Collectors Problem

    题目链接:https://cn.vjudge.net/problem/UVA-10779 前言: 本题是关于姜志豪<网络流的一些建模方法>的笔记. 知识点: 最大流 题意摘抄: \(Bob ...

  2. 【Oracle】CentOS7/CentOS8命令行重启Oracle 11G R2

    写在前面 按照读者朋友的要求写了一篇<[Oracle]CentOS7/CentOS8命令行安装Oracle 11G R2>,由于读者完全是按照我的安装方式安装的Oracle数据库,也是将O ...

  3. Ubuntu虚拟机的安装

    1.在VMware中新建虚拟机 注意W10的现在强制升级VMware所以大家,安装低版本的时候提示,升级就区官网下载一个新版本的即可. 这边大家填写自己的就好,要记住自己填写的! 这边我们等一会即可. ...

  4. MySQL递归查询

    MySQL8.0已经支持CTE递归查询,举例说明 CREATE TABLE EMP (EMPNO integer NOT NULL, ENAME ), JOB ), MGR integer, HIRE ...

  5. BUUCTF Crypto

    BUUCTF 几道crypto WP [AFCTF2018]Morse 简单的莫尔斯密码,最直观的莫尔斯密码是直接采用空格分割的点和划线,这题稍微绕了一下使用的是斜杠来划分 所以首先将斜杠全部替换为空 ...

  6. STM32与匿名上位机通信——使用串口DMA实现

    背景:匿名上位机功能强大,这里想要采用匿名上位机输出一些调试信息,以波形的形式显示,方便观察和调试. 平台: 硬件:STM32F405RGT6 通信:2.4G zigbee无线串口收发模块 CC253 ...

  7. Netty学习笔记(番外篇) - ChannelHandler、ChannelPipeline和ChannelHandlerContext的联系

    这一篇是 ChannelHandler 和 ChannelPipeline 的番外篇,主要从源码的角度来学习 ChannelHandler.ChannelHandler 和 ChannelPipeli ...

  8. 管程(Monitor)概念及Java的实现原理

    互斥 互斥访问是并发编程要解决的核心问题之一. 有许多种方法可以满足临界区的互斥访问.大体上可以分为三种, 一种是软件方法,即由用户程序承担互斥访问的责任,而不需要依赖编程语言或操作系统,譬如Dekk ...

  9. 上位机C#通过OPCUA和西门子PLC通信

    写在前面: 很多人在学习OPCUA的时候,有个非常苦恼的问题,就是没有OPCUA服务器的环境,这时候,有些人可能会想到通过类似于KepServer这样的软件来实现.那么,有没有一种方式,实现快速搭建O ...

  10. 面试官:兄弟,说说Java的static关键字吧

    读者乙在上一篇我去系列文章里留言说,"我盲猜下一篇标题是,'我去,你竟然不知道 static 关键字'".我只能说乙猜对了一半,像我这么有才华的博主,怎么可能被读者猜中了心思呢,必 ...