单链表与双链表

单链表

• 结构:
  head|next->node1|next->…->noden|next->null
• 首先创建单链表要先声明好节点的数据参数和指向下一个数据节点的参数，
  然后初始化头节点。
• 单链表在末尾添加数据时需要从头节点开始遍历知道节点指向null，然后将最后一个节点指向要添加的数据然后让要添加的数据的next节点指向null
  head|next->node1|next->…->noden|next-> 　　　　　　　null;
  　　　　　　　　　　　　　　　　　　　　 ^->new|next->
• 删除操作需要遍历到要删除的节点的前一个节点然后让这个节点指向下下个节点的数据即可
  head|next->node1|next-　　node2|next->　　　node3|next->…->noden|next->null;
  　　　　　　　　　　　　 ^ –　-　-> 　 ^
• 插入操作需要遍历到要插入的节点的位置然后让要插入的数据指向下一个节点，然后让要前面的节点指向要插入的节点。
  head|next->node1|next-　node2|next->　　　　　　　　　　　node3|next->…->noden|next->null;
  　　　　　　　　　　　　　　　　　　　　　 ^->new|next->
• 替换操作是删除和插入的结合

双向链表

• 结构：
  null<-previous|head|next->previous|node|next->. . . . . . . ->previous|noden|next->null
  　　　　　　　　^<　- - - 　-| 　　　　　　　　　　 ^<-- - --|
• 与单链表相同都要先定义头结点，但它比单链表要多定义一个previous前驱指向前一个数据
• 双向链表在添加替换删除时不仅需要将next指向后一个数据还需要要将前驱指向前一个数据。

---

单链表的代码：

包Link：

• Node.java

package Link;

public class Node {
    int data;
    Node next;

}

• Link.java

package Link;

import java.sql.SQLOutput;

public class Link {//初始化头结点
    private Node head;
    public void create(int data){
        Node node=new Node();
        node.data=data;
        node.next=null;
        head=node;
    }
    public int gethead(){

        return this.head.data;
    }
    public void add(int m){
        Node n=new Node();
        Node c;
        n.data=m;
        c=head;
        while (c.next!=null){
            c=c.next;
        }
        n.next=null;
        c.next=n;
    }
    public int getsize(){
        int size=0;
        Node m;
        m=head;
        while (m!=null){
            m=m.next;
            size++;
        }
        return size;
    }
    public void delete(int i){
        Node n;
        n=head;
        if(i<this.getsize()) {
            for (int j = 1; j < i - 1; j++) {
                n = n.next;
            }
            n.next=n.next.next;
        }
        if(i==this.getsize()){
            n.next=null;
        }
        else {
            System.out.println("超出范围");
        }
    }
    public void list(){
        Node l;
        l=head;
        System.out.print("链表: ");
        for(int i=1;i<=this.getsize();i++){
            System.out.print(l.data+" ");
            l=l.next;
        }
        System.out.println();
    }
    public void insert(int i,int m){
        Node t=new Node();
        t.data=m;
        Node s;
        s=head;
        if(i<this.getsize()) {
            for (int j = 1; j < i; j++) {
                s = s.next;
            }
            t.next = s.next;
            s.next = t;
        }
        if(i==this.getsize()){
            for (int j = 1; j < i; j++) {
                s = s.next;
            }
            s.next=t;
            t.next=null;
        }
        else {
            System.out.println("超出范围");
        }
    }
    public void replace(int i,int r){
        Node t=new Node();
        t.data=r;
        Node s;
        s=head;
        if(i<this.getsize()) {
            for (int j = 1; j < i-1; j++) {
                s=s.next;
            }
            t.next=s.next.next;
            s.next=t;
        }
        if(i==this.getsize()){
            for (int j = 1; j < i-1; j++) {
                s=s.next;
            }
            s.next=null;
        }
        else {
            System.out.println("超出范围");
        }
    }
}

• Test.java

package Link;

import com.sun.org.apache.bcel.internal.generic.LNEG;

public class Test {
    public static void main(String[] args) {
        Link link=new Link();
        link.create(1);
        int m=0;
        int n=link.gethead();
        System.out.println("头结点为:"+n);
        link.add(2);
        link.add(3);
        link.add(4);
        link.add(5);
        m=link.getsize();
        System.out.println("链表长度为:"+m);
        link.delete(3);
        System.out.println("删除第三个节点");
        link.list();
        m=link.getsize();
        System.out.println("链表长度为:"+m);
        link.add(6);
        link.add(7);
        link.delete(5);
        System.out.println("先在末尾添加6和7，然后删除第五个节点");
        link.list();
        link.insert(2,10);
        System.out.println("在第二个节点后插入10");
        link.list();
        link.replace(3,2);
        System.out.println("替换第三个节点为2");
        link.list();
    }
}

