1. 定义节点node

public class Node<T> {

	private Node<T> pre;

	private Node<T> next;

	private T data;

	public void setPre(Node<T> node){
this.pre = node;
} public Node<T> getPre(){
return pre;
} public void setNext(Node<T> node){
this.next = node;
} public Node<T> getNext(){
return next;
} public void setData(T data){
this.data = data;
} public T getData(){
return this.data;
} public Node(Node<T> pre, Node<T> next, T data){
this.pre = pre;
this.next = next;
this.data = data;
} public Node(){
super();
}
}

2.  创建链表方式1,与c++类似

public class ListDirectNode<T extends Comparable<T>> {

	private byte[] lock = new byte[1];

	/**
* 链表大小
*/
private int size; /**
* 链表头节点
*/
private Node<T> header; /**
* 链表尾部节点
*/
private Node<T> tail; public void setHeader(Node<T> node){
this.header = node;
} public Node<T> getHeader(){
return this.header;
} public void setTail(Node<T> node){
this.tail = node;
} public Node<T> getTail(){
return this.tail;
} public int size(){
return this.size;
} public ListDirectNode(){
size = 0;
header = new Node<T>(null, null, null);
tail = new Node<T>(header, null, null);
header.setNext(tail);
} /**
* 往链表尾部追加数据
* @param data
*/
public void add(T data){
synchronized (lock) {
Node<T> node = new Node<T>(null, null, data);
tail.getPre().setNext(node);
node.setPre(tail);
node.setNext(tail);
tail.setPre(node);
size++;
}
} /**
* @param sortType 排序方式
* true:升序
* false:降序
*/
public void sort(boolean sortType){
for(Node<T> node1 = header.getNext(); node1.getNext() != tail; node1 = node1.getNext()){
for(Node<T> node2 = node1.getNext(); node2 != tail; node2 = node2.getNext()){
T d1 = node1.getData();
T d2 = node2.getData();
if(sortType){
if(compare(d1, d2) > 0){
node1.setData(d2);
node2.setData(d1);
}
}else{
if(compare(d1, d2) < 0){
node1.setData(d2);
node2.setData(d1);
}
}
}
}
} private int compare(T d1, T d2){
return d1.compareTo(d2);
} public boolean isEmpty(){
return size==0;
} public T get(int index){
if(index > size || index < 0){
throw new IndexOutOfBoundsException();
}
Node<T> currentNode = new Node<T>(header, null, null);
for(int i=1; i<=index; i++){
currentNode = currentNode.getNext();
}
return currentNode.getData();
} public void print(){
int index = 0;
Node<T> currentNode = header.getNext();
while(currentNode.getNext() != null){
index++;
System.out.println("当前位置:"+index+",当前值"+currentNode.getData().toString());
currentNode = currentNode.getNext();
}
}
}

3. 创建链表方式2,迭代器

public class MyList<T extends Comparable<T>> implements Iterable<T>{

	/**
* 链表大小
*/
private int size; /**
* 链表头节点
*/
private Node<T> header; /**
* 链表下一节点
*/
private Node<T> tail; public void setHeader(Node<T> node){
this.header = node;
} public Node<T> getHeader(){
return this.header;
} public void setTail(Node<T> node){
this.tail = node;
} public Node<T> getTail(){
return this.tail;
} public int size(){
return this.size;
} public MyList(){
size = 0;
header = new Node<T>(null, null, null);
tail = new Node<T>(header, null, null);
header.setNext(tail);
} public void add(T data){
Node<T> node = new Node<T>(null, null, data);
tail.getPre().setNext(node);
node.setPre(tail);
node.setNext(tail);
tail.setPre(node);
size++;
} /**
* @param sortType 排序方式
* true:升序
* false:降序
*/
public void sort(boolean sortType){
for(Node<T> node1 = header.getNext(); node1.getNext() != tail; node1 = node1.getNext()){
for(Node<T> node2 = node1.getNext(); node2 != tail; node2 = node2.getNext()){
T d1 = node1.getData();
T d2 = node2.getData();
if(sortType){
if(compare(d1, d2) > 0){
node1.setData(d2);
node2.setData(d1);
}
}else{
if(compare(d1, d2) < 0){
node1.setData(d2);
node2.setData(d1);
}
}
}
}
} private int compare(T d1, T d2){
return d1.compareTo(d2);
} public void print(){
int index = 0;
Iterator<T> iterator = this.iterator();
while(iterator.hasNext()){
index++;
System.out.println("当前位置:"+index+",当前值"+iterator.next().toString());
}
} @Override
public Iterator<T> iterator() {
return new MyListIterator<T>();
} private class MyListIterator<T> implements Iterator<T>{ @SuppressWarnings("unchecked")
Node<T> current = (Node<T>) header.getNext(); @Override
public boolean hasNext() {
return current != tail;
} @Override
public T next() {
if(!hasNext()){
throw new IndexOutOfBoundsException();
}
T data = current.getData();
current = current.getNext();
return data;
} @Override
public void remove() {
if(!hasNext()){
throw new NoSuchElementException();
}
current.getPre().setNext(current.getNext());
current.getNext().setPre(current.getPre());
current = current.getNext();
size--;
}
}
}

4. 测试代码

public class TestMain {

