算法与数据结构基础学习六（链表问题总结）

最新推荐文章于 2024-09-16 20:32:31 发布
最新推荐文章于 2024-09-16 20:32:31 发布
阅读量86 收藏
点赞数
分类专栏： 算法与数据结构 文章标签： 链表 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Master_guoguo/article/details/125191819
版权
本文探讨了链表的多种操作，包括使用快慢指针寻找链表中点及前后节点，判断链表是否为回文，以及链表排序和查找链表相交节点的方法。详细介绍了不同算法的时间复杂度和实现细节，涵盖了基础的链表操作和高级的链表问题解决策略。
摘要由CSDN通过智能技术生成

快慢指针

在这里插入图片描述


public class LinkedListMid {
    public static class Node{
        public int value;
        public Node next;
        public Node(int value){
            this.value = value;
        }
    }

    //输入链表头节点，奇数长度返回中点，偶数长度返回上中点
    //快慢指针实现
    public static Node midOrUpMidNode(Node head){
        if (head == null || head.next == null || head.next.next == null){
            return head;
        }
        Node slow = head.next;
        Node fast = head.next.next;
        while (fast.next != null && fast.next.next != null){
            slow = slow.next;
            fast = fast.next.next;
        }
        return slow;
    }
    //输入链表头节点，奇数长度返回中点，偶数长度返回下中点
    public static Node midOrDownMidNode(Node head){
        if (head == null || head.next == null || head.next.next == null){
            return head;
        }
        Node slow = head.next;
        Node fast = head.next;
        while (fast.next != null && fast.next.next != null){
            slow = slow.next;
            fast = fast.next.next;
        }
        return slow;
    }
    //输入链表头节点，奇数长度返回中点前一个，偶数长度返回上中点前一个
    public static Node midOrUpMidPreNode(Node head){
        if (head == null || head.next == null || head.next.next == null){
            return null;
        }
        Node slow = head;
        Node fast = head.next.next;
        while (fast.next != null && fast.next.next != null){
            slow = slow.next;
            fast = fast.next.next;
        }
        return slow;
    }
    //输入链表头节点，奇数长度返回中点前一个，偶数长度返回下中点前一个
    public static Node midOrDownMidPreNode(Node head){
        if (head == null || head.next == null){
            return null;
        }
        Node slow = head;
        Node fast = head.next;
        while (fast.next != null && fast.next.next != null){
            slow = slow.next;
            fast = fast.next.next;
        }
        return slow;

    }
    public static Node right1(Node head){
        if (head == null){
            return null;
        }
        Node cur = head;
        ArrayList<Node> arr = new ArrayList<>();
        while (cur!=null){
            arr.add(cur);
            cur = cur.next;
        }
        return arr.get((arr.size()-1)/2);
    }
    public static Node right2(Node head) {
        if (head == null) {
            return null;
        }
        Node cur = head;
        ArrayList<Node> arr = new ArrayList<>();
        while (cur != null) {
            arr.add(cur);
            cur = cur.next;
        }
        return arr.get(arr.size() / 2);
    }

    public static Node right3(Node head) {
        if (head == null || head.next == null || head.next.next == null) {
            return null;
        }
        Node cur = head;
        ArrayList<Node> arr = new ArrayList<>();
        while (cur != null) {
            arr.add(cur);
            cur = cur.next;
        }
        return arr.get((arr.size() - 3) / 2);
    }

    public static Node right4(Node head) {
        if (head == null || head.next == null) {
            return null;
        }
        Node cur = head;
        ArrayList<Node> arr = new ArrayList<>();
        while (cur != null) {
            arr.add(cur);
            cur = cur.next;
        }
        return arr.get((arr.size() - 2) / 2);
    }
    public static void main(String[] args) {
        Node test = null;
        test = new Node(0);
        test.next = new Node(1);
        test.next.next = new Node(2);
        test.next.next.next = new Node(3);
        test.next.next.next.next = new Node(4);
        test.next.next.next.next.next = new Node(5);
        test.next.next.next.next.next.next = new Node(6);
        test.next.next.next.next.next.next.next = new Node(7);
        test.next.next.next.next.next.next.next.next = new Node(8);

        Node ans1 = null;
        Node ans2 = null;

        ans1 = midOrUpMidNode(test);
        ans2 = right1(test);
        System.out.println(ans1 != null ? ans1.value : "无");
        System.out.println(ans2 != null ? ans2.value : "无");

        ans1 = midOrDownMidNode(test);
        ans2 = right2(test);
        System.out.println(ans1 != null ? ans1.value : "无");
        System.out.println(ans2 != null ? ans2.value : "无");

        ans1 = midOrUpMidPreNode(test);
        ans2 = right3(test);
        System.out.println(ans1 != null ? ans1.value : "无");
        System.out.println(ans2 != null ? ans2.value : "无");

        ans1 = midOrDownMidPreNode(test);
        ans2 = right4(test);
        System.out.println(ans1 != null ? ans1.value : "无");
        System.out.println(ans2 != null ? ans2.value : "无");

    }

}

