Java数据结构和算法：数组、单链表、双链表

最新推荐文章于 2024-07-15 17:21:36 发布
转载 最新推荐文章于 2024-07-15 17:21:36 发布 · 1.3k 阅读 · 2
文章标签：

#数据结构 #单链表 #算法 #双链表 #数组

本文介绍了线性表的基本概念，包括数组、单向链表和双向链表的特点，并详细阐述了双向链表的C++实现方法及操作流程。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1. 概要

线性表是一种线性结构，它是具有相同类型的n(n≥0)个数据元素组成的有限序列。本章先介绍线性表的几个基本组成部分：数组、单向链表、双向链表；随后给出双向链表的C、C++和Java三种语言的实现

2. 数组

数组有上界和下界，数组的元素在上下界内是连续的。存储10,20,30,40,50的数组的示意图如下

数组

数组的特点是：数据是连续的；随机访问速度快。

数组中稍微复杂一点的是多维数组和动态数组。对于C语言而言，多维数组本质上也是通过一维数组实现的。至于动态数组，是指数组的容量能动态增长的数组；对于C语言而言，若要提供动态数组，需要手动实现；而对于C++而言，STL提供了Vector；对于Java而言，Collection集合中提供了ArrayList和Vector。

3. 单向链表

单向链表(单链表)是链表的一种，它由节点组成，每个节点都包含下一个节点的指针。

单链表的示意图如下：

单链表

表头为空，表头的后继节点是”节点10”(数据为10的节点)，”节点10”的后继节点是”节点20”(数据为10的节点)

3.1 单链表删除节点

单链表

删除”节点30”
删除之前：”节点20” 的后继节点为”节点30”，而”节点30” 的后继节点为”节点40”。
删除之后：”节点20” 的后继节点为”节点40”。

3.2 单链表添加节点

单链表

在”节点10”与”节点20”之间添加”节点15”
添加之前：”节点10” 的后继节点为”节点20”。
添加之后：”节点10” 的后继节点为”节点15”，而”节点15” 的后继节点为”节点20”。

单链表的特点是：节点的链接方向是单向的；相对于数组来说，单链表的的随机访问速度较慢，但是单链表删除/添加数据的效率很高。

4. 双向链表

双向链表(双链表)是链表的一种。和单链表一样，双链表也是由节点组成，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。

双链表的示意图如下：

双链表

表头为空，表头的后继节点为”节点10”(数据为10的节点)；”节点10”的后继节点是”节点20”(数据为10的节点)，”节点20”的前继节点是”节点10”；”节点20”的后继节点是”节点30”，”节点30”的前继节点是”节点20”；…；末尾节点的后继节点是表头。

4.1 双链表删除节点

双链表

删除”节点30”
删除之前：”节点20”的后继节点为”节点30”，”节点30” 的前继节点为”节点20”。”节点30”的后继节点为”节点40”，”节点40” 的前继节点为”节点30”。
删除之后：”节点20”的后继节点为”节点40”，”节点40” 的前继节点为”节点20”。

4.2 双链表添加节点

双链表

在”节点10”与”节点20”之间添加”节点15”
添加之前：”节点10”的后继节点为”节点20”，”节点20” 的前继节点为”节点10”。
添加之后：”节点10”的后继节点为”节点15”，”节点15” 的前继节点为”节点10”。”节点15”的后继节点为”节点20”，”节点20” 的前继节点为”节点15”。

5. Java实现双链表

/**
 * Java 实现的双向链表。 
 * 注：java自带的集合包中有实现双向链表，路径是:java.util.LinkedList
 *
 * @author skywang
 * @date 2013/11/07
 */
public class DoubleLink<T> {

    // 表头
    private DNode<T> mHead;
    // 节点个数
    private int mCount;

    // 双向链表“节点”对应的结构体
    private class DNode<T> {
        public DNode prev;
        public DNode next;
        public T value;

        public DNode(T value, DNode prev, DNode next) {
            this.value = value;
            this.prev = prev;
            this.next = next;
        }
    }

    // 构造函数
    public DoubleLink() {
        // 创建“表头”。注意：表头没有存储数据！
        mHead = new DNode<T>(null, null, null);
        mHead.prev = mHead.next = mHead;
        // 初始化“节点个数”为0
        mCount = 0;
    }

