剑指offer第二版题解系列（四）

最新推荐文章于 2022-08-31 15:59:54 发布
最新推荐文章于 2022-08-31 15:59:54 发布
阅读量124 收藏
点赞数
分类专栏： Java 剑指offer题解
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sfiayui123/article/details/81940999
版权

写在开头：正值毕业生求职期间，翻一翻剑指offer的书籍，将其中的题目进行分析和代码编写，并将代码整理到csdn博客上，如果有错误，敬请指出！（此系列不提供题目原文，请参考书籍《剑指offer第二版》即可。）

Test30 - Test39系列

1. Test30.java
import java.util.Stack;
public class Test30{
    Stack s1 = new Stack();
    Stack s2 = new Stack();
    public void push(int num)
    {
        if(s1.isEmpty()&&s2.isEmpty())
        {
            s1.push(num);
            s2.push(num);
        }
        else if(!s2.isEmpty())
        {
            s1.push(num);
            if(num<s2.peek())
                s2.push(num);
            else
                s2.push(s2.peek());
        }
    }
    public int pop()
    {
        if(s1.isEmpty())
            return -1;


            int x = s1.pop();
            s2.pop();
        return x;
    }
    public int min()
    {
        if(s2.isEmpty())
            return -1;
        else
            int x = s2.pop();
        return x;
    }
    public static void main(String[] args)
    {

    }
}
2. Test31.java
import java.util.Stack;
public class Test31{
    public static boolean popPush(int[] push,int[] pop) {
        if(push==null&&pop==null)
            return true;
        if(push==null||pop==null||push.length<1||pop.length<1||push.length!=pop.length)
            return false;
        Stack<Integer> s = new Stack<Integer>();
        int popIndex = 0;
//        Stack s2 = new Stack();
        for(int i=0;i<push.length;i++)
        {
            s.push(push[i]);
            while(!s.isEmpty()&&s.peek()==pop[popIndex]) {
                s.pop();
                popIndex++;
            }
        }
        if(s.isEmpty()&&popIndex==pop.length)
            return true;
        else
            return false;

    }
    public static void main(String[] args)
    {
        int[] push = {1,2,3,4,5};
        int[] pop = {4,5,3,1,2};
        boolean flag = false;
        flag = popPush(push,pop);
        System.out.println(flag);
    }


}
3. Test32.java
import java.util.Queue;
import java.util.LinkedList;
public class Test32{
    public static class BinaryTree
    {
        int data;
        BinaryTree left;
        BinaryTree right;
        public BinaryTree(int data)
        {
            this.data = data;

        }
    }
    public static void updownPrint(BinaryTree root)
    {
        if(root==null)
            return;
        Queue<BinaryTree> queue = new LinkedList<BinaryTree>();
        queue.add(root);
        while(!queue.isEmpty()) {
            BinaryTree node = queue.poll();
            System.out.println(node.data);
            if(node.left!=null) {
                queue.add(node.left);
            }
            if(root.right!=null) {
                queue.add(node.right);
            }

        }
        return;
    }
    public static void main(String[] args)
    {
        BinaryTree t1 = new BinaryTree(8);
        BinaryTree t2 = new BinaryTree(8);
        BinaryTree t3 = new BinaryTree(7);
        BinaryTree t4 = new BinaryTree(9);
        BinaryTree t5 = new BinaryTree(2);
        BinaryTree t6 = new BinaryTree(4);
        BinaryTree t7 = new BinaryTree(7);
        t1.left = t2;
        t1.right = t3;
        t2.left = t4;
        t2.right = t5;
        t3.left = null;
        t3.right = null;
        t5.left = t6;
        t5.right = t7;
        t4.left = null;
        t4.right = null;
        t6.right = null;
        t6.left = null;
        t7.left = null;
        t7.right = null;
        updownPrint(t1);
    }
}
4. Test32_2.java
import java.util.Queue;
import java.util.LinkedList;
public class Test32_2{
    public static class BinaryTree{
        int data;
        BinaryTree left;
        BinaryTree right;