回文问题

在这里插入图片描述

import java.util.Stack;

public class IsPalindromeList {
    public static class Node{
        public int value;
        public Node next;
        public Node(int value){
            this.value = value;
        }
    }
    //判断链表是否属于回文
    //need n extra space
    public static boolean isPalindrome1(Node head){
        if (head == null){
            return true;
        }
        Stack<Node> stack = new Stack<>();
        Node cur = head;
        while (cur != null){
            stack.push(cur);
            cur = cur.next;
        }
        while (head != null){
            if (head.value != stack.pop().value){
                return false;
            }
            head = head.next;
        }
        return true;
    }
    //need n/2 extra space
    //判断是否为回文
    public static boolean isPalindrome2(Node head){
        if (head == null || head.next == null){
            return true;
        }
        Node rihgt = head.next;
        Node cur = head;
        while (cur.next != null && cur.next.next != null){
            rihgt = rihgt.next;
            cur = cur.next.next;
        }
        Stack<Node> stack = new Stack<>();
        while (rihgt != null){
            stack.push(rihgt);
            rihgt = rihgt.next;
        }
        while (!stack.isEmpty()){
            if (head.value != stack.pop().value){
                return false;
            }
            head = head.next;
        }
        return true;
    }
    //need O(1) extra space
    //回文
    public static boolean isPalindrome3(Node head){
        if (head == null || head.next == null){
            return true;
        }
        //找到链表中点和终点
        Node n1 = head;
        Node n2 = head;
        while (n2.next != null && n2.next.next != null){
            n1 = n1.next;
            n2 = n2.next.next;
        }
        //反转后半部分链表
        n2 = n1.next; //n2-->right part first node
        n1.next = null; // mid.next = null
        Node n3 = null;
        while (n2 != null){
            n3 = n2.next; // n3-->save next node
            n2.next = n1; // 反转
            n1 = n2;
            n2 = n3;
        }
        n3 = n1; //保存右边反转后头节点
        n2 = head; //左边头节点
        boolean res = true;
        while (n1 != null && n2 != null){
            if (n1.value != n2.value){
                res = false;
                break;
            }
            n1 = n1.next;
            n2 = n2.next;
        }
        //将反转的链表再反转回来
        n1 = null;
        n2 = null;
        while (n3 != null){
            n1 = n3.next;
            n3.next = n2;
            n2 = n3;
            n3 = n1;
        }
        return res;
    }
    //for test
    public static void printLinkedList(Node head){
        System.out.print("Linked list: ");
        while (head != null){
            System.out.print(head.value+" ");
            head = head.next;
        }
        System.out.println();
    }