    // 返回节点数目
    public int size() {
        return mCount;
    }

    // 返回链表是否为空
    public boolean isEmpty() {
        return mCount==0;
    }

    // 获取第index位置的节点
    private DNode<T> getNode(int index) {
        if (index<0 || index>=mCount)
            throw new IndexOutOfBoundsException();

        // 正向查找
        if (index <= mCount/2) {
            DNode<T> node = mHead.next;
            for (int i=0; i<index; i++)
                node = node.next;

            return node;
        }

        // 反向查找
        DNode<T> rnode = mHead.prev;
        int rindex = mCount - index -1;
        for (int j=0; j<rindex; j++)
            rnode = rnode.prev;

        return rnode;
    }

    // 获取第index位置的节点的值
    public T get(int index) {
        return getNode(index).value;
    }

    // 获取第1个节点的值
    public T getFirst() {
        return getNode(0).value;
    }

    // 获取最后一个节点的值
    public T getLast() {
        return getNode(mCount-1).value;
    }

    // 将节点插入到第index位置之前
    public void insert(int index, T t) {
        if (index==0) {
            DNode<T> node = new DNode<T>(t, mHead, mHead.next);
            mHead.next.prev = node;
            mHead.next = node;
            mCount++;
            return ;
        }

        DNode<T> inode = getNode(index);
        DNode<T> tnode = new DNode<T>(t, inode.prev, inode);
        inode.prev.next = tnode;
        inode.next = tnode;
        mCount++;
        return ;
    }

    // 将节点插入第一个节点处。
    public void insertFirst(T t) {
        insert(0, t);
    }

    // 将节点追加到链表的末尾
    public void appendLast(T t) {
        DNode<T> node = new DNode<T>(t, mHead.prev, mHead);
        mHead.prev.next = node;
        mHead.prev = node;
        mCount++;
    }

    // 删除index位置的节点
    public void del(int index) {
        DNode<T> inode = getNode(index);
        inode.prev.next = inode.next;
        inode.next.prev = inode.prev;
        inode = null;
        mCount--;
    }

    // 删除第一个节点
    public void deleteFirst() {
        del(0);
    }

    // 删除最后一个节点
    public void deleteLast() {
        del(mCount-1);
    }
}

测试程序(DlinkTest.java)

/**
 * Java 实现的双向链表。 
 * 注：java自带的集合包中有实现双向链表，路径是:java.util.LinkedList
 *
 * @author skywang
 * @date 2013/11/07
 */

public class DlinkTest {

    // 双向链表操作int数据
    private static void int_test() {
        int[] iarr = {10, 20, 30, 40};

        System.out.println("\n----int_test----");
        // 创建双向链表
        DoubleLink<Integer> dlink = new DoubleLink<Integer>();

        dlink.insert(0, 20);    // 将 20 插入到第一个位置
        dlink.appendLast(10);    // 将 10 追加到链表末尾
        dlink.insertFirst(30);    // 将 30 插入到第一个位置

        // 双向链表是否为空
        System.out.printf("isEmpty()=%b\n", dlink.isEmpty());
        // 双向链表的大小
        System.out.printf("size()=%d\n", dlink.size());

        // 打印出全部的节点
        for (int i=0; i<dlink.size(); i++)
            System.out.println("dlink("+i+")="+ dlink.get(i));
    }


    private static void string_test() {
        String[] sarr = {"ten", "twenty", "thirty", "forty"};

        System.out.println("\n----string_test----");
        // 创建双向链表
        DoubleLink<String> dlink = new DoubleLink<String>();

        dlink.insert(0, sarr[1]);    // 将 sarr中第2个元素 插入到第一个位置
        dlink.appendLast(sarr[0]);    // 将 sarr中第1个元素 追加到链表末尾
        dlink.insertFirst(sarr[2]);    // 将 sarr中第3个元素 插入到第一个位置

        // 双向链表是否为空
        System.out.printf("isEmpty()=%b\n", dlink.isEmpty());
        // 双向链表的大小
        System.out.printf("size()=%d\n", dlink.size());

        // 打印出全部的节点
        for (int i=0; i<dlink.size(); i++)
            System.out.println("dlink("+i+")="+ dlink.get(i));
    }