	public static void main(String[] args){
ListDirectNode<String> list = new ListDirectNode<String>();
list.add("a");
list.add("d");
list.add("b");
list.add("e");
list.sort(true);
list.print(); MyList<String> list2 = new MyList<String>();
list2.add("a1");
list2.add("d1");
list2.add("b1");
list2.add("e1");
list2.sort(true);
list2.print(); ListDirectNode<Integer> list3 = new ListDirectNode<Integer>();
list3.add(1);
list3.add(3);
list3.add(2);
list3.add(10);
list3.sort(false);
list3.print(); MyList<Integer> list4 = new MyList<Integer>();
list4.add(10);
list4.add(3);
list4.add(6);
list4.add(0);
list4.sort(false);
list4.print();
}
}

java实现链表结构的更多相关文章

  1. (原创)用Java实现链表结构对象:单向无环链表

    转载请注明本文出处:http://www.cnblogs.com/Starshot/p/6918569.html 链表的结构是由一个一个节点组成的,所谓链,就是每个节点的头尾连在一起.而单向链表就是: ...

  2. java实现链表结构详细代码

    一.数据准备 1. 定义节点 2.   定义链表 1.数据部分 2.节点部分 class DATA //数据节点类型 { String key; String name; int age; } cla ...

  3. Java实现链表结构的具体代码

    一.数据准备 1. 定义节点 2.   定义链表 1.数据部分 2.节点部分 class DATA //数据节点类型 { String key; String name; int age; } cla ...

  4. JAVA基础——链表结构之单链表

    链表:一种数据存储结构.学链表首先要搞懂数组,按朋友的话说,数组和链表的关系就相当于QQ2008和QQ2009. 除非要通过索引频繁访问各个数据,不然大多数情况下都可以用链表代替数组. 链表部分主要要 ...

  5. JAVA基础——链表结构之双端链表

    双端链表:双端链表与传统链表非常相似.只是新增了一个属性-即对最后一个链结点的引用 如上图所示:由于有着对最后一个链结点的直接引用.所以双端链表比传统链表在某些方面要方便.比如在尾部插入一个链结点.双 ...

  6. 《Java数据结构》链表结构(单向链表,双向链表)

    单向链表(单链表)是链表的一种,其特点是链表的链接方向是单向的,对链表的访问要通过顺序读取从头部开始:链表是使用指针进行构造的列表:又称为结点列表,因为链表是由一个个结点组装起来的:其中每个结点都有指 ...

  7. java数据结构--线性结构

    一.数据结构 数据结构由数据和结构两部分组成,就是将数据按照一定的结构组合起来,这样不同的组合方式有不同的效率,可根据需求选择不同的结构应用在相应在场景.数据结构大致 分为两类:线性结构(如数组,链表 ...

  8. java单链表常用操作

    总结提高,与君共勉 概述. 数据结构与算法亘古不变的主题,链表也是面试常考的问题,特别是手写代码常常出现,将从以下方面做个小结 [链表个数] [反转链表-循环] [反转链表-递归] [查找链表倒数第K ...

  9. java资料——链表(转)

    链表 链表是一种物理存储单元上非连续.非顺序的存储结构,数据元素的逻辑顺序是通过链表中的指针链接次序实现的.链表由一系列结点(链表中每一个元素称为结点)组成,结点可以在运行时动态生成.每个结点包括两个 ...

随机推荐

  1. C++和MATLAB混合编程-DLL

    先小话一下DLL,DLL是动态链接库,是源代码编译后的二进制库文件和程序接口,和静态链接库不同的是,程序在编译时并不链接动态链接库的执行体,而是在文件中保留一个调用标记,在程序运行时才将动态链接库文件 ...

  2. Git (2)

    要使用Git首先遇到的问题是怎么把文件加到库中. 很简单. 新建一个目录,然后git init. 完成上述工作之后的唯一改动是在当前目录下生成了一个.git的子目录.这个子目录是一个集中的数据库,包含 ...

  3. XPATH 注入的介绍与代码防御

    0x01 介绍 软件未正确对 XML 中使用的特殊元素进行无害化处理,导致攻击者能够在终端系统处理 XML 的语法.内容或命令之前对其进行修改.在 XML 中,特殊元素可能包括保留字或字符,例如“&l ...

  4. 微信菜单开发:使用PHP数组来定义微信菜单

    目前使用数组的方式来定义,然后在通过json_encode函数来转JSON $menuJson=array(); $menuJson['button'][]=array('name'=>urle ...

  5. [Linux]XAMPP安装

    XAMPP安装下载地址:http://xiazai.zol.com.cn/index.php?c=Detail_DetailMini&n=19e18f86d0596b5cd&softi ...

  6. jquery roundabout幻灯片插件3d图片切换支持图片旋转切换滚动

    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/ ...

  7. PHP扩展Redis编译安装

    PHP扩展Redis编译安装 1.下载PHP官方Redis源码包  wget http://pecl.php.net/get/redis-2.2.4.tgz  注:我用的是Redhat系统,ubunt ...

  8. Memcache,Redis

    Memcache Memcached 是一个高性能的分布式内存对象缓存系统,用于动态Web应用以减轻数据库负载.它通过在内存中缓存数据和对象来减少读取数据库的次数,从而提高动态.数据库驱动网站的速度. ...

  9. WPF Navigation导航

    WPF导航这个话题,网上的解决方法有很多种,有点吃猪脚的感觉,弃之可惜,食之乏味. 不过还是简单聊聊吧. 常见的导航: 利用HyperLink导航,可以到某一个Page页面,也可以是外部链接,当然也可 ...

  10. WebApi学习总结系列第五篇(消息处理管道)

    引言: ASP.NET WebAPI的核心框架是一个消息处理管道,这个管道是一组HttpMessageHandler的有序组合.这是一个双工管道,请求消息从一端流入并依次经过所有HttpMessage ...