    public static void main(String[] args) {
        Node head = null;
        printLinkedList(head);
        System.out.print(isPalindrome1(head) + " | ");
        System.out.print(isPalindrome2(head) + " | ");
        System.out.println(isPalindrome3(head) + " | ");
        printLinkedList(head);
        System.out.println("=========================");

        head = new Node(1);
        printLinkedList(head);
        System.out.print(isPalindrome1(head) + " | ");
        System.out.print(isPalindrome2(head) + " | ");
        System.out.println(isPalindrome3(head) + " | ");
        printLinkedList(head);
        System.out.println("=========================");

        head = new Node(1);
        head.next = new Node(2);
        printLinkedList(head);
        System.out.print(isPalindrome1(head) + " | ");
        System.out.print(isPalindrome2(head) + " | ");
        System.out.println(isPalindrome3(head) + " | ");
        printLinkedList(head);
        System.out.println("=========================");

        head = new Node(1);
        head.next = new Node(1);
        printLinkedList(head);
        System.out.print(isPalindrome1(head) + " | ");
        System.out.print(isPalindrome2(head) + " | ");
        System.out.println(isPalindrome3(head) + " | ");
        printLinkedList(head);
        System.out.println("=========================");

        head = new Node(1);
        head.next = new Node(2);
        head.next.next = new Node(3);
        printLinkedList(head);
        System.out.print(isPalindrome1(head) + " | ");
        System.out.print(isPalindrome2(head) + " | ");
        System.out.println(isPalindrome3(head) + " | ");
        printLinkedList(head);
        System.out.println("=========================");

        head = new Node(1);
        head.next = new Node(2);
        head.next.next = new Node(1);
        printLinkedList(head);
        System.out.print(isPalindrome1(head) + " | ");
        System.out.print(isPalindrome2(head) + " | ");
        System.out.println(isPalindrome3(head) + " | ");
        printLinkedList(head);
        System.out.println("=========================");

        head = new Node(1);
        head.next = new Node(2);
        head.next.next = new Node(3);
        head.next.next.next = new Node(1);
        printLinkedList(head);
        System.out.print(isPalindrome1(head) + " | ");
        System.out.print(isPalindrome2(head) + " | ");
        System.out.println(isPalindrome3(head) + " | ");
        printLinkedList(head);
        System.out.println("=========================");

        head = new Node(1);
        head.next = new Node(2);
        head.next.next = new Node(2);
        head.next.next.next = new Node(1);
        printLinkedList(head);
        System.out.print(isPalindrome1(head) + " | ");
        System.out.print(isPalindrome2(head) + " | ");
        System.out.println(isPalindrome3(head) + " | ");
        printLinkedList(head);
        System.out.println("=========================");

        head = new Node(1);
        head.next = new Node(2);
        head.next.next = new Node(3);
        head.next.next.next = new Node(2);
        head.next.next.next.next = new Node(1);
        printLinkedList(head);
        System.out.print(isPalindrome1(head) + " | ");
        System.out.print(isPalindrome2(head) + " | ");
        System.out.println(isPalindrome3(head) + " | ");
        printLinkedList(head);
        System.out.println("=========================");

    }
}

链表排序

在这里插入图片描述

import java.util.ArrayList;
public class SmallEqualBigger {
    public static class Node{
        public int value;
        public Node next;
        public Node(int value){
            this.value = value;
        }
    }

    public static Node listPartition1(Node head,int pivot){
        if (head == null || head.next == null){
            return head;
        }
        Node cur = head;
        int i =0;
        while (cur != null){
            i++;
            cur = cur.next;
        }
        Node[] nodeArr = new Node[i];
        i=0;
        cur = head;
        while (cur != null){
            nodeArr[i] = cur;
            cur = cur.next;
            i++;
        }
        arrPartition(nodeArr,pivot);
        for (i=1;i != nodeArr.length;i++){
            nodeArr[i-1].next = nodeArr[i];
        }
        nodeArr[i-1].next = null;
        return nodeArr[0];

    }

    private static void arrPartition(Node[] nodeArr, int pivot) {
        int small = -1;
        int big = nodeArr.length;
        int index = 0;
        while (index!=big){
            if (nodeArr[index] !=null && nodeArr[index].value < pivot){
                swap(nodeArr,index++,++small);
            }else if (nodeArr[index]!= null &&nodeArr[index].value == pivot){
                index++;
            }else {
                swap(nodeArr,index,--big);
            }
        }
    }

    private static void swap(Node[] nodeArr, int i, int i1) {
        Node tmp = nodeArr[i];
        nodeArr[i] = nodeArr[i1];
        nodeArr[i1] = tmp;
    }

