List链表(Basic)

  1 //如果数据结构都还没搞明白,就先别刷力扣.先敲一下基本数据结构  2 
/**
 * @Auther: Caojc
 * @Date: 2022/3/17 - 03 - 17 - 19:50
 * @Description: 链表,画出来就很简单.注意考虑边界条件
 * @version: 1.0
 */
public class createListNode {
    //自定义链表
    static class ListNode{
        int val;
        ListNode next;

        public ListNode() {
        }

        public ListNode(int val) {
            this.val = val;
        }

        public ListNode(int val, ListNode next) {
            this.val = val;
            this.next = next;
        }
    }
    //根据数组创建链表
    public static ListNode createList(int[] array){
        ListNode head=null;
        ListNode pre=null;
        ListNode curr=null;
        for (int i = 0; i <array.length-1 ; i++) {
            curr=new ListNode(array[i]);
            if(i==0){
                head=curr;
            }else{
                pre.next=curr;
            }
            pre=curr;
        }
        return head;
    }
    //打印链表
    public static void printList(ListNode head){
        while(head!=null){
            System.out.print(head.val+"->");
            head=head.next;
        }
        System.out.println("null");
    }
    //按照节点值删除链表
    public static ListNode deleteList(ListNode head,int val){
        if(head.val==val) return head.next;
        ListNode curr=head;
        while(curr!=null&&curr.val!=val){
            curr=curr.next;
        }
        curr.next=curr.next.next;
        return head;

    }
    //获取链表长度
    public static int getListLength(ListNode head){
        int len=0;
        while(head!=null){
            head=head.next;
            len++;
        }
        return len;
    }
    //删除第index个节点
    public static ListNode indexDeleteList(ListNode head,int index){
        ListNode curr=head;
        int len=getListLength(head);
        try {
            if (index<0||index > len) throw new IndexOutOfBoundsException();
            if(index==1) return head.next;
            while(index-2>0){
                curr=curr.next;
                index--;
            }
            curr.next=curr.next.next;
        }catch (IndexOutOfBoundsException e){
            System.out.println("超出链表长度");
            e.printStackTrace();
        }
        return head;
    }
    //删除链表倒数第index个节点
    public static ListNode reverseIndexDeleteListNode(ListNode head,int index){
        ListNode curr=head;
        int len=getListLength(head);
        try {
            if (index<0||index > len) throw new IndexOutOfBoundsException();
            if(index==len) return head.next;
            //找到正数len-index个节点前一个节点
            for (int i = 0; i <len-index-1 ; i++) {
                curr=curr.next;
            }
            curr.next=curr.next.next;
        }catch (IndexOutOfBoundsException e){
            System.out.println("超出链表长度");
            e.printStackTrace();
        }
        return head;

    }
    //反转链表
    public static ListNode reverseList(ListNode head){
        ListNode pre=null;
        ListNode curr=head;
        while(curr!=null){
            ListNode next=curr.next;
            curr.next=pre;
            pre=curr;
            curr=next;
        }
        return pre;
    }
    //反转L位置和R位置之间的链表
    public static ListNode reversePartList(ListNode head,int L,int R){
        ListNode dummyNode=new ListNode(0,head);
        ListNode LNode=null;
        ListNode RNode=null;
        ListNode begin=null;
        ListNode end=null;
        ListNode start=dummyNode;
        try {
            if (L > R || R < 0 || L > getListLength(head)) throw new RuntimeException("起始位置异常");
            for (int i = 0; i < L - 1; i++) {
                start = start.next;
            }
            begin = start;
            LNode = begin.next;
            for (int i = 0; i < R - L + 1; i++) {
                start = start.next;
            }
            RNode = start;
            end = RNode.next;
            begin.next=null;
            RNode.next=null;
            reverseList(head);
            begin.next = RNode;
            LNode.next=end;
        } catch (RuntimeException e) {
            e.printStackTrace();
        }

        return dummyNode.next;
    }
    //主函数测试
    public static void main(String[] args) {
        int[] array={3,4,51,34,32,5,5,32};
        ListNode head=createList(array);
        System.out.println("创建链表");
        printList(head);
        System.out.println("删除指定值的链表元素");
        deleteList(head,5);
        printList(head);
        System.out.println("反转链表");
        head=reverseList(createList(array));
        printList(head);
        System.out.println("删除指定位置的链表节点");
        printList(indexDeleteList(createList(array),1));
        System.out.println("删除倒数第n个节点");
        printList(reverseIndexDeleteListNode(createList(array),getListLength(createList(array))));
        printList(reverseIndexDeleteListNode(createList(array),1));
        System.out.println("反转L位置和R位置之间的链表");
        ListNode a = createList(array);
        printList(reversePartList(a, 1, 7));

    }
}