测试运行结果：
头结点为:1
链表长度为:5
超出范围
删除第三个节点
链表: 1 2 4 5
链表长度为:4
先在末尾添加6和7，然后删除第五个节点
链表: 1 2 4 5
超出范围
在第二个节点后插入10
链表: 1 2 10 4 5
超出范围
替换第三个节点为2
链表: 1 2 2 4 5

双向链表的代码：

包Link：

• DoubleLink.java

package DoubleLink;

public class Node {
    Node next;
    Node previous;
    int data;
}

• Node.java

package DoubleLink;

public class DoubleLink {
    private Node head;
    public void create(int data,int data1){
        Node node=new Node();
        node.data=data;
        node.next=null;
        node.previous=null;
        head=node;
    }
    public int gethead(){

        return this.head.data;
    }
    public int getsize(){
        Node t;
        t=head;
        int size=0;
        while (t!=null){
            t=t.next;
            size++;
        }
        return size;
    }
    public void add(int a){
        Node t=new Node();
        Node s;
        t.data=a;
        s=head;
        while (s.next!=null){
            s=s.next;
        }
        t.next=null;
        t.previous=s;
        s.next=t;

    }
    public void list(){
        Node s;
        s=head;
        System.out.print("链表: ");
        for(int i=1;i<=this.getsize();i++){
            System.out.print(s.data+" ");
            s=s.next;
        }
        System.out.println();
    }
    public void insert(int i,int data){
        Node in=new Node();
        Node s;
        in.data=data;
        s=head;
        if(i<=this.getsize()) {
            for (int j = 1; j <i; j++) {
               s=s.next;
            }
            in.next=s.next;
            s.next.previous=in;
            s.next=in;
            in.previous=s;
        }else {
            System.out.println("超出范围");
        }
    }
    public void delete(int i){
        Node n;
        n=head;
        if(i<this.getsize()) {
            for (int j = 1; j < i - 1; j++) {
                n = n.next;
            }
            n.next=n.next.next;
            n.next.next.previous=n;
        }else {
            System.out.println("超出范围");
        }
    }
    public void replace(int i,int r){
        Node t=new Node();
        t.data=r;
        Node s;
        s=head;
        if(i<=this.getsize()) {
            for (int j = 1; j < i-1; j++) {
                s=s.next;
            }
            t.next=s.next.next;
            t.previous=s;
            s.next=t;
        }else {
            System.out.println("超出范围");
        }
    }
}

• test0.java

package DoubleLink;

public class DoubleLink {
    private Node head;
    public void create(int data,int data1){
        Node node=new Node();
        node.data=data;
        node.next=null;
        node.previous=null;
        head=node;
    }
    public int gethead(){

        return this.head.data;
    }
    public int getsize(){
        Node t;
        t=head;
        int size=0;
        while (t!=null){
            t=t.next;
            size++;
        }
        return size;
    }
    public void add(int a){
        Node t=new Node();
        Node s;
        t.data=a;
        s=head;
        while (s.next!=null){
            s=s.next;
        }
        t.next=null;
        t.previous=s;
        s.next=t;

    }
    public void list(){
        Node s;
        s=head;
        System.out.print("链表: ");
        for(int i=1;i<=this.getsize();i++){
            System.out.print(s.data+" ");
            s=s.next;
        }
        System.out.println();
    }
    public void insert(int i,int data){
        Node in=new Node();
        Node s;
        in.data=data;
        s=head;
        if(i<=this.getsize()) {
            for (int j = 1; j <i; j++) {
               s=s.next;
            }
            in.next=s.next;
            s.next.previous=in;
            s.next=in;
            in.previous=s;
        }else {
            System.out.println("超出范围");
        }
    }
    public void delete(int i){
        Node n;
        n=head;
        if(i<this.getsize()) {
            for (int j = 1; j < i - 1; j++) {
                n = n.next;
            }
            n.next=n.next.next;
            n.next.next.previous=n;
        }else {
            System.out.println("超出范围");
        }
    }
    public void replace(int i,int r){
        Node t=new Node();
        t.data=r;
        Node s;
        s=head;
        if(i<=this.getsize()) {
            for (int j = 1; j < i-1; j++) {
                s=s.next;
            }
            t.next=s.next.next;
            t.previous=s;
            s.next=t;
        }else {
            System.out.println("超出范围");
        }
    }
}

运行结果：
头结点为:1
链表的size:4
链表: 1 3 4 5
在第三个位置添加7
链表: 1 3 4 7 5
删除第三个位置
链表: 1 3 7 5
替换第二个位置为8
链表: 1 8 7 5