    //分成小、中、大三部分，再把各个部分之间串起来
    public static Node listPartition2(Node head,int pivot){
        Node sH = null; //small head
        Node sT = null; //small tail
        Node eH = null; //equal head
        Node eT = null; //equal tail
        Node mH = null; //big head
        Node mT = null; //big tail
        Node next = null; //save next node
        //every node distributed to three lists
        while (head != null){
            next = head.next;
            head.next = null;
            if (head.value < pivot){
                if (sH == null){
                    sH = head;
                    sT = head;
                }else {
                    sT.next = head;
                    sT = head;
                }
            }else if (head.value == pivot){
                if (eH == null){
                    eH = head;
                    eT = head;
                }else {
                    eT.next = head;
                    eT = head;
                }
            }else {
                if (mH == null){
                    mH = head;
                    mT = head;
                }else {
                    mT.next = head;
                    mT = head;
                }
            }
            head = next;
        }
        //小于区的尾巴连等于区的头。等于区的尾巴连大于去的头
        if (sT != null){
            sT.next = eH;
            eT = eT == null ? sT : eT; //下一步，谁去连大于区的头谁就取eT
        }
        // 下一步，一定是需要用eT 去接 大于区域的头
        // 有等于区域，eT -> 等于区域的尾结点
        // 无等于区域，eT -> 小于区域的尾结点
        // eT 尽量不为空的尾巴节点
        if (eT != null){
            eT.next = mH;
        }
        return sH != null ? sH : (eH != null ? eH : mH);
    }
    public static void printLinkedList(Node head){
        System.out.print("Linked list: ");
        while (head != null){
            System.out.print(head.value+" ");
            head = head.next;
        }
        System.out.println();
    }
    public static void main(String[] args) {
        Node head1 = new Node(7);
        head1.next = new Node(9);
        head1.next.next = new Node(1);
        head1.next.next.next = new Node(8);
        head1.next.next.next.next = new Node(5);
        head1.next.next.next.next.next = new Node(2);
        head1.next.next.next.next.next.next = new Node(5);
        printLinkedList(head1);
        head1 = listPartition1(head1, 4);
        //head1 = listPartition2(head1, 5);
        printLinkedList(head1);

    }
}

一种特殊链表

在这里插入图片描述


import java.util.HashMap;

public class CopyListWithRandom {
    public static class Node{
        public int val;
        public Node next;
        public Node random;
        public Node(int value){
            this.val = value;
            this.next = null;
            this.random = null;
        }
    }
    //给定一个由Node节点类型组成的无环单链表的头节点 head，请实现一个函数完成这个链表的复制，并返回复制的新链表的头节点。
    public static Node copyRandomList1(Node head){
        //key 老节点
        //value 新节点
        HashMap<Node, Node> map = new HashMap<>();
        Node cur = head;
        while (cur != null){
            map.put(cur,new Node(cur.val));
            cur = cur.next;
        }
        cur = head;
        while (cur != null){
            // cur 老
            //map.get(cur) 新
            map.get(cur).next = map.get(cur.next);
            map.get(cur).random = map.get(cur.random);
            cur = cur.next;
        }
        return map.get(head);
    }

    public static Node copyRandomList2(Node head){
        if (head == null){
            return null;
        }
        Node cur = head;
        Node next = null;
        // 1 -> 2 -> 3 -> null
        // 1 -> 1' -> 2 -> 2' -> 3 -> 3'
        while (cur != null){
            next = cur.next;
            cur.next = new Node(cur.val);
            cur.next.next = next;
            cur = next;
        }
        cur = head;
        Node copy = null;
        while (cur != null){
            next = cur.next.next;
            copy = cur.next;
            copy.random = cur.random != null ? cur.random.next : null;
            cur = next;
        }
        //在next方向上把新 老链分离
        cur = head;
        Node res = head.next;
        while (cur != null){
            next = cur.next.next;
            copy = cur.next;
            cur.next = next;
            copy.next = next != null? next.next : null;
            cur = next;
        }
        return res;
    }
}

链表环

在这里插入图片描述


