【无头双向链表和链表练习题2】

简介: 【无头双向链表和链表练习题2】

以给定值x为基准将链表分割成两部分,所有小于x的结点排在大于或等于x的结点之前


public class Partition {
    public ListNode partition(ListNode pHead, int x) {
        // write code here
        //创建四个节点
        ListNode bs = null;
        ListNode be = null;
        ListNode as = null;
        ListNode ae = null;
        ListNode cur = pHead; 
        if(cur == null){
            return null;
        }
        while(cur != null){
            if(cur.val < x){
           //小于x放左边
                if(bs == null){
                //当bs里面没有节点时
                    bs = cur;
                    be = cur;     
                }else{
                //有节点了用be去遍历
                    be.next = cur;
                    be = cur;
                }
            }else{
            //大于x放右边
                if(as == null){
                //当as里面没有节点时
                    as = cur;
                    ae = cur;
                }else{
                //有节点了用ae去遍历
                    ae.next = cur;
                    ae = cur;
                }
            }
            cur = cur.next;
        }
        //cur遍历完了开始串起来
        //如果前面为空
        if(bs == null){
            return as;
        }
        //如果都不为空
        be.next = as;
        //如果后面不为空,要置为空
        if(as != null){
            ae.next = null;
        }
        return bs; 
}
}


输入两个链表,找出它们的第一个公共结点。


public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB){
    ListNode cur1 = headA;
    ListNode cur2 = headB; 
    int len1 =0;
    int len2 = 0;
    //1.求链表的长度
    while(cur1 != null){
        len1++;//5
        cur1 = cur1.next;
    }
    while(cur2 != null){
        len2++;//2
        cur2 = cur2.next;
    }
    cur1 = headA;
    cur2 = headB; 
        //int len = math.abs(len1 - len2);//3
        //2.走差值步
        if(len1>len2){
            for(int i = 0;i < len1-len2;i++){
                cur1 = cur1.next;
            }
        }else{
            for(int j = 0;j < len2 - len1;j++){
                cur2 = cur2.next;
            }
        }
        //3.同时走
    while(cur1 != cur2 ){
        cur1 = cur1.next;
        cur2 = cur2.next;
    }
    //如果没相遇,都是空
    if(cur1 == null){
        return null;
    }
     return cur1;
    }
}


给定一个链表,判断链表中是否有环


        public class Solution {
            public boolean hasCycle(ListNode head) {
                ListNode fast = head;
                ListNode slow = head;
                while(fast != null && fast.next != null){
                    fast = fast.next.next;//走两步
                    slow = slow.next;//走一步
                    if(fast == slow){
                        return true;
                    }
                }
                return false;
            }
        }


无头双向链表的模拟实现