    // 内部类
    private static class Student {
        private int id;
        private String name;

        public Student(int id, String name) {
            this.id = id;
            this.name = name;
        }

        @Override
        public String toString() {
            return "["+id+", "+name+"]";
        }
    }

    private static Student[] students = new Student[]{
        new Student(10, "sky"),
        new Student(20, "jody"),
        new Student(30, "vic"),
        new Student(40, "dan"),
    };

    private static void object_test() {
        System.out.println("\n----object_test----");
        // 创建双向链表
        DoubleLink<Student> dlink = new DoubleLink<Student>();

        dlink.insert(0, students[1]);    // 将 students中第2个元素 插入到第一个位置
        dlink.appendLast(students[0]);    // 将 students中第1个元素 追加到链表末尾
        dlink.insertFirst(students[2]);    // 将 students中第3个元素 插入到第一个位置

        // 双向链表是否为空
        System.out.printf("isEmpty()=%b\n", dlink.isEmpty());
        // 双向链表的大小
        System.out.printf("size()=%d\n", dlink.size());

        // 打印出全部的节点
        for (int i=0; i<dlink.size(); i++) {
            System.out.println("dlink("+i+")="+ dlink.get(i));
        }
    }


    public static void main(String[] args) {
        int_test();        // 演示向双向链表操作“int数据”。
        string_test();    // 演示向双向链表操作“字符串数据”。
        object_test();    // 演示向双向链表操作“对象”。
    }
}

运行结果

----int_test----
isEmpty()=false
size()=3
dlink(0)=30
dlink(1)=20
dlink(2)=10

----string_test----
isEmpty()=false
size()=3
dlink(0)=thirty
dlink(1)=twenty
dlink(2)=ten

----object_test----
isEmpty()=false
size()=3
dlink(0)=[30, vic]
dlink(1)=[20, jody]
dlink(2)=[10, sky]

6. 双链表实现2

public class MyDoubleLink implements Iterable<Object>{
    private class Node{
        public Node(Object data){
            this.data = data;
        }
        Node next;
        Node prev;
        Object data;
    }
    private Node head;
    private Node rear;

    public void add(Object data){
        Node node = new Node(data);
        if (head == null){
            head = node;
            rear = node;
        } else {
            rear.next = node;
            node.prev = rear;
            rear = node;
        }
    }

    public boolean contains(Object data){
        Node node = find(data);
        return node != null;
    }

    public void print(){
        Node temp = head;
        while(temp != null){
            System.out.print(temp.data + ",");
            temp = temp.next;
        }
        System.out.println();
    }
    private Node find(Object data){
        Node node = head;
        while (node != null){
            if (node.data.equals(data) && node.data.hashCode() == data.hashCode()){
                break;
            } else {
                node = node.next;
            }
        }
        return node;
    }

    public void remove(Object data){
        Node node = find(data);
        if (node != null){
            if (node == head && node == rear){//只有一个节点
                head = null;
                rear = null;
            } else if (node == head){ //头节点
                head = head.next;
                head.prev = null;
            } else if (node == rear){ //尾节点
                rear = rear.prev;
                rear.next = null;
            } else { //中间节点
                node.prev.next = node.next;
                node.next.prev = node.prev;
            }
        }
    }

    @Override
    public Iterator<Object> iterator() {
        Iterator<Object> ite = new Iterator<Object>() {
            private Node temp = head;
            @Override
            public boolean hasNext() {
                return temp != null;
            }

            @Override
            public Object next() {
                // TODO Auto-generated method stub
                Object data = temp.data;
                temp = temp.next;
                return data;
            }

            @Override
            public void remove() {
                // TODO Auto-generated method stub      
            }
        };
        return ite;
    }   
}

6.1 测试双链表

public class Test {

    public static  class Instance{
        public Instance(int i){

        }
        public Instance(){

        }
    }

    public static void main(String[] args) {
        Instance in  = new Instance(){

        };
        MyDoubleLink datas = new MyDoubleLink();
        datas.add("aaa");
        datas.add("bbb");
        datas.add("ccc");
        datas.print();
        datas.remove("ccc");
        datas.print();
        for (Object d : datas) {
            System.out.println(d);
        }
    }
}