public class FindFirstIntersectNode {
    //给定两个可能有环也可能无环的单链表，头节点head1和head2。请实现一个函数，如果两个链表相交，请返回相交的 第一个节点。如果不相交，返回null
    //如果两个链表长度之和为N，时间复杂度请达到O(N)，额外空间复杂度 请达到O(1)
    public static class Node{
        public int value;
        public Node next;
        public Node(int value){
            this.value = value;
        }
    }
    public static Node getInsertNode(Node head1,Node head2){
        if (head1 == null || head2 == null){
            return null;
        }
        Node loop1 = getLoopNode(head1);
        Node loop2 = getLoopNode(head2);
        if (loop1 == null && loop2 == null){
            return noLoop(head1,head2);
        }
        if (loop1 != null && loop2 != null){
            return bothLoop(head1,loop1,head2,loop2);
        }
        return null;
    }
    //找到链表的第一个入环节点，如果无环，返回null
    public static Node getLoopNode(Node head){
        if (head == null || head.next == null || head.next.next == null){
            return  null;
        }
        Node slow = head.next;
        Node fast = head.next.next;
        //追击问题，跑的快的在环里总会跟跑的慢的相遇，
        while (slow != fast){
            if (fast.next == null || fast.next.next == null){
                return null;
            }
            slow = slow.next;
            fast = fast.next.next;
        }
        fast = head;
        //相遇后，跑的快的回到起点保持和慢一样的速度，相遇时就是环的节点
        while (fast != slow){
            slow = slow.next;
            fast = fast.next;
        }
        return slow;
    }
    //如果两个链表都没环，返回第一个相交点， 如果不相交返回null
    public static Node noLoop(Node head1,Node head2){
        if (head1 == null || head2 == null){
            return null;
        }
        Node cur1 = head1;
        Node cur2 = head2;
        int n=0;
        while (cur1.next != null){
            n++;
            cur1 = cur1.next;
        }
        while (cur2.next != null){
            n--;
            cur2 = cur2.next;
        }
        if (cur1 != cur2){
            return null;
        }
        // n -> head1 - head2 的长度的值
        cur1 = n > 0 ? head1 : head2; //谁长，谁的头变成cur1
        cur2 = cur1 == head1 ? head2 :head1; //短的链表头变成cur2
        n = Math.abs(n);
        while (n !=0){
            n--;
            cur1 = cur1 != null ? cur1.next : null;
        }
        //此时cur1、cur2两个链表长度一样
        while (cur1 != cur2){
            cur1 = cur1 != null ? cur1.next : null;
            cur2= cur2 != null ? cur2.next : null;
        }
        return cur1;
    }
    //两个有环列表，相交返回第一个相交点，不相交返回null
    public static Node bothLoop(Node head1,Node loop1,Node head2,Node loop2){
        if (head1 == null || head2 == null){
            return null;
        }
        Node cur1 = null;
        Node cur2 = null;
        //如果入环节点一样,相交必在入环前
        if (loop1 == loop2){
            cur1 = head1;
            cur2 = head2;
            int n = 0;
            while (cur1 != loop1){
                n++;
                cur1 = cur1.next;
            }
            while (cur2 != loop2){
                n--;
                cur2 = cur2.next;
            }
            cur1 = n>0 ? head1:head2;
            cur2 = cur1 == head1 ? head2 : head1;
            n = Math.abs(n);
            while (n!=0){
                n--;
                cur1 = cur1.next;
            }
            while (cur1 != cur2){
                cur1 = cur1.next;
                cur2 = cur2.next;
            }
            return cur1;
        }else {
            cur1 = loop1.next;
            while (cur1 != loop1){
                if (cur1 == loop2){
                    return loop1;
                }
                cur1 = cur1.next;
            }
            return null;
        }
    }
    public static void main(String[] args) {
        // 1->2->3->4->5->6->7->null
        Node head1 = new Node(1);
        head1.next = new Node(2);
        head1.next.next = new Node(3);
        head1.next.next.next = new Node(4);
        head1.next.next.next.next = new Node(5);
        head1.next.next.next.next.next = new Node(6);
        head1.next.next.next.next.next.next = new Node(7);

        // 0->9->8->6->7->null
        Node head2 = new Node(0);
        head2.next = new Node(9);
        head2.next.next = new Node(8);
        head2.next.next.next = head1.next.next.next.next.next; // 8->6
        System.out.println(getInsertNode(head1, head2).value);

        // 1->2->3->4->5->6->7->4...
        head1 = new Node(1);
        head1.next = new Node(2);
        head1.next.next = new Node(3);
        head1.next.next.next = new Node(4);
        head1.next.next.next.next = new Node(5);
        head1.next.next.next.next.next = new Node(6);
        head1.next.next.next.next.next.next = new Node(7);
        head1.next.next.next.next.next.next = head1.next.next.next; // 7->4

        // 0->9->8->2...
        head2 = new Node(0);
        head2.next = new Node(9);
        head2.next.next = new Node(8);
        head2.next.next.next = head1.next; // 8->2
        System.out.println(getInsertNode(head1, head2).value);

        // 0->9->8->6->4->5->6..
        head2 = new Node(0);
        head2.next = new Node(9);
        head2.next.next = new Node(8);
        head2.next.next.next = head1.next.next.next.next.next; // 8->6
        System.out.println(getInsertNode(head1, head2).value);

    }

}

