算法与数据结构-链表(linked-list)-Java实现单向链表
数据结构中的单向链表
PASCAL语言之父、图灵奖得主尼古拉斯·沃斯(Niklaus Wirth)曾有一句在计算机领域几乎人尽皆知的名言：“算法+数据结构=程序”（Algorithm+Data Structures=Programs）。java
数据结构指的是是计算机存储、组织数据的方式。其中数据的逻辑结构分为线性结构和非线性结构。node
线性结构是一个有序数据元素的集合，其数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素以外，其它数据元素都是首尾相接的。算法
最基础的两种表示元素集合的方式就是数组和链表。数组
数组指的是有序的元素序列。其中一维数组是线性的数据结构。数组的优势是经过索引能够访问任意元素，查找快。数组的缺点是在初始化数组的时候，就要知道数组的元素数量，并且插入和删除元素很是复杂。数据结构
链表就很好地解决了数组的缺点，其使用的空间大小和元素数量成正比，即不须要提供初始化的大小，并且插入和删除元素比较简单，不会“牵一发而动全身”。链表的缺点是须要经过引用访问任意元素，查找很复杂。ide
链表是一种递归的数据结构。通常链表分为单向链表和双向链表两种实现。测试
单向链表（单链表、线性链表）是链表的一种，其特色是链表的连接方向是单向的，对链表的访问要经过从头部开始，依序往下读取。而双向链表（双链表）的每一个数据结点中都有两个指针，分别指向直接后继和直接前驱。因此，从双向链表中的任意一个结点开始，均可以很方便地访问它的前驱结点和后继结点。spa
下面经过Java语言实现单向链表，来展现链表的相关操做。.net
Java实现单向链表
单向链表的每一个节点只须要定义两个属性：当前节点的元素，下一个节点。指针
class Node{
Item item;
Node node;
}
复制代码
使用链表实现栈
栈是一种先进后出(FILO)的数据结构，若是经过数组实现栈，则要考虑数组扩容的问题，能够经过链表来解决这个问题。
下面经过链表实现栈，并借此演示了在链表的头部增长节点以及除链表头部节点。
package net.ijiangtao.tech.algorithms.algorithmall.datastructure.stack;
public interface Stack<Item> {
/** * add an item * * @param item */
void push(Item item);
/** * remove the most recently added item * * @return */
Item pop();
/** * is the stack empty? * * @return */
boolean isEmpty();
/** * number of items in the stac */
int size();
}
复制代码
package net.ijiangtao.tech.algorithms.algorithmall.datastructure.stack.impl;
import net.ijiangtao.tech.algorithms.algorithmall.datastructure.stack.Stack;
import java.util.Iterator;
/** * 链表实现可迭代的栈 * @param <Item> * @author ijiangtao.net */
public class IterableLinkedListStack<Item> implements Stack<Item>,Iterable<Item> {
/** 栈顶元素 */
private Node first;
/** 栈元素数量 */
private int N;
/** 经过内部类定义链表节点 */
private class Node{
Item item;
Node next;
}
/** * 向栈顶增长元素，即在链表的头插入节点 * @param item */
@Override
public void push(Item item) {
Node oldFirst=first;
first=new Node();
first.item=item;
first.next=oldFirst;
N++;
}
/** * 从栈顶移除元素，即移除链表的头部节点 * @return */
@Override
public Item pop() {
Item item=first.item;
first=first.next;
N--;
return item;
}
@Override
public boolean isEmpty() {
return N==0;
}
@Override
public int size() {
return N;
}
@Override
public Iterator<Item> iterator() {
return new ListIterator();
}
/** * 支持迭代方法，实如今内部类里 */
private class ListIterator implements Iterator<Item> {
private Node current = first;
@Override
public boolean hasNext() {
//或者 N!=0
return current !=null;
}
@Override
public Item next() {
Item item=current.item;
current=current.next;
return item;
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
}
public static void main(String[] args) {
//测试
Stack<String> stack=new IterableLinkedListStack<>();
stack.push("aa");
stack.push("bbb");
stack.push("abc");
for (String s:(IterableLinkedListStack<String>)stack) {
System.out.println(s);
}
System.out.println("stack.size="+stack.size());
System.out.println("stack.pop="+stack.pop());
System.out.println("stack.size="+stack.size());
System.out.println("stack.isEmpty="+stack.isEmpty());
System.out.println("stack.pop="+stack.pop());
System.out.println("stack.pop="+stack.pop());
System.out.println("stack.size="+stack.size());
System.out.println("stack.isEmpty="+stack.isEmpty());
//测试输出
/** * abc * bbb * aa * stack.size=3 * stack.pop=abc * stack.size=2 * stack.isEmpty=false * stack.pop=bbb * stack.pop=aa * stack.size=0 * stack.isEmpty=true */
}
}
复制代码
使用链表实现队列
队列是一种基于先进先出(FIFO)策略的集合模型。
下面基于链表实现队列，并演示使用。
package net.ijiangtao.tech.algorithms.algorithmall.datastructure.queue;
/** * 队列 * @author ijiangtao.net * @param <Item> */
public interface Queue<Item> {
/** * 队列是否为空 * @return */
boolean isEmpty();
/** * 队列大小 * @return */
int size();
/** * 入队 * @param item */
public void enqueue(Item item);
/** * 出队 * @return */
public Item dequeue();
}
复制代码
package net.ijiangtao.tech.algorithms.algorithmall.datastructure.queue.impl;
import net.ijiangtao.tech.algorithms.algorithmall.datastructure.queue.Queue;
import java.util.Iterator;
/** * 队列 * @author ijiangtao.net * @param <Item> */
public class IterableLinkedListQueue<Item> implements Queue<Item>,Iterable<Item>{
/** 队头，最初入队的节点 */
private Node first;
/**队尾，最晚入队的节点*/
private Node last;
/** 队列中元素的数量 */
private int N;
private class Node{
Item item;
Node next;
}
@Override
public boolean isEmpty() {
//或N==0
return first==null;
}
@Override
public int size() {
return N;
}
/** * 入队，即向队尾增长一个元素 * @param item */
@Override
public void enqueue(Item item) {
Node oldLast=last;
last=new Node();
last.item=item;
last.next=null;
if (isEmpty()){
first=last;
}else {
oldLast.next=last;
}
N++;
}
/** * 出队，即移除队头元素 * @return */
@Override
public Item dequeue() {
Item item=first.item;
first=first.next;
if (isEmpty()){
last=null;
}
N--;
return item;
}
@Override
public Iterator<Item> iterator() {
return new ListIterator();
}
/** * 支持迭代方法，实如今内部类里 */
private class ListIterator implements Iterator<Item> {
private Node current = first;
@Override
public boolean hasNext() {
//或者 N!=0
return current !=null;
}
@Override
public Item next() {
Item item=current.item;
current=current.next;
return item;
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
}
public static void main(String[] args) {
//测试
Queue<String> queue=new IterableLinkedListQueue<>();
queue.enqueue("aa");
queue.enqueue("bbb");
queue.enqueue("abc");
for (String s:(IterableLinkedListQueue<String>)queue) {
System.out.println(s);
}
System.out.println("queue.size="+queue.size());
System.out.println("queue.dequeue="+queue.dequeue());
System.out.println("queue.size="+queue.size());
System.out.println("queue.isEmpty="+queue.isEmpty());
System.out.println("queue.dequeue="+queue.dequeue());
System.out.println("queue.dequeue="+queue.dequeue());
System.out.println("queue.size="+queue.size());
System.out.println("queue.isEmpty="+queue.isEmpty());
//测试输出
/** * aa * bbb * abc * queue.size=3 * queue.dequeue=aa * queue.size=2 * queue.isEmpty=false * queue.dequeue=bbb * queue.dequeue=abc * queue.size=0 * queue.isEmpty=true */
}
}
复制代码
使用链表实现背包
背包是一种只支持添加不支持删除的容器，它的做用是收集元素，并遍历所收集到的元素。
包(Bag)与栈同样，遵循先进后出的策略（FILO）。
下面提供基于链表的背包实现。
package net.ijiangtao.tech.algorithms.algorithmall.datastructure.bag;
/** * 背包 * @author ijiangtao.net * @param <Item> */
public interface Bag<Item> extends Iterable<Item>{
/** * 向背包内加入元素 * @param item */
void add(Item item);
}
复制代码
package net.ijiangtao.tech.algorithms.algorithmall.datastructure.bag.impl;
import net.ijiangtao.tech.algorithms.algorithmall.datastructure.bag.Bag;
import java.util.Iterator;
public class IterableLinkedListBag<Item> implements Bag<Item> {
private Node first;
private class Node{
Item item;
Node next;
}
@Override
public void add(Item item) {
Node oldFirst=first;
first=new Node();
first.item=item;
first.next=oldFirst;
}
@Override
public Iterator<Item> iterator() {
return new ListIterator();
}
/** * 支持迭代方法，实如今内部类里 */
private class ListIterator implements Iterator<Item> {
private Node current = first;
@Override
public boolean hasNext() {
//或者 N!=0
return current !=null;
}
@Override
public Item next() {
Item item=current.item;
current=current.next;
return item;
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
}
public static void main(String[] args) {
//测试
Bag<String> bag=new IterableLinkedListBag<>();
bag.add("aa");
bag.add("bbb");
bag.add("abc");
for (String s:bag) {
System.out.println(s);
}
//测试输出
/** * abc * bbb * aa */
}
}
复制代码
相关文章
- 1. 数据结构与算法－单向链表(js实现)
- 2. 数据结构与算法 — 单链表
- 3. 数据结构与算法 - 单链表
- 4. 数据结构与算法（单链表）
- 5. 【译】JavaScript数据结构（3）：单向链表与双向链表
- 6. 数据结构与算法15-链表-单链表
- 7. C+数据结构与算法之链表之单链表
- 8. js数据结构与算法--双向链表的实现
- 9. 数据结构与算法－双向链表(js实现)
- 10. 数据结构与算法之PHP实现链表类（单链表/双链表/循环链表）
- 更多相关文章...
- • Redis链表（linked-list）数据结构和常用命令 - Redis教程
- • Markdown 链接 - Markdown 教程
- • TiDB 在摩拜单车在线数据业务的应用和实践
- • 算法总结-回溯法
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. Duang!超快Wi-Fi来袭
- 2. 机器学习-补充03 神经网络之**函数(Activation Function)
- 3. git上开源maven项目部署 多module maven项目（多module maven+redis+tomcat+mysql）后台部署流程学习记录
- 4. ecliple-tomcat部署maven项目方式之一
- 5. eclipse新导入的项目经常可以看到“XX cannot be resolved to a type”的报错信息
- 6. Spark RDD的依赖于DAG的工作原理
- 7. VMware安装CentOS-8教程详解
- 8. YDOOK：Java 项目 Spring 项目导入基本四大 jar 包 导入依赖，怎样在 IDEA 的项目结构中导入 jar 包 导入依赖
- 9. 简单方法使得putty（windows10上）可以免密登录树莓派
- 10. idea怎么用本地maven
欢迎关注本站公众号,获取更多信息