7. 双链表

import java.util.Iterator;
public class MyDoubleLink implements Iterable<Object>{
    private class Node{
        public Node(Object data){
            this.data = data;
        }
        Node next;
        Node prev;
        Object data;
    }
    private Node head;
    private Node rear;

    public void add(Object data){
        Node node = new Node(data);
        if (head == null){
            head = node;
            rear = node;
        } else {
            rear.next = node;
            node.prev = rear;
            rear = node;
        }
    }

    public boolean contains(Object data){
        Node node = find(data);
        return node != null;
    }

    public void print(){
        Node temp = head;
        while(temp != null){
            System.out.print(temp.data + ",");
            temp = temp.next;
        }
        System.out.println();
    }
    private Node find(Object data){
        Node node = head;
        while (node != null){
            if (node.data.equals(data) && node.data.hashCode() == data.hashCode()){
                break;
            } else {
                node = node.next;
            }
        }
        return node;
    }

    public void remove(Object data){
        Node node = find(data);
        if (node != null){
            if (node == head && node == rear){//只有一个节点
                head = null;
                rear = null;
            } else if (node == head){ //头节点
                head = head.next;
                head.prev = null;
            } else if (node == rear){ //尾节点
                rear = rear.prev;
                rear.next = null;
            } else { //中间节点
                node.prev.next = node.next;
                node.next.prev = node.prev;
            }
        }
    }

    @Override
    public Iterator<Object> iterator() {
        Iterator<Object> ite = new Iterator<Object>() {
            private Node temp = head;
            @Override
            public boolean hasNext() {
                return temp != null;
            }

            @Override
            public Object next() {
                // TODO Auto-generated method stub
                Object data = temp.data;
                temp = temp.next;
                return data;
            }

            @Override
            public void remove() {
                // TODO Auto-generated method stub

            }
        };
        return ite;
    }
}

public class TEst {

    public static  class Instance{
        public Instance(int i){

        }
        public Instance(){

        }
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Instance in  = new Instance(){

        };
        MyDoubleLink datas = new MyDoubleLink();
        datas.add("aaa");
        datas.add("bbb");
        datas.add("ccc");
        datas.print();
        datas.remove("ccc");
        datas.print();
        for (Object d : datas) {
            System.out.println(d);
        }
    }
}

7.1 单链表的实现

// linkList2.java
// demonstrates linked list
// to run this program: C>java LinkList2App
////////////////////////////////////////////////////////////////
class Link
   {
   public int iData;              // data item (key)
   public double dData;           // data item
   public Link next;              // next link in list
// -------------------------------------------------------------
   public Link(int id, double dd) // constructor
      {
      iData = id;
      dData = dd;
      }
// -------------------------------------------------------------
   public void displayLink()      // display ourself
      {
      System.out.print("{" + iData + ", " + dData + "} ");
      }
   }  // end class Link
////////////////////////////////////////////////////////////////
class LinkList
   {
   private Link first;            // ref to first link on list

// -------------------------------------------------------------
   public LinkList()              // constructor
      {
      first = null;               // no links on list yet
      }
// -------------------------------------------------------------
   public void insertFirst(int id, double dd)
      {                           // make new link
      Link newLink = new Link(id, dd);
      newLink.next = first;       // it points to old first link
      first = newLink;            // now first points to this
      }
// -------------------------------------------------------------
   public Link find(int key)      // find link with given key
      {                           // (assumes non-empty list)
      Link current = first;              // start at 'first'
      while(current.iData != key)        // while no match,
         {
         if(current.next == null)        // if end of list,
            return null;                 // didn't find it
         else                            // not end of list,
            current = current.next;      // go to next link
         }
      return current;                    // found it
      }
// -------------------------------------------------------------
   public Link delete(int key)    // delete link with given key
      {                           // (assumes non-empty list)
      Link current = first;              // search for link
      Link previous = first;
      while(current.iData != key)
         {
         if(current.next == null)
            return null;                 // didn't find it
         else
            {
            previous = current;          // go to next link
            current = current.next;
            }
         }                               // found it
      if(current == first)               // if first link,
         first = first.next;             //    change first
      else                               // otherwise,
         previous.next = current.next;   //    bypass it
      return current;
      }
// -------------------------------------------------------------
   public void displayList()      // display the list
      {
      System.out.print("List (first-->last): ");
      Link current = first;       // start at beginning of list
      while(current != null)      // until end of list,
         {
         current.displayLink();   // print data
         current = current.next;  // move to next link
         }
      System.out.println("");
      }
// -------------------------------------------------------------
   }  // end class LinkList
