编程导航算法通关村第1关|链表的基础与构造方法

编程导航算法通关村第1关|链表的基础与构造方法

单链表

头结点中数据data可以为null也可以存储数据

data保存数据，next指向下一个结点

内部结构

static class Node {
    final int data;
    Node next;
    public Node(int data) {
        this.data = data;
    }
}

插入节点

• 头插
  

• 中间插入
  

  /**
       * 链表插入
       *
       * @param head       链表头节点
       * @param nodeInsert 待插入节点
       * @param position   待插入位置，取值从2开始
       * @return 插入后得到的链表头节点
       */
  public static Node insertNode(Node head, Node nodeInsert, int position) {
      // 需要判空，否则后面可能会有空指针异常
      if (head == null) {
          return nodeInsert;
      }
      //越界判断
      int size = getLength(head);
      if (position > size + 1 || position < 1) {
          System.out.println("位置参数越界");
          return head;
      }
  
      //在链表开头插入
      if (position == 1) {
          nodeInsert.next = head;
          //            return nodeInsert;
          //上面return还可以这么写：
          head = nodeInsert;
          return head;
      }
  
      Node pNode = head;
      int count = 1;
      while (count < position - 1) { //遍历找到要插入的前一个节点
          pNode = pNode.next;
          count++;
      }
      nodeInsert.next = pNode.next;
      pNode.next = nodeInsert;
  
      return head;
  }
  

删除节点

• /**
       * 删除节点
       *
       * @param head     链表头节点
       * @param position 删除节点位置，取值从1开始
       * @return 删除后的链表头节点
       */
  public static Node deleteNode(Node head, int position) {
      if (head == null) {
          return null;
      }
      int size = getLength(head);
      if (position > size || position <= 0) {
          System.out.println("输入的参数有误");
          return head;
      }
  
      if (position == 1) {
          // head.next就是链表的新head
          return head.next;
      }
      Node preNode = head;
      int count = 1;
      while (count < position) {
          preNode = preNode.next;
          count++;
          Node curNode = preNode.next;
          preNode.next = curNode.next;
      }
      return head;
  }
  

遍历链表

/**
     * 输出链表
     *
     * @param head 头节点
     */
public static String toString(Node head) {
    Node current = head;
    StringBuilder sb = new StringBuilder();
    while (current != null) {
        sb.append(current.data).append("\t");
        current = current.next;
    }
    return sb.toString();
}

双向链表

内部结构

/**
     * 创建双向链表结点
     */
class DoubleNode {
    public int data;    //数据域
    public DoubleNode next;    //指向下一个结点
    public DoubleNode prev;    //指向前一个结点

    public DoubleNode(int data) {
        this.data = data;
    }

    //打印结点的数据域
    public void displayNode() {
        System.out.print("{" + data + "} ");
    }
}

插入

• 头插
  

  • //头部插入
    public void insertFirst(int data) {
        DoubleNode newDoubleNode = new DoubleNode(data);
        if (isEmpty()) {
            last = newDoubleNode;
        } else {//如果不是第一个结点的情况
            first.prev = newDoubleNode;    //将还没插入新结点之前链表的第一个结点的previous指向newNode
        }
        newDoubleNode.next = first;        //将新结点的next指向first
        first = newDoubleNode;            //将新结点赋给first（链接）成为第一个结点
    }
    //检查链表是否为空
    public boolean isEmpty() {
        return (first == null);
    }
    

• 尾插
  

  • //尾部插入
    public void insertLast(int data) {
        DoubleNode newDoubleNode = new DoubleNode(data);
        if (isEmpty()) {
            first = newDoubleNode;        //若链表为空，则将first指向新的结点（newNode）
        } else {
            newDoubleNode.prev = last;//将last的previous指向last（last永远指向的是最后一个结点）【此时还没有插入新的结点newNode，所以last指向的是当前链表的最后一个结点】
            last.next = newDoubleNode;    //将last.next(当前链表最后一个结点的next域)指向新的结点newNode
        }
        last = newDoubleNode;                //由于插入了一个新的结点，又因为是尾部插入，所以将last指向newNode
    }
    

• 中间插入
  

  • //某个结点的后部插入
    public void insertAfter(int key, int data) {
        DoubleNode newDoubleNode = new DoubleNode(data);
        DoubleNode current = first;
        while ((current != null) && (current.data != key)) {
            current = current.next;
        }
        //若当前结点current为空
        if (current == null) {                    //current为null有两种情况 一种是链表为空，一种是找不到key值
            if (isEmpty()) {                    //1、链表为空
                first = newDoubleNode;                //则插入第一个结点（其实可以调用其它的Insert方法）
                last = newDoubleNode;                    //first和last均指向该结点（第一个结点）
            } else {
                last.next = newDoubleNode;        //2、找不到key值
                newDoubleNode.prev = last;    //则在链表尾部插入一个新的结点
                last = newDoubleNode;
            }
        } else {
            if (current == last) {                    //第三种情况，找到了key值，分两种情况
                newDoubleNode.next = null;            //1、key值与最后结点的data相等
                last = newDoubleNode;                    //由于newNode将是最后一个结点，则将last指向newNode
            } else {       							  //2、两结点中间插入   
                newDoubleNode.next = current.next;      //将current当前结点的下一个结点赋给newNode.next       
                current.next.prev = newDoubleNode;  	//将current下一个结点即current.next的previous域指向current
            }                                      
            current.next = newDoubleNode;                    //将当前结点的next域指向newNode
            newDoubleNode.prev = current;                //将新结点的previous域指向current（current在newNode前面一个位置）
    
        }
    
    }
    

删除节点

同理

//从头部删除结点
public DoubleNode deleteFirst() {
    DoubleNode temp = first;
    if (first.next == null) {            //若链表只有一个结点，删除后链表为空，将last指向null
        last = null;
    } else {
        first.next.prev = null;        //若链表有两个（包括两个）以上的结点 ，因为是头部插入，则first.next将变成第一个结点，其previous将变成null
    }
    first = first.next;                //将first.next赋给first
    return temp;                    //返回删除的结点
}

//从尾部删除结点
public DoubleNode deleteLast() {
    DoubleNode temp = last;
    if (first.next == null) {        //如果链表只有一个结点，则删除以后为空表,last指向null
        first = null;
    } else {
        last.prev.next = null;    //将上一个结点的next域指向null
    }
    last = last.prev;            //上一个结点称为最后一个结点，last指向它
    return temp;                    //返回删除的结点
}

//按值删除
public DoubleNode deleteKey(int key) {
    DoubleNode current = first;
    while (current != null && current.data != key) {        //遍历链表寻找该值所在的结点
        current = current.next;
    }
    if (current == null) {                        //若当前结点指向null则返回null，
        return null;                        //两种情况当前结点指向null，一是该链表为空链表，而是找不到该值
    } else {
        if (current == first) {                //如果current是第一个结点
            first = current.next;            //则将first指向它，将该结点的previous指向null,其余不变
            current.next.prev = null;
        } else if (current == last) {            //如果current是最后一个结点
            last = current.prev;        //将last指向当前结点的上一个结点（我们将当前结点除名了以后它便不再是最后一个了）
            current.prev.next = null;    //相应的要删除结点的上一个结点的next域应指向null
        } else {
            current.prev.next = current.next;        //当前结点的上一个结点的next域应指向当前的下一个结点
            current.next.prev = current.prev;    //当前结点的下一个结点的previous域应指向当前结点的上一个结点
        }
    }
    return current;        //返回
}