        public BinaryTree(int data)
        {
            this.data = data;
        }
    }
    public static void upDownPrint(BinaryTree root)
    {
        if(root==null)
            return;
        Queue<BinaryTree> queue  = new LinkedList<BinaryTree>();
//        int ce = 1;
//        root.ceng = 1;
        queue.offer(root);
        int nextNode = 0;
        int toBehind = 1;
        while(!queue.isEmpty())
        {
           BinaryTree node = queue.poll();
           System.out.print(node.data+"\t");
            if(node.left!=null) {
//                node.left.ceng = node.ceng + 1;
                queue.offer(node.left);
                nextNode++;
            }
            if(node.right!=null) {
//                node.right.ceng = node.ceng + 1;
                queue.offer(node.right);
                nextNode++;
            }
            toBehind--;
            if(toBehind==0) {
                System.out.println();
                toBehind = nextNode;
                nextNode = 0;

            }

        }
        return;
    }
    public static void main(String[] args){
        BinaryTree t1 = new BinaryTree(8);
        BinaryTree t2 = new BinaryTree(8);
        BinaryTree t3 = new BinaryTree(7);
        BinaryTree t4 = new BinaryTree(9);
        BinaryTree t5 = new BinaryTree(2);
        BinaryTree t6 = new BinaryTree(4);
        BinaryTree t7 = new BinaryTree(7);
        t1.left = t2;
        t1.right = t3;
        t2.left = t4;
        t2.right = t5;
        t3.left = null;
        t3.right = null;
        t5.left = t6;
        t5.right = t7;
        t4.left = null;
        t4.right = null;
        t6.right = null;
        t6.left = null;
        t7.left = null;
        t7.right = null;
        upDownPrint(t1);
    }
}
5. Test32_3.java
import java.util.Stack;
public class Test32_3{
    public static class BinaryTree{
        int data;
        BinaryTree left;
        BinaryTree right;
        public BinaryTree(int data)
        {
            this.data = data;
        }
    }
    public static void zhiprint(BinaryTree root)
    {
        Stack<BinaryTree> s1 = new Stack<BinaryTree>();
        Stack<BinaryTree> s2 = new Stack<BinaryTree>();
        s1.push(root);
        while(!s1.isEmpty()||!s2.isEmpty()) {
            while (!s1.isEmpty()) {
                BinaryTree node1 = s1.pop();
                System.out.print(node1.data);
                if (node1.left != null)
                    s2.push(node1.left);
                if (node1.right != null)
                    s2.push(node1.right);
            }
            System.out.println();
            while (!s2.isEmpty()) {
                BinaryTree node2 = s2.pop();
                System.out.print(node2.data);
                if (node2.right != null)
                    s1.push(node2.right);
                if (node2.left != null)
                    s1.push(node2.left);
            }
            System.out.println();
        }
    }
    public static void main(String[] args){
        BinaryTree t1 = new BinaryTree(1);
        BinaryTree t2 = new BinaryTree(2);
        BinaryTree t3 = new BinaryTree(3);
        BinaryTree t4 = new BinaryTree(4);
        BinaryTree t5 = new BinaryTree(5);
        BinaryTree t6 = new BinaryTree(6);
        BinaryTree t7 = new BinaryTree(7);
        BinaryTree t8 = new BinaryTree(8);
        BinaryTree t9 = new BinaryTree(9);
        BinaryTree t10 = new BinaryTree(10);
        BinaryTree t11 = new BinaryTree(11);
        BinaryTree t12 = new BinaryTree(12);
        BinaryTree t13 = new BinaryTree(13);
        BinaryTree t14 = new BinaryTree(14);
        BinaryTree t15 = new BinaryTree(15);
        t1.left = t2;
        t1.right = t3;
        t2.left = t4;
        t2.right = t5;
        t3.left = t6;
        t3.right = t7;
        t5.left = t10;
        t5.right = t11;
        t4.left = t8;
        t4.right = t9;
        t6.right = t13;
        t6.left = t12;
        t7.left = t14;
        t7.right = t15;
        t8.left = null;
        t8.right = null;
        t9.left = null;
        t9.right = null;
        t10.left = null;
        t10.right = null;
        t11.left = null;
        t11.right = null;
        t12.left = null;
        t12.right = null;
        t13.left = null;
        t13.right = null;
        t14.left = null;
        t14.right = null;
        t15.left = null;
        t15.right = null;
        zhiprint(t1);
    }
}
6. Test33.java
public class Test33{
    public static boolean arrrySearchTree(int[] num,int start,int end)
    {
        if(num==null|num.length<1||start<0||end<0||start>end)
            return false;
        if(start==end)
            return true;
        int root = num[end];
        int i=start;
        for(;i<end;i++)
        {
            if(num[i]>root)
                break;
        }
        System.out.println(i);
        int j = i;
        for(;j<end;j++)
        {
            if(num[j]<root)
                return false;
        }
        boolean left = true;
        if(i>0)
        left = arrrySearchTree(num,start,i-1);
        boolean right = true;
        if(i<=end-1)
        right = arrrySearchTree(num,i,end-1);
        return (left&&right);
    }
    public static void main(String[] args)
    {
        int[] num = {5,7,6,9,11,10,8};
        System.out.println(arrrySearchTree(num,0,6));
    }
}
7. Test34.java
import java.util.ArrayList;
public class Test34{
    public static class BinaryTree{
        int data;
        BinaryTree left;
        BinaryTree right;
        public BinaryTree(int data)
        {
            this.data = data;
        }
    }
    public static void exceptPathSum(BinaryTree root,int exception) {
        if (root == null)
            return;
        int sum = 0;
        ArrayList<Integer> st = new ArrayList<Integer>();
        exception(root, exception, sum, st);
    }
    public static void exception(BinaryTree root,int exception,int sum, ArrayList st)
    {
        st.add(root.data);
        sum = sum + root.data;
        if(root.left==null&&root.right==null)
        {
            if(sum==exception) {
                System.out.print(st);
                System.out.println();
            }
        }
        if(root.left!=null)
        {
            exception(root.left,exception,sum,st);
        }
        if(root.right!=null)
        {
            exception(root.right,exception,sum,st);
        }
        st.remove(st.size()-1);
    }
    public static void main(String[] args) {
        BinaryTree t1 = new BinaryTree(10);
        BinaryTree t2 = new BinaryTree(5);
        BinaryTree t3 = new BinaryTree(12);
        BinaryTree t4 = new BinaryTree(4);
        BinaryTree t5 = new BinaryTree(7);
        t1.left = t2;
        t1.right = t3;
        t2.left = t4;
        t2.right = t5;
        t3.left = null;
        t3.right = null;
        t4.left = null;
        t4.right = null;
        t5.left = null;
        t5.right = null;
        exceptPathSum(t1,22);
    }
}
8. Test35.java
public class Test35{
    public static class Linklist{
        int data;
        Linklist next;
        Linklist psibling;
        public Linklist(int data)
        {
            this.data = data;
        }
    }
    public static Linklist copyLink(Linklist phead)
    {
        if(phead==null)
        return null;
        Linklist linkedhead = copylink1(phead);
        copypsibling(linkedhead);
        Linklist copyhead  = sperateLink(linkedhead);
        return copyhead;
    }
    public static Linklist copylink1(Linklist phead)
    {
        Linklist pheadtd = phead;
        while(pheadtd!=null) {
            Linklist copynode = new Linklist(pheadtd.data);
            copynode.next = pheadtd.next;
            pheadtd.next = copynode;
            pheadtd = copynode.next;
        }
        return phead;
    }
    public static void copypsibling(Linklist phead)
    {
        Linklist pheadtd2 = phead;
        Linklist copyhead = phead.next;
        while(pheadtd2.psibling!=null)
        {
            copyhead.psibling = pheadtd2.psibling.next;
            pheadtd2 = copyhead.next;
            copyhead = pheadtd2.next;
        }
    }
    public static Linklist sperateLink(Linklist phead)
    {
        Linklist phead3 = phead;
        Linklist copyhead = phead.next;
        Linklist copyhead2  =phead.next;
        while(copyhead2.next!=null)
        {
            phead3.next = copyhead2.next;
            phead3 = phead3.next;
            copyhead2.next = phead3.next;
            copyhead2 = copyhead2.next;
        }
        phead3.next = null;
        copyhead2.next = null;
        return copyhead;
    }
    public static void print(Linklist head)
    {
        if(head==null)
            return;
        Linklist chead = head;
        while(chead!=null)
        {
            System.out.print(chead.data);
            if(chead.psibling!=null)
                System.out.print(chead.psibling.data);
            chead = chead.next;
        }
    }
    public static void main(String[] args)
    {
        Linklist n1 = new Linklist(1);
        Linklist n2 = new Linklist(2);
        Linklist n3 = new Linklist(3);
        Linklist n4 = new Linklist(4);
        Linklist n5 = new Linklist(5);
        n1.next = n2;
        n2.next = n3;
        n3.next = n4;
        n4.next = n5;
        n5.next = null;
        n1.psibling = n3;
        n4.psibling =n2;
        print(n1);

    }
}
9. Test36.java
public class Test36{
    public static class BinaryTree{
        int data;
        BinaryTree left;
        BinaryTree right;
        public BinaryTree(int data){this.data=data;}
    }
    public static BinaryTree treetransferLink(BinaryTree root)
    {
        if(root==null)
            return null;
        BinaryTree[]  bt = new BinaryTree[1];
        converse(root,bt);
        BinaryTree head = bt[0];
        while(head.left!=null)
            head = head.left;
        return head;
    }
    public static void converse(BinaryTree root,BinaryTree[] bt)
    {
        if(root==null)
            return;
        if(root.left!=null)
            converse(root.left,bt);
        root.left = bt[0];
//        if(bt[0]!=null)
//        System.out.println(bt[0].data);
        if(bt[0]!=null)
            bt[0].right = root;
        bt[0] = root;
        if(root.right!=null)
            converse(root,bt);
    }
    public static void main(String[] args)
    {
        BinaryTree t1 = new BinaryTree(10);
        BinaryTree t2 = new BinaryTree(5);
        BinaryTree t3 = new BinaryTree(12);
        BinaryTree t4 = new BinaryTree(4);
        BinaryTree t5 = new BinaryTree(7);
        t1.left = t2;
        t1.right = t3;
        t2.left = t4;
        t2.right = t5;
        t3.left = null;
        t3.right = null;
        t4.left = null;
        t4.right = null;
        t5.left = null;
        t5.right = null;
        BinaryTree head = treetransferLink(t1);
        System.out.println(head.data);
    }
}
10. Test37.java
import java.lang.StringBuilder;
import java.lang.String;
import java.lang.Integer;
public class Test37 {
    public static  int index =0;
    public static class BinaryTree {
        int data;
        BinaryTree left;
        BinaryTree right;