////////////////////////////////////////////////////////////////
class LinkList2App
   {
   public static void main(String[] args)
      {
      LinkList theList = new LinkList();  // make list

      theList.insertFirst(22, 2.99);      // insert 4 items
      theList.insertFirst(44, 4.99);
      theList.insertFirst(66, 6.99);
      theList.insertFirst(88, 8.99);

      theList.displayList();              // display list

      Link f = theList.find(44);          // find item
      if( f != null)
         System.out.println("Found link with key " + f.iData);
      else
         System.out.println("Can't find link");

      Link d = theList.delete(66);        // delete item
      if( d != null )
         System.out.println("Deleted link with key " + d.iData);
      else
         System.out.println("Can't delete link");

      theList.displayList();              // display list
      }  // end main()
   }  // end class LinkList2App
////////////////////////////////////////////////////////////////

7.2 有序链表

// sortedList.java
// demonstrates sorted list
// to run this program: C>java SortedListApp
////////////////////////////////////////////////////////////////
class Link
   {
   public long dData;                  // data item
   public Link next;                   // next link in list
// -------------------------------------------------------------
   public Link(long dd)                // constructor
      { dData = dd; }
// -------------------------------------------------------------
   public void displayLink()           // display this link
      { System.out.print(dData + " "); }
   }  // end class Link
////////////////////////////////////////////////////////////////
class SortedList
   {
   private Link first;                 // ref to first item
// -------------------------------------------------------------
   public SortedList()                 // constructor
      { first = null; }
// -------------------------------------------------------------
   public boolean isEmpty()            // true if no links
      { return (first==null); }
// -------------------------------------------------------------
   public void insert(long key)        // insert, in order
      {
      Link newLink = new Link(key);    // make new link
      Link previous = null;            // start at first
      Link current = first;
                                       // until end of list,
      while(current != null && key > current.dData)
         {                             // or key > current,
         previous = current;
         current = current.next;       // go to next item
         }
      if(previous==null)               // at beginning of list
         first = newLink;              // first --> newLink
      else                             // not at beginning
         previous.next = newLink;      // old prev --> newLink
      newLink.next = current;          // newLink --> old currnt
      }  // end insert()
// -------------------------------------------------------------
   public Link remove()           // return & delete first link
      {                           // (assumes non-empty list)
      Link temp = first;               // save first
      first = first.next;              // delete first
      return temp;                     // return value
      }
// -------------------------------------------------------------
   public void displayList()
      {
      System.out.print("List (first-->last): ");
      Link current = first;       // start at beginning of list
      while(current != null)      // until end of list,
         {
         current.displayLink();   // print data
         current = current.next;  // move to next link
         }
      System.out.println("");
      }
   }  // end class SortedList
////////////////////////////////////////////////////////////////
class SortedListApp
   {
   public static void main(String[] args)
      {                            // create new list
      SortedList theSortedList = new SortedList();
      theSortedList.insert(20);    // insert 2 items
      theSortedList.insert(40);

      theSortedList.displayList(); // display list

      theSortedList.insert(10);    // insert 3 more items
      theSortedList.insert(30);
      theSortedList.insert(50);

      theSortedList.displayList(); // display list

      theSortedList.remove();      // remove an item

      theSortedList.displayList(); // display list
      }  // end main()
   }  // end class SortedListApp
////////////////////////////////////////////////////////////////

7.3 双向链表

