JAVA数据结构与算法-单链表(4)

一、思路及代码实现

/*
单链表的增删改查
*/
public class Emp
{

    int id;
    String name;
    Emp next = null;

    public Emp(){

    }

    public Emp(int id, String name) {
        this.id = id;
        this.name = name;
    }
}
public class EmpLinkedList
{

    Emp head = null;

    public void add(Emp node) {
        //链空的情况
        if (head == null) {
            head = node;
            return;
        }

        //添加节点位于头结点之前
        if (head.id >= node.id) {
            node.next = head;
            head = node;
            return;
        }

        //临时节点指向头结点，找到要插入位置的前一个位置
        Emp tmp = head;
        while (tmp.next != null && tmp.next.id < node.id) {
            tmp = tmp.next;
        }

        //插入位置在链尾
        if (tmp.next == null) {
            tmp.next = node;
            return;
        }

        //插入节点已存在
        if (tmp.next.id == node.id) {
            System.out.println("节点'" + node.id + "'存在");
            return;
        }

        //插入位置在链中
        Emp tmpNode = tmp.next;
        tmp.next = node;
        node.next = tmpNode;
    }

    public Emp get(int k) {
        if (isEmpty()){
            System.out.println("链空");
            return null;
        }
        Emp tmp = head;
        while (tmp != null && tmp.id < k) {
            tmp = tmp.next;
        }

        if (tmp != null && tmp.id == k) {
            return tmp;
        }
        else {
            return null;
        }
    }

    public void del(int k){
        if (isEmpty()){
            System.out.println("链空");
            return;
        }
        
        Emp tmp = head;
        while (tmp.next != null && tmp.next.id < k) {
            tmp = tmp.next;
        }

        //要删除节点为头结点
        if (tmp == head && tmp.id == k){
            head = head.next;
            return;
        }

        if (tmp.next != null && tmp.next.id == k){
            tmp.next = tmp.next.next;
            return;
        }
        
        System.out.println("节点'" + k + "'不存在");
    }

    public void edit(int k, String value){
        Emp emp = get(k);
        if (emp != null){
            emp.name = value;
        }
    }

    public void traverse() {
        if (isEmpty()) {
            System.out.println("空链");
            return;
        }
        Emp tmp = head;
        while (tmp != null) {
            System.out.println(tmp.id + ":" + tmp.name);
            tmp = tmp.next;
        }
        System.out.println("==============================");
    }

    public boolean isEmpty() {
        return head == null;
    }

}

二、相关试题

1）反转单链表

// 单链表的反转

    /**
     * 遍历单链表，
     * 将每一个节点，剔除后，放在新链表的第一个
     * 最后将原链表的头节点指向新链表的第一个节点
     */
    public void reverse(){
        SingleLinkedList newLinkedList = new SingleLinkedList();
        Node tmp = headNode;
        while (tmp != null){
        	//将tmp移除
            headNode = tmp.next;
            //添加到新链表
            newLinkedList.reverseAdd(tmp);
            //指向下一个节点
            tmp = headNode;
        }
        //将新链表返回给旧链表
        headNode = newLinkedList.headNode;
    }

    public void reverseAdd(Node node){
        // 第一次加入时，头结点为空
        if (headNode == null){
            node.next = null;
            headNode = node;
            return;
        }
        // 将剔除的节点放入链表头
        node.next = headNode;
        headNode = node;
    }

2）后序遍历单链表

/*
 后序遍历单链表 1、反转后打印× 2、栈√
*/
public void postTraverse() {
  if (headNode == null) {
      System.out.println("none");
      return;
  }
  Node tmp = headNode;
  Stack<Node> nodeStack = new Stack<>();
  while (tmp != null) {
      nodeStack.push(tmp);
      tmp = tmp.next;
  }
  while (true) {
      try {
          System.out.println(nodeStack.pop());
      }
      catch (Exception e) {
          break;
      }
  }
}

3）合并两个有序链表

/**
 * 合并两个有序链表 同时遍历两链表，将较小的节点放入新链表，若其中一链表到链尾则另一链表直接加入新链表尾
 * 
 * @param list1
 * @param list2
 * @return
 */
public static SingleLinkedList mergeTowSortedLinkedList(SingleLinkedList list1, SingleLinkedList list2) {
    SingleLinkedList newList = new SingleLinkedList();
    // 存在空链表的情况
    if (list1.headNode == null) {
        newList.headNode = list2.headNode;
        return newList;
    }
    if (list2.headNode == null) {
        newList.headNode = list1.headNode;
        return newList;
    }

    // 这时两链表都不为空
    Node tmp1 = list1.headNode;
    Node tmp2 = list2.headNode;
    // 遍历比较两链表
    while (tmp1 != null && tmp2 != null) {
        // 这里需要改变头结点的原因，与反转一致，需要将节点剔除并不丢失下一个节点
        if (tmp1.rank < tmp2.rank) {
            list1.headNode = tmp1.next;
            tmp1.next = null;
            newList.add(tmp1);
            tmp1 = list1.headNode;
            continue;
        }
        if (tmp1.rank > tmp2.rank) {
            list2.headNode = tmp2.next;
            tmp2.next = null;
            newList.add(tmp2);
            tmp2 = list2.headNode;
            continue;
        }
        // 当前两节点值相同
        list1.headNode = tmp1.next;
        tmp1.next = null;
        newList.add(tmp1);
        tmp1 = list1.headNode;
        list2.headNode = tmp2.next;
        tmp2.next = null;
        newList.add(tmp2);
        tmp2 = list2.headNode;
    }

    // 两链表都遍历完
    if (tmp1 == null && tmp2 == null) {
        return newList;
    }

    // 第一个链表遍历完
    if (tmp1 == null) {
        Node tmp = list2.headNode;
        while (tmp != null) {
            newList.add(tmp);
            tmp = tmp.next;
        }
    }

    // 第二个链表遍历完
    if (tmp2 == null) {
        Node tmp = list1.headNode;
        while (tmp != null) {
            newList.add(tmp);
            tmp = tmp.next;
        }
    }

    return newList;
}