from —左程云算法基础课

Master_guoguo
关注
专栏目录
数据结构与算法基础知识总结.pdf
07-14
数据结构与算法是计算机科学的基础，对于理解和优化程序性能至关重要。算法是解决问题的精确步骤描述，它不等同于程序，但程序的高效实现离不开良好的算法设计。算法必须具备可行性、确定性、有穷性和足够的信息，即...
实验二 线性表的应用（二）
程序设计
10-20 393
实验二 线性表的应用（二） 【实验类别】设计型实验 【实验目的】 1.熟悉线性表的顺序存储和链式存储各自的特点及运算； 2.熟练掌握线性表的基本操作在不同存储结构中实现算法； 3.通过本次实验帮助学生加深对C语言的使用（特别是函数的参数调用、指针类型的应用和链表的建立等各种基本操作） 4．对一个实际的问题能够进行合理的需求分析，选择合适的存储结构，设计完成符合实际需要的功能。 【实验学时】4 学时 【实验组人数】1 人。 【实验设备环境】计算机，VC++6.0，C-Free等 【实验内容】 1、停车场的管理
数据结构课程设计----停车场管理系统（栈和队列）
热门推荐
化身强盗的博客
12-13 1万+
题目： 设停车场（如下图1所示）内只有一个可停放几量汽车的狭长通道，且只有一个大门可供汽车进出。汽车在停车场内按车辆到达时的先后顺序，依次由北向南排列（大门在最南端，最先到达的第一辆车停放在车场的最北端），若车场内已经停满几量汽车，则后来的汽车只能在门外的便道上等候，一旦停车场内有车开走，则排在便道上的第一辆汽车即可开入；当停车场内某车辆要离开时，由于停车场是狭长的通道，在它之后开入车场的车辆必须先退出车场为它让路，待该车辆开出大门外后，为它让路的车辆再按原次序进入车场。在这里假设汽车不能从便道上开走。试设
数据结构 链表常见算法问题(一)
qq_43128902的博客
10-07 579
数据结构，线性表，链表常见算法 算法和问题来自于试卷，辅导书，以及网络。 //顺序表的一般数据结构 typedef struct LNode{ int data; struct Lnode *next; }LNode,*LinkList; 算法2.2.1 设计一个递归算法，删除不带头节点的单链表L中所有值为x的节点 分析：略 bool deleteX(LinkList &L,int x) { LinkList *p; if(L==NULL) return 0; else if
算法与数据结构——算法基础——链表（java）（左程云b站课程笔记总结）
Borslav的博客
06-05 352
算法与数据结构——算法基础——链表（java）（左程云b站课程笔记总结）
算法和数据结构总结---单链表
Kroner的博客
11-22 606
链表 链表可以说是一种很基本的数据结构，链表通常以一种特定的组合将元素链接在一起，以便可以对元素实现方便的管理维护。这一点和我们常常使用的数组很相似，但是链表在最多的情况下可以带来比链表更为优势的操作，链表通常是在系统需要的时候动态开辟的，换句话说链表的存储空间是在程序运行的时候在进行分配的，在许多的时候，我们无法明确的确定数据的大小直接在编译前分配内存，这种动态分配的方法也是链表的优势之一。 单...
【Java数据结构与算法】环形链表及约瑟夫问题
12-21
【Java数据结构与算法】环形链表及约瑟夫问题 环形链表是一种特殊的数据结构，它的每个节点都包含一个数据元素和一个指向下一个节点的指针，且最后一个节点的指针会指向列表的第一个节点，形成一个闭合的循环。这种...
数据结构与算法 c语言 线性表-静态链表
04-27
数据结构与算法 c语言 线性表-静态链表 静态链表源码
数据结构和算法-2.顺序表与链表
08-10
对于希望巩固数据结构基础、提升算法能力的读者来说，这份笔记是不可多得的学习资源。无论你是计算机专业的学生，还是在职的软件开发者，这份笔记都将为你提供深刻的见解和实际的编程技巧，助你在日常开发和面试中...
数据结构与算法学习总结.zip
01-15
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树...学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
数据结构及算法：链表相关（如何判断单链表是否存在环、找出入环点、链表相交等问题）
天才小站
06-27 1258
目录 一、如何判断单链表是否存在环 方法一、穷举遍历 方法二、哈希表缓存 方法三、快慢指针（推荐） 方法四、Set集合大小变化 二、如何找出有环链表的入环点？ 方法一、用HashSet来解决 方法二、计算循环（快慢指针） 情况一：多走一个环 情况二、当fast比slow 多走n个环 代码实现 三、如果存在环，求出环上节点的个数； 四、如果存在环，求出链表的长度； ...
数据结构之线性表（python）
huaz_md的博客
09-16 504
线性表零个或多个数据元素的有限序列在逻辑结构上具有线性关系。将具有“一对一”关系的数据“线性”地存储到物理空间中，这种存储结构就称为线性存储结构（简称线性表线性表元素的个数nn>=0）定义为线性表的长度，当n=0时，称为空表。在较复杂的线性表中，一个数据元素可以有若干个数据项组成。线性表又可以分为顺序表顺序存储结构）和链表链式存储结构。
排序算法-交换排序
weixin_74312694的博客
09-16 702
1. 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序2. 时间复杂度：O(N*logN)如果还想了解更多排序欢迎大家前往我的主页。
LeetCode力扣二叉树算法训练
你白勺男孩TT的博客
09-13 324
经典问题，根据前序遍历和中序遍历还原一棵二叉树，虽然这个函数的参数比较多，但是它主要是控制数组的索引而已，注意到build的位置，本质上该算法也就是一个前序遍历，因为它在前序遍历的位置上加了一个代码逻辑。注意递归函数的位置，这就是后序遍历嘛，无非就是把traverse函数名字改成了oneSideMax了。中序遍历对于一棵二叉搜索树意味着什么？
Java-数据结构-二叉树-基础 (oﾟ▽ﾟ)o
2303_80388948的博客
09-12 902
OK，到这里呢，我们的二叉树基础就到这里就结束了，我们接下来看看关于二叉树的相关的习题，并且在题中我们会看见我们 二叉树的创建方法。让我们期待下次的博客吧！！！拜拜啦~~~
MATLAB系列03：分支语句和编程设计
lbm666666的博客
09-16 592
所谓的自顶向下的编程方法，本质上就是编写程序的视角从整体的宏观性逐层进入具体的微观性的一种编程思想。我们编写程序时一开始不用思考得事无巨细，把所有细节都想清楚；也不要面条式的想到哪里写到哪里。而应该是自顶向下的，从一个大的粗的核心的任务开始，逐级细分，最后再完成最底层的具体实现。清晰地陈述出你要解决的问题。确定程序所需地输入量和程序所产生的输出量。为你的程序设计算法将算法转化为 MATLAB 语句调试MATLAB语句。
深入理解指针（4）
khjjjgd的博客
09-11 820
如果把函数的指针（地址）作为参数传递给另一个函数 ，当这个指针被用来调用其所指向的函数时，被调用的函数就是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或者条件发生时由另外的一方调用的，用于对该事件或条件进行响应。
【探索数据结构与算法】插入排序：原理、实现与分析（图文详解）
最新发布
2302_80220709的博客
09-16 679
因此，第i个元素需要比较i次（其中i从2开始，直到n），总共需要进行的比较次数大约为1 + 2 + 3 + ... + (n-1) = n(n-1)/2，时间复杂度为O(n^2)。当输入数组已经是排序状态时，插入排序的性能最优。插入排序是一种原地排序算法，它只需要一个额外的存储空间来暂存当前需要插入的元素（即“key”），而不需要额外的数组来存储排序过程中的数据。在插入排序过程中，如果两个相等的元素，后面的元素不会移动到前面元素的前面，而是直接插入到与它相等的元素之后，从而保持了原有的相对顺序。
数据结构(7.3_1)——二叉排序树
m0_65240792的博客
09-14 410
又称左子树结点值<根结点值<右子树结点值进行中序遍历，可以得到一个递增的有序序列二叉排序树可用于元素的有序组织，搜索。
数据结构与算法：简单程序基础及链表入门
"本文档深入探讨了简单程序的概念及其与数据结构和算法的关系，强调了数据结构基础在编程中的核心地位。学习目标包括理解数据结构（如链表、树和基本查找/排序算法）的基本概念，以及如何将它们应用于编写程序。简单...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值