// doublyLinked.java
// demonstrates doubly-linked list
// to run this program: C>java DoublyLinkedApp
////////////////////////////////////////////////////////////////
class Link
   {
   public long dData;                 // data item
   public Link next;                  // next link in list
   public Link previous;              // previous link in list
// -------------------------------------------------------------
   public Link(long d)                // constructor
      { dData = d; }
// -------------------------------------------------------------
   public void displayLink()          // display this link
      { System.out.print(dData + " "); }
// -------------------------------------------------------------
   }  // end class Link
////////////////////////////////////////////////////////////////
class DoublyLinkedList
   {
   private Link first;               // ref to first item
   private Link last;                // ref to last item
// -------------------------------------------------------------
   public DoublyLinkedList()         // constructor
      {
      first = null;                  // no items on list yet
      last = null;
      }
// -------------------------------------------------------------
   public boolean isEmpty()          // true if no links
      { return first==null; }
// -------------------------------------------------------------
   public void insertFirst(long dd)  // insert at front of list
      {
      Link newLink = new Link(dd);   // make new link

      if( isEmpty() )                // if empty list,
         last = newLink;             // newLink <-- last
      else
         first.previous = newLink;   // newLink <-- old first
      newLink.next = first;          // newLink --> old first
      first = newLink;               // first --> newLink
      }
// -------------------------------------------------------------
   public void insertLast(long dd)   // insert at end of list
      {
      Link newLink = new Link(dd);   // make new link
      if( isEmpty() )                // if empty list,
         first = newLink;            // first --> newLink
      else
         {
         last.next = newLink;        // old last --> newLink
         newLink.previous = last;    // old last <-- newLink
         }
      last = newLink;                // newLink <-- last
      }
// -------------------------------------------------------------
   public Link deleteFirst()         // delete first link
      {                              // (assumes non-empty list)
      Link temp = first;
      if(first.next == null)         // if only one item
         last = null;                // null <-- last
      else
         first.next.previous = null; // null <-- old next
      first = first.next;            // first --> old next
      return temp;
      }
// -------------------------------------------------------------
   public Link deleteLast()          // delete last link
      {                              // (assumes non-empty list)
      Link temp = last;
      if(first.next == null)         // if only one item
         first = null;               // first --> null
      else
         last.previous.next = null;  // old previous --> null
      last = last.previous;          // old previous <-- last
      return temp;
      }
// -------------------------------------------------------------
                                     // insert dd just after key
   public boolean insertAfter(long key, long dd)
      {                              // (assumes non-empty list)
      Link current = first;          // start at beginning
      while(current.dData != key)    // until match is found,
         {
         current = current.next;     // move to next link
         if(current == null)
            return false;            // didn't find it
         }
      Link newLink = new Link(dd);   // make new link

      if(current==last)              // if last link,
         {
         newLink.next = null;        // newLink --> null
         last = newLink;             // newLink <-- last
         }
      else                           // not last link,
         {
         newLink.next = current.next; // newLink --> old next
                                      // newLink <-- old next
         current.next.previous = newLink;
         }
      newLink.previous = current;    // old current <-- newLink
      current.next = newLink;        // old current --> newLink
      return true;                   // found it, did insertion
      }
// -------------------------------------------------------------
   public Link deleteKey(long key)   // delete item w/ given key
      {                              // (assumes non-empty list)
      Link current = first;          // start at beginning
      while(current.dData != key)    // until match is found,
         {
         current = current.next;     // move to next link
         if(current == null)
            return null;             // didn't find it
         }
      if(current==first)             // found it; first item?
         first = current.next;       // first --> old next
      else                           // not first
                                     // old previous --> old next
         current.previous.next = current.next;

      if(current==last)              // last item?
         last = current.previous;    // old previous <-- last
      else                           // not last
                                     // old previous <-- old next
         current.next.previous = current.previous;
      return current;                // return value
      }
// -------------------------------------------------------------
   public void displayForward()
      {
      System.out.print("List (first-->last): ");
      Link current = first;          // start at beginning
      while(current != null)         // until end of list,
         {
         current.displayLink();      // display data
         current = current.next;     // move to next link
         }
      System.out.println("");
      }
// -------------------------------------------------------------
   public void displayBackward()
      {
      System.out.print("List (last-->first): ");
      Link current = last;           // start at end
      while(current != null)         // until start of list,
         {
         current.displayLink();      // display data
         current = current.previous; // move to previous link
         }
      System.out.println("");
      }
// -------------------------------------------------------------
   }  // end class DoublyLinkedList