public interface IList {
    // 2、无头双向链表实现
        //头插法
         void addFirst(int data);
         void addLast(int data);
        //任意位置插入,第一个数据节点为0号下标
         void addIndex(int index,int data);
        //查找是否包含关键字key是否在单链表当中
         boolean contains(int key);
        //删除第一次出现关键字为key的节点
         void remove(int key);
        //删除所有值为key的节点
         void removeAllKey(int key);
        //得到单链表的长度
         int size();
         void display();
        void clear();
}
public class MyLinkedList implements IList {
    //节点内部类
    static class ListNode{
        public int val;
        public ListNode next;
        public ListNode prev;
        public ListNode(int val){
            this.val = val;
        }
    }
    public ListNode head;
    public ListNode last;
    @Override
    public void addFirst(int data) {
        //实例化一个节点
        ListNode node = new ListNode(data);
        if (head == null){
            head = node;
            last = node;
        }else{
            node.next = head;
            head.prev = node;
            head = node;
        }
    }
    //尾插法
    @Override
    public void addLast(int data) {
        ListNode node = new ListNode(data);
        if (last == null){
            last = node;
            head = node;
        }else{
            last.next = node;
            node.prev = last;
            last = node;
        }
    }
    //让cur去到index位置
    private ListNode findIndex(int index){
        ListNode cur = this.head;
        //index-1
        while(index != 0){
            cur = cur.next;
            index--;
        }
        return cur;
    }
    //   插入节点
    @Override
    public void addIndex(int index, int data) {
        ListNode node = new ListNode(data);
        //检查index是否合法
        if(index < 0 || index >size()){
            //抛出自定义异常
            System.out.println("index不合法");
            return;
        }
        //头插法
        if(index == 0){
//            node.next = head;
//            head.prev = node;
//            head = node;
            addFirst(data);
            return;
        }
        //尾插法
        if (index == size()){
//            last.next = node;
//            node.prev = last;
//            last = node;
            addLast(data);
            return;
        }
        ListNode cur = findIndex(index);
        node.next = cur;
        cur.prev.next = node;
        node.prev = cur.prev;
        cur.prev = node;
    }
    @Override
    public boolean contains(int key) {
        ListNode cur = head;
        while(cur != null){
            if (cur.val == key){
                return true;
            }
            cur = cur.next;
        }
        return false;
    }
    @Override
    public void remove(int key) {
        ListNode cur = head;
        while (cur != null) {
            //如果等于关键字进入循环
            if (cur.val == key) {
                //删除头
                if (cur == head) {
                    //如果只有一个节点
                    head = head.next;//head已经删了
                    if (head != null){
                        //如果有很多节点
                        head.prev = null;
                    }
                    last = null;
                } else {
                    //删中间节点和尾巴节点的共同代码
                    cur.prev.next = cur.next;
                    if (cur.next == null) {
                        //删尾巴节点
                        last = last.prev;
                    } else {
                        //删中间节点
                        cur.next.prev = cur.prev;
                    }
                }
                return;
            }else{
                //不等于,cur往后走
                cur = cur.next;
            }
        }
    }
    @Override
    public void removeAllKey(int key) {
        ListNode cur = head;
        while (cur != null) {
            //如果等于关键字进入循环
            if (cur.val == key) {
                //删除头
                if (cur == head) {
                    //如果只有一个节点
                    head = head.next;//head已经删了
                    if (head != null){
                        //如果有很多节点
                        head.prev = null;
                    }
                    last = null;
                } else {
                    //删中间节点和尾巴节点的共同代码
                    cur.prev.next = cur.next;
                    if (cur.next == null) {
                        //删尾巴节点
                        last = last.prev;
                    } else {
                        //删中间节点
                        cur.next.prev = cur.prev;
                    }
                }
            }
            //继续往后遍历
                cur = cur.next;
        }
    }
    //求链表长度
    @Override
    public int size() {
        ListNode cur = head;
        int count = 0;
        while(cur != null){
            count++;
            cur = cur.next;
        }
        return count;
    }
    //打印链表
    @Override
    public void display() {
        ListNode cur = head;
        while(cur != null){
            System.out.print(cur.val +" ");
            cur = cur.next;
        }
        System.out.println();
    }
    @Override
    public void clear() {
        head = null;
        last = null;
    }
}
public class TestLink {
    //遍历链表
    public static void main(String[] args) {
        LinkedList<Integer> list =new LinkedList<>();
        list.add(1);
        list.add(3);
        list.add(5);
        list.add(7);
        list.add(9);
        list.add(12);
        System.out.println(list);
        System.out.println("=================");
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i)+" ");
        }
    }
}


ArrayList(顺序表)和LinkedList(双向链表)的区别



总结


链表的学习就到这里,最重要的就是什么是链表,链表又细分为哪些链表,要会把链表画出来,链表和顺序表的区别,链表的各种方法的实现,链表的各种练习题等。

相关文章
|
3月前
|
存储 Java
|
4月前
链表8(法二考试专用)7-8 sdut-C语言实验-双向链表
链表8(法二考试专用)7-8 sdut-C语言实验-双向链表
20 0
|
4月前
sdut 链表 8 -----7-8 sdut-C语言实验-双向链表
sdut 链表 8 -----7-8 sdut-C语言实验-双向链表
19 0
|
5月前
|
存储 缓存
【海贼王的数据航海】链表—双向链表
【海贼王的数据航海】链表—双向链表
28 0
|
5月前
|
存储 算法 前端开发
【C/数据结构与算法】:链表的实现(单向链表+双向链表)
【C/数据结构与算法】:链表的实现(单向链表+双向链表)
28 0
|
5月前
|
算法
数据结构和算法学习记录——线性表之双向链表(下)-头插函数、头删函数、查找函数、pos位置之前插入结点、pos位置删除结点及其复用、销毁链表函数
数据结构和算法学习记录——线性表之双向链表(下)-头插函数、头删函数、查找函数、pos位置之前插入结点、pos位置删除结点及其复用、销毁链表函数
30 0
|
6月前
|
存储
链表练习题-1
链表练习题
|
6月前
|
缓存 算法
【数据结构】----链表--双向链表
【数据结构】----链表--双向链表
42 0
|
6月前
|
算法 索引
链表经典练习题
链表经典练习题
|
6月前
|
Java
DAY-1 | Java数据结构之链表:删除无头单链表中等于给定值 val 的所有节点
力扣203题解:使用时间复杂度为O(n)的思路删除链表中所有值为key的元素。引入辅助指针pre,记录cur的前一个节点,遍历链表时,若cur.val!=key,pre和cur同时前进;若cur.val==key,则pre.next=cur.next,cur继续前进,确保pre不急于跟随以处理连续相同值的情况。遍历结束后,处理头节点可能需要删除的特殊情况。
46 0