        public BinaryTree(int data) {
            this.data = data;
        }
    }

    public static String serialize(BinaryTree root) {
        if (root == null)
            return null;
        StringBuilder sb = new StringBuilder();
        StringBuilder sb2 =  serialize1(root, sb);
        sb2.deleteCharAt(sb2.length()-1);
        String s = sb2.toString();
        return s;

    }

    public static StringBuilder serialize1(BinaryTree root, StringBuilder sb) {
        if(root==null)
        {sb.append("$").append(",");
            return sb;}
        sb.append(root.data).append(",");
        serialize1(root.left,sb);
        serialize1(root.right,sb);
        return sb;
    }
    public static BinaryTree constract(String s)
    {
        if(s==null||s.length()<1)
            return null;
        String[] arr = s.split(",");
        BinaryTree root = null;
        if(!arr[index].equals("$")&&index<arr.length)
        {
            root = new BinaryTree(Integer.valueOf(arr[index]));
            index++;
            root.left = constract(s);
            root.right = constract(s);
        }
        return root;
    }
    public static void printTree(BinaryTree root)
    {
        if(root!=null)
        {
            System.out.println(root.data);
        }
        printTree(root.left);
        printTree(root.right);
    }
    public static void main(String[] args)
    {
        BinaryTree t1 = new BinaryTree(10);
        BinaryTree t2 = new BinaryTree(5);
        BinaryTree t3 = new BinaryTree(12);
        BinaryTree t4 = new BinaryTree(4);
        BinaryTree t5 = new BinaryTree(7);
        t1.left = t2;
        t1.right = t3;
        t2.left = t4;
        t2.right = t5;
        t3.left = null;
        t3.right = null;
        t4.left = null;
        t4.right = null;
        t5.left = null;
        t5.right = null;
        System.out.println(serialize(t1));
        printTree(constract(serialize(t1)));
    }
}
11. Test38.java
public class Test38{
    public static void permutition(char[] arr)
    {
        if(arr==null|arr.length<1)
            return;
        permutition(arr,0);
    }
    public static void permutition(char[] arr,int begin)
    {
        if(begin==arr.length-1)
            System.out.println(new String(arr));
        else {
            for (int i = begin; i < arr.length; i++) {
                char temp = arr[i];
                arr[i] = arr[begin];
                arr[begin] = temp;
                permutition(arr, begin + 1);
                temp = arr[i];
                arr[i] = arr[begin];
                arr[begin] = temp;
            }
        }
    }
    public static void main(String[] args)
    {
        char[] arr = {'a','b','c'};
        permutition(arr);
    }
}
12. Test39.java
public class Test39{
    public static int morehalfnum(int[] arr)
    {
        if(arr==null||arr.length<1)
            return -1;
        int count = 1;
        int temp = arr[0];
        for(int i=1;i< arr.length;i++)
        {
            if(arr[i]==temp)
                count++;
            else
                count--;
            if(count==0) {
                temp = arr[i];
                count = 1;

            }
        }
        return temp;
    }
//    public static int partition(int[] arr,int start,int end)
//    {
//        if(arr==null||arr.length<1||start<0||end<0||start>end)
//            return -1;
//        int i=start;
//        int j =end;
//        int temp = arr[i];
//        if(i<j)
//        {
//            while(arr[j]>temp&&i<j) j--;
//            arr[i] = arr[j];
//            i++;
//        }
//        if(i<j)
//        {
//            while(arr[i]<=temp&&i<j)i++;
//            arr[j] = arr[i];
//            j--;
//        }
//        arr[i] = temp;
//        return i;
//    }
//    public static int morehalfnum(int[] arr)
//    {
//        if(arr==null||arr.length<1)
//            return -1;
//        int start = 0;
//        int end = arr.length-1;
//        int middle = (start+end)/2;
//        int result = 0;
//        result = partition(arr,start,end);
//        while(result<middle) {
//            start = result+1;
//            result = partition(arr,start,end);
//        }
//        while(result>middle)
//        {
//            end = result-1;
//            result = partition(arr,start,end);
//        }
//        return arr[result];
//    }
    //必须要计算一下出现在数组夹中间位置上面的数字出现的次数是否大于数组长度的一半。
//    public static boolean checkishalf(int[] arr,int number)
//    {
//        int count =0;
//        for(int i=0;i<arr.length;i++)
//        {
//            if(arr[i]==number)
//                count++;
//        }
//        if(count*2>arr.length)
//            return true;
//        else
//            return false;
//    }
    public static void main(String[] args)
    {
        int[] arr = {1,2,3,5,2,5,5,5,5};
        System.out.println(morehalfnum(arr));
    }
}
sfiayui123
关注
专栏目录
leetcodeoj调试-LeetCode-Exercise:LeetCode刷题&剑指offer第二版题解(67题已完成)&部分数据结构的实
07-01
leetcode oj 调试 LeetCode练习 ...CaptureOffer：剑指offer第二版68题题解和部分面试模拟题题解，OJ平台为牛客网 Interview，AlibabaInterview：面试题题解 java/utils:几种算法的实现 java/inteview:
剑指offer题解(C++).docx
07-17
《剑指Offer题解》是针对面试准备的一份宝贵资源，由Sidney.Tan精心整理，结合了牛客网上的讨论、《剑指Offer》书中的解法以及个人的编程实践，提供了全面的代码和思路解析。这份文档按照牛客网上的题目顺序，覆盖了...
【C++题解】剑指offer第二版，面试必备专栏
Newin2020的博客
08-11 1515
📚专栏目标：剑指offer系列题解📣专栏定位：为找工作的小伙伴整理常考算法题解，祝大家都能成功上岸！🎏唠叨唠叨：在这个专栏里，我会整理所有剑指 offer 第二版的题解，这里面的思路也参考了各个大佬。一方面我希望通过这个专栏加深我对于剑指 offer 题目的理解，另一方面也想将所有题目整合在一起方便大家参考。
剑指offer第二版题解系列（二）
tian的博客
08-22 160
写在开头：正值毕业生求职期间，翻一翻剑指offer的书籍，将其中的题目进行分析和代码编写，并将代码整理到csdn博客上，如果有错误，敬请指出！（此系列不提供题目原文，请参考书籍《剑指offer第二版》即可。） __ Test10 - Test19系列 1. Test10.java 1. Test10.java 1. Test10.java 1. Test10.java ...
剑指offer第二版题解系列（五）
tian的博客
08-22 201
写在开头：正值毕业生求职期间，翻一翻剑指offer的书籍，将其中的题目进行分析和代码编写，并将代码整理到csdn博客上，如果有错误，敬请指出！（此系列不提供题目原文，请参考书籍《剑指offer第二版》即可。） Test40 - Test49系列 1. Test40.java 两种解法 【解法一】 利用39给出的方法，使用partition函数计算出索引值为K-1的点，其左边的数包...
剑指offer最新版_剑指offer第二版题解(详细版)
weixin_39597323的博客
12-19 714
技术交流QQ群:1027579432，欢迎你的加入！欢迎关注我的微信公众号：CurryCoder的程序人生1.滑动窗口的最大值(剑指offer原59题)解题思路：其实是一个队列的问题，用一个队列去维护当前窗口中的所有元素；首先将超出窗口中的队头元素先删掉，然后将新的元素插入当前窗口中，插入时要判断新插入的元素与队尾元素的大小，如果队尾元素较小，则先删除队尾元素再插入。#include #inclu...
剑指offer第二版题解系列（七）
tian的博客
08-22 174
写在开头：正值毕业生求职期间，翻一翻剑指offer的书籍，将其中的题目进行分析和代码编写，并将代码整理到csdn博客上，如果有错误，敬请指出！（此系列不提供题目原文，请参考书籍《剑指offer第二版》即可。） Test60 - Test66系列 1. Test61.java import java.util.Arrays; public class Test61{ pub...
LeetCode《剑指offer》第二版 Java版全系列题解
m0_51277527的博客
08-31 359
本系列记录了最新版 《剑指Offer》 的题解过程与代码，这里用Java代码复现并优化，并包含解题分析。希望各位能够点赞，收藏！关注我！ 每日更新！
剑指offer第二版题解系列（三）
tian的博客
08-22 154
写在开头：正值毕业生求职期间，翻一翻剑指offer的书籍，将其中的题目进行分析和代码编写，并将代码整理到csdn博客上，如果有错误，敬请指出！（此系列不提供题目原文，请参考书籍《剑指offer第二版》即可。） __ Test20 - Test29系列 1. Test20.java public class Test20{ public static boolean isnu...
剑指offer第二版题解系列（一）
tian的博客
08-22 831
写在开头：正值毕业生求职期间，翻一翻剑指offer的书籍，将其中的题目进行分析和代码编写，并将代码整理到csdn博客上，如果有错误，敬请指出！（此系列不提供题目原文，请参考书籍《剑指offer第二版》即可。） __ Test1 - Test10系列 1. Test3_1.java public class Test3{ public static int dulpli...
剑指offer第二版题解系列（六）
tian的博客
08-22 197
写在开头：正值毕业生求职期间，翻一翻剑指offer的书籍，将其中的题目进行分析和代码编写，并将代码整理到csdn博客上，如果有错误，敬请指出！（此系列不提供题目原文，请参考书籍《剑指offer第二版》即可。） Test50 - Test59系列 1. Test50.java import java.util.HashMap; public class Test50{ pu...
剑指 offer 题解.pdf
09-13
"剑指 offer 题解.pdf" 本资源是一个关于剑指 Offer 题解的 PDF 文件，包含了多种编程题的解决方案。下面是对标题、描述、标签和部分内容的解释和知识点总结。 标题：剑指 offer 题解 该标题表明了该资源的主要...
基于java的校园美食交流系统设计与实现.docx
09-19
基于java的校园美食交流系统设计与实现.docx
#_ssm_126_mysql_实习支教中小学学校信息管理系统_.zip
09-19
均包含代码，文章，部分项目包含ppt
基于python的酒店评论中文情感分析系统源码+设计文档+数据集.zip
最新发布
09-19
基于python的酒店评论中文情感分析系统源码+设计文档+数据集.zip基于python的酒店评论中文情感分析系统源码+设计文档+数据集.zip基于python的酒店评论中文情感分析系统源码+设计文档+数据集.zip 个人大四的毕业设计、课程设计、作业、经导师指导并认可通过的高分设计项目，评审平均分达96.5分。主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者，也可作为课程设计、期末大作业。 [资源说明] 不懂运行，下载完可以私聊问，可远程教学 该资源内项目源码是个人的毕设或者课设、作业，代码都测试ok，都是运行成功后才上传资源，答辩评审平均分达到96.5分，放心下载使用！ 1、该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的，请放心下载使用！ 2、本项目适合计算机相关专业(如计科、人工智能、通信工程、自动化、电子信息等)的在校学生、老师或者企业员工下载学习，也适合小白学习进阶，当然也可作为毕设项目、课程设计、作业、项目初期立项演示等。 3、如果基础还行，也可在此代码基础上进行修改，以实现其他功能，也可用于毕设、课设、作业等。 下载后请首先打开README.md文件（如有），供学习参考。
ASP.NET公交车管理系统的实现与设计(源代码+论文).zip
09-19
1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 、4下载使用后，可先查看README.md或论文文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。 5、资源来自互联网采集，如有侵权，私聊博主删除。 6、可私信博主看论文后选择购买源代码。 1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合；、下载 4使用后，可先查看README.md或论文文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。 5、资源来自互联网采集，如有侵权，私聊博主删除。 6、可私信博主看论文后选择购买源代码。 1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合；、 4下载使用后，可先查看README.md或论文文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。 5、资源来自互联网采集，如有侵权，私聊博主删除。 6、可私信博主看论文后选择购买源代码。
ASP基于WEB楼宇专业网站毕业设计(源代码+论文).zip
09-19
1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看README.md或论文文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。 5、资源来自互联网采集，如有侵权，私聊博主删除。 6、可私信博主看论文后选择购买源代码。 1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看README.m或d论文文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。 5、资源来自互联网采集，如有侵权，私聊博主删除。 6、可私信博主看论文后选择购买源代码。 、1资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看README.md或论文文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。 5、资源来自互联网采集，如有侵权，私聊博主删除。 6、可私信博主看论文后选择购买源代码。
django基于协同过滤算法的小说推荐系统 -论文.zip
09-19
基于Django框架开发的协同过滤算法小说推荐系统是一种利用用户行为数据来提供个性化小说推荐的应用。该系统通过分析用户的历史阅读记录、评分和反馈，发现用户之间的相似性或小说之间的相似性，进而为用户推荐可能感兴趣的小说。以下是该系统可能包含的关键特性： 1. **用户账户管理**：允许用户创建账户、登录和编辑个人信息，同时跟踪用户的阅读历史和评分。 2. **小说数据库**：构建一个包含大量小说信息的数据库，每本小说都有详细的元数据，如作者、出版年份、流派、标签等。 3. **协同过滤引擎**：实现协同过滤算法，包括用户-用户协同过滤和项目-项目协同过滤，以发现相似用户或相似小说。 4. **推荐生成**：根据协同过滤引擎的结果，生成个性化的小说推荐列表，并提供给用户。 5. **评分系统**：允许用户对小说进行评分，这些评分数据将用于训练推荐算法，提高推荐的准确性。 6. **用户界面**：设计直观、易用的用户界面，使用户能够轻松浏览推荐的小说、查看详情和进行评分。 7. **搜索和筛选功能**：提供强大的搜索功能，允许用户根据标题、作者或流派等关键词搜索小说，并提供筛选
剑指Offer C++题解：二维查找与替换空格算法详解
剑指OFFER题解(C++)文档是一份全面的编程题解资料，针对C++语言，特别适合那些正在刷《剑指Offer》这本书中的题目或者希望提升算法能力的学习者。这份资源由作者Sidney.Tan整理，包含了牛客网讨论区、原著书中的代码...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值