////////////////////////////////////////////////////////////////
class DoublyLinkedApp
   {
   public static void main(String[] args)
      {                             // make a new list
      DoublyLinkedList theList = new DoublyLinkedList();

      theList.insertFirst(22);      // insert at front
      theList.insertFirst(44);
      theList.insertFirst(66);

      theList.insertLast(11);       // insert at rear
      theList.insertLast(33);
      theList.insertLast(55);

      theList.displayForward();     // display list forward
      theList.displayBackward();    // display list backward

      theList.deleteFirst();        // delete first item
      theList.deleteLast();         // delete last item
      theList.deleteKey(11);        // delete item with key 11

      theList.displayForward();     // display list forward

      theList.insertAfter(22, 77);  // insert 77 after 22
      theList.insertAfter(33, 88);  // insert 88 after 33

      theList.displayForward();     // display list forward
      }  // end main()
   }  // end class DoublyLinkedApp
////////////////////////////////////////////////////////////////

数据结构与算法

数据结构（java）——单链表、双端链表和双向链表
likunkun__的博客
04-17 1997
单链表    链表大家都很熟悉，链表是由若干个节点串起来的一个结构。类似于火车一样，拥有一个头结点（火车头）之后挂着一个个的节点，每个节点后面跟上另一个节点。每个节点分为两个域，一个数据域，用来存放这个节点的数据，一个是节点域，用来存放下一个节点。    所以对于单链表，用java实现我们首先创建节点类。Node类：//联结点，相当于是车厢 public class Node { //数据域 ...
图解数据结构：数组和单链表
Sicimike的博客
10-17 3463
前言 数据结构始终是计算机科学绕不开的话题，是计算机中存储、组织数据的方式。学习数据结构能让我们明白，如何更高效的存、取数据。编写程序的目的就是为了处理数据，处理数据本质上就是存、取、运算。 本篇从最简单的数据结构入手，讲解数组和链表。主要讲解他们的特点、存储结构、区别、各种场景下的效率等问题。更具体一点，就是从本质上讲解了ArrayList和LinkedList的区别。 数组 在计算机科学中，...
Java两种基本的数据结构：数组和链表
ShareUs的专栏
11-28 9647
-- Java两种基本的数据结构：数组和链表。 Java底层机制,JVM机制 - http://www.jianshu.com/p/ae97b692614e# Java数组（初学者必看）- http://www.importnew.com/7127.html     数组无论在哪种编程语言中都算是最重要的数据结构之一，同时不同语言的实现及处理也不尽相同。但凡写过一些程序的人都知道数组的价值及理解数...
数据结构java（一）数组链表
weixin_30673715的博客
02-12 160
链表是数据结构中最基础的内容，链表在存储结构上分成两种：数组形式储存，链式存储。 相比c语言需要的结构体，在java中由于有了面向对象编程，将指针‘藏’了起来，不需要分配内存。 所以只需要创建一个对象数组，为了能让链表更加实用，方便存储非基本类型的对象，所以使用了泛型。 菱形运算符<>中放你自己写的或者基本类型，比如你创建了一个Stdent类，想用链表将很多学生的信息存起来。 ...
数据结构--java实现单链表与双链表
mingshengda的博客
09-09 377
【代码】数据结构--java实现单链表与双链表。
Java数据结构和算法——数组、单向链表、双向链表
Dream It Possible
06-21 3677
概要线性表是一种线性结构，它是具有相同类型的n(n≥0)个数据元素组成的有限序列。本文先介绍线性表的几个基本组成部分：数组、单向链表（One-way LinkedList）、双向链表（two-way linked-list ）。数组数组有上界和下界，数组的元素在上下界内是连续的。存储10、20、30、40、50的数组的示意图如下：数组的特点： 1. 数据是连续的； 2. 随机访问速度快。数组中稍
数据结构与算法：数组与链表的实现与应用
常见的数据结构包括数组、链表、栈、队列、树等。不同的数据结构适用于不同的场景，能够提高数据操作的效率和减少内存资源的消耗。 ## 1.2 算法的基本原理和应用 算法是解决特定问题或执行特定任务的一系列步骤。在...
Java数据结构期末应用：数组、链表、树等核心考点解读（专家级教程）
![Java数据结构期末应用：数组、链表、树等核心考点解读（专家级教程）]... # 摘要 本文全面探讨了数据结构及其在Java语言中的实现，深入分析了数组、链表、树结构等基础数据结构的内部机制、操作方法和性能特征。...
java数据结构与算法.pdf
01-04
Java作为广泛应用的编程语言，其在实现数据结构和算法时有着丰富的库支持和优秀的可读性。下面将对标题和描述中提到的一些关键知识点进行详细解释。 1. **数据结构**： - **稀疏数组**：当大量数据中大部分为零或...
Java数据结构和算法中文第二版_Java数据结构_
10-04
《Java数据结构和算法中文第二版》是一本深入探讨Java编程中数据结构和算法的书籍。数据结构是计算机科学的基础，它涉及到如何有效地组织和存储数据，以便在各种操作下高效地访问和修改。算法则是解决问题的具体步骤...
java 单链表和双向链表的实现
08-06
操作包括： 1. 在头部添加结点 2. 在尾部添加结点 3. 遍历 4. 逆置 5. 删除
Java 单链表 双链表
qq_45858803的博客
11-27 299
java 单链表和双_Java-链表，单链表和双链表
weixin_33137081的博客
02-16 163
Java-链表1、什么是链表？2、链表的特点是什么？3、链表的实现原理？4、如何自己写出一个链表？1、什么是链表？链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针连接次序实现的。每一个链表都包含多个节点，节点又包含两个部分，一个是数据域(储存节点含有的信息)，一个是引用域(储存下一个节点或者上一个节点的地址)。链表的理解示意图2、链表的特点是什么？获取数据麻烦...
数据结构——单链表与双链表（java实现）
最新发布
2301_77993957的博客
07-15 1480
链表是线性表的一种，在物理存储结构上不一定连续（绝大多数情况下非连续），在数据逻辑顺序上，将节点用指针链接起来实现连续。链表是由一个一个的节点组成节点：节点中分为数据域与指针域，数据域用于存放数据，指针域用于存放下一个节点的引用地址。
java实现单链表和双链表数据结构
qq_44911340的博客
10-09 268
首先定义一个接口, 规范单链表和双链表常用的基本操作: /** * @Author Huzz * @Created 2021-10-09 17:49 */ public interface LinkedList<T> { /** * 节点长度 * @return */ int size(); /** * 返回链表是否为空 * @return 空:true | 非空:false */ boole
数组&链表【Java算法（二）】
qq_56402474的博客
03-31 714
数据结构（Java版） 包含了数组&链表，可以放心食用！
Java实现单向链表基本功能
weixin_33816821的博客
03-28 198
一、前言 最近在回顾数据结构与算法，有部分的算法题用到了栈的思想，说起栈又不得不说链表了。数组和链表都是线性存储结构的基础，栈和队列都是线性存储结构的应用～ 本文主要讲解单链表的基础知识点，做一个简单的入门～如果有错的地方请指正 二、回顾与知新 说起链表，我们先提一下数组吧，跟数组比较一下就很理解链表这种存储结构了。 2.1回顾数组 数组我们无论是C、Java都会学过： 数组是一种连续存储线性结...
Java实现单向链表
3y
03-28 602
一、前言最近在回顾数据结构与算法，有部分的算法题用到了栈的思想，说起栈又不得不说链表了。数组和链表都是线性存储结构的基础，栈和队列都是线性存储结构的应用～本文主要讲解单链...
从1开始学Java数据结构与算法——单链表与双链表
weixin_43851232的博客
01-13 497
从1开始学Java数据结构与算法——单链表的使用单链表的特点单链表的代码思路分析方法详细思路分析单链表的代码实现小问题： 单链表的特点 1.链表是以节点的方式存储的 2.每个节点包含data域，用来存放数据；和next域，用来指向下一个节点 3.链表的各个节点不一定是连续存储 4.链表分为带头节点的和不带头节点的 5.单链表在内存中的布局如下图 单链表的代码思路分析 1.先创建一个节点类，用于表...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值