java双向链表实现迭代_Java实现一个双向链表的倒置功能

淩亂°似流年 2022-11-06 04:52 186阅读 0赞

双向链表类代码：public class DoubleLinkedList \{

transient Node first; //头节点

transient Node last; //尾节点

transient int size = 0; //节点个数

public DoubleLinkedList() \{

/\*\*

\* 判断是否为空

\* @return true 为空, false 不为空

\*/

public boolean isEmpty() \{

return 0 == size;

/\*\*

\* 获取表元素个数

\* @return 表链元素个数

\*/

public int size() \{

return size;

/\*\*

\* 反序排列列表中的值

\*/

public void reverse() \{

if (isEmpty()) \{

return;

// 表的头节点与尾节点互换位置

Node temp = first;

first = last;

last = temp;

// 从表头按序遍历 更每个新节点的前后节点互换

Node n = first;

while (n != null) \{

temp = n.next;

n.next = n.per;

n.per = temp;

n = n.next;

/\*\*

\* 根据索引获取元素

\* @param index 元素

\* @return

\*/

public E get(int index) \{

checkIndex(index);

return getNode(index).item;

/\*\*

\* 将元素追加到列表的末尾

\* @param item 元素

\*/

public void add(E item) \{

Node l = last;

Node newNode = new Node(l, item, null);

last = newNode;

if (l == null) \{

first = newNode;

\} else \{

l.next = newNode;

size++;

/\*\*

\* 根据索引获取节点

\* @param index 索引

\* @return 节点

\*/

private Node getNode(int index) \{

if (index < (size >> 2)) \{ //如果索引在列表前面 正序遍历

Node node = first;

for (int i = 0; i < index; i++) \{

node = node.next;

return node;

\} else \{ //否则倒叙遍历

Node node = last;

for (int i = size - 1; i > index; i--) \{

node = node.per;

return node;

/\*\*

\* 检查索引值

\* @param index 索引

\*/

private void checkIndex(int index) \{

if (index < 0 || index >= size) \{

throw new IndexOutOfBoundsException();

/\*\*

\* 节点元素

\* @param

\*/

private class Node \{

E item;//元素的值

Node per;// 前一个结点

Node next;// 后一个结点

public Node(Node per, E item, Node next) \{

this.item = item;

this.per = per;

this.next = next;

public String toString() \{

return item + "";

/\*\*

\* 自定义个一个列表迭代器

\* @return

\*/

public Iterator iterator() \{

return new Itr();

private class Itr implements Iterator \{

int cursor = 0;

int lastRet = -1;

public boolean hasNext() \{

return cursor != size();

public E next() \{

try \{

E next = get(cursor);

lastRet = cursor++;

return next;

\} catch (IndexOutOfBoundsException e) \{

throw new NoSuchElementException();

public void remove() \{

if (-1 == lastRet) \{

throw new IllegalStateException();

throw new RuntimeException("remove is denied");

下面在创建一个测试用例：public class DoubleLinkedListTest \{

/\*\*

\* 链表打印

\* @param list

\*/

public static void printDoubleLinkedList(DoubleLinkedList list) \{

StringBuffer sb = new StringBuffer();

Iterator it = list.iterator();

while (it.hasNext()) \{

sb.append(it.next());

if(it.hasNext()) \{

sb.append("->");

System.out.println(sb.toString());

public static void main(String\[\] args) \{

DoubleLinkedList list = new DoubleLinkedList();

list.add(1);

list.add(2);

list.add(3);

System.out.println("链表倒置前:");

printDoubleLinkedList(list);

list.reverse();

System.out.println("链表倒置后:");

printDoubleLinkedList(list);

java双向链表实现迭代_Java实现一个双向链表的倒置功能

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 Java实现双向链表

相关实现双向链表算法（Java）

相关 java模拟双向链表实现

相关 Java实现双向链表

相关用Java实现双向链表

相关 java双向链表实现迭代_Java实现一个双向链表的倒置功能

相关 c语言双向链表实现,双向链表(双向循环链表)的建立及C语言实现

相关 java实现双向循环链表

相关双向链表下的简单迭代器实现

相关双向链表Java实现