链表基础知识

1.创建链表

Java创建链表

public class ListNode {
    public int val;
    public ListNode next;
    
    ListNode(int x){
        val = x;
        next = null; //更加规范
    }
}

ListNode listNode = new ListNode(1);

python创建链表

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next
    listNode = ListNode(1)

2.链表的增删改查

2.1 遍历链表

Java遍历链表

public static int getListLength(ListNode head){
    int length = 0;
    ListNode cur = head;
    while (cur != null){
        length ++;
        cur = cur.next;
    }
    return length;
}

Python遍历链表

def length(self):
    cur = self._head
    count = 0
    while cur != None:
        count += 1
        cur =cur.next
    return count

2.2 链表插入

考虑三种情况：

1. 在链表头部插入
2. 在链表中间插入
3. 在链表尾部插入

特殊考虑情况：1.输入节点为空、2.插入位置越界

Java实现链表插入

    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;
    }

python实现链表插入

    #此方法调用了其它方法，只作为思路参考，勿直接复用
    def insert(self, pos, item):
        """指定位置添加元素"""
        # 若指定位置pos为第一个元素之前，则执行头部插入
        if pos <= 0:
            self.add(item)
        # 若指定位置超过链表尾部，则执行尾部插入
        elif pos > (self.length() - 1):
            self.append(item)
        # 找到指定位置
        else:
            node = Node(item)
            count = 0
            # pre用来指向指定位置pos的前一个位置pos-1，初始从头节点开始移动到指定位置
            pre = self._head
            while count < (pos - 1):
                count += 1
                pre = pre.next
            # 先将新节点node的next指向插入位置的节点
            node.next = pre.next
            # 将插入位置的前一个节点的next指向新节点
            pre.next = node

2.3 链表删除

考虑三种情况：

1. 在链表头部删除
2. 在链表中间删除
3. 在链表尾部删除

Java实现链表删除

    public static Node deleteNode(Node head, int position) {
        if (head == null) {
            return null;
        }
        int size = getLength(head);
        //思考一下，这里为什么是size，而不是size+1-->因为此处是删除元素
        if (position > size || position <1) {
            System.out.println("输入的参数有误");
            return head;
        }
        if (position == 1) {
            //curNode就是链表的新head
            return head.next;
        } else {
            Node cur = head;
            int count = 1;
            // 找到删除位置的前一个元素
            while (count < position - 1) {
                cur = cur.next;
                count++;
            }
            Node curNode = cur.next;
            cur.next = curNode.next;
        }
        return head;
    }

Python实现链表删除

    def remove(self, item):
        """删除节点"""
        cur = self._head
        pre = None
        while cur != None:
            # 找到了指定元素
            if cur.item == item:
                # 如果第一个就是删除的节点
                if not pre:
                    # 将头指针指向头节点的后一个节点
                    self._head = cur.next
                else:
                    # 将删除位置前一个节点的next指向删除位置的后一个节点
                    pre.next = cur.next
                break
            else:
                # 继续按链表后移节点
                pre = cur
                cur = cur.next