算法学习（1）冒泡 插入归并 链表翻转

最新推荐文章于 2020-08-07 17:39:29 发布
最新推荐文章于 2020-08-07 17:39:29 发布
阅读量160 收藏
点赞数 1
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41888669/article/details/82595980
版权

 算法学习笔记

 

冒泡排序  时间复杂度O（n2）

public class BubbleSort {
    public static void main(String[] args) {
        int[] array={7,8,9,4,5,6,2,1,3};
        sort(array);
        for (int i = 0; i <array.length ; i++) {
            System.out.print(array[i]+",");
        }

    }
    public static void sort(int[] array){
        for (int i = 0; i <array.length-1 ; i++) {
            for (int j = 0; j <array.length-1-i ; j++) {
                if (array[j]>array[j+1]){
                    int temp=array[j+1];
                    array[j+1]=array[j];
                    array[j]=temp;
                }//if
            } // forj
        } //fori
    }  //sort

 //改进  原理记录最后一位冒泡交换的下标，
    public static void sort2(int[] array){
        int m=array.length;
            while (m > 1) {
                int lastExchangeIndex = 1;
                for (int j = 0; j < array.length-1; j++) {
                    if (array[j] > array[j + 1]) {
                        swap(array, j, j + 1);
                        lastExchangeIndex = j;
                    }else {
                        m = lastExchangeIndex;  //只要最后一位交换的下标不是0，就一直循环
                    }
                } // forj
            } //while

        }  //sort

}

插入排序  时间复杂度 O（n2）

public class InsertSort {
    public static void main(String[] args) {
        int[] arr = {1,4,5,8,6,7,8,21,33};
        insertSort(arr);
        for (int ele:arr) {
            System.out.println(ele);
        }
    }
    //插入排序
    public  static void insertSort(int[] arr){
        for (int j=1;j<arr.length;j++){
            int key =arr[j];
            int i=j-1;
            while(i>-1&&arr[i]>key){
                arr[i+1]=arr[i];
                i=i-1;
            }
            arr[i+1]=key;
        }
    }
}

选择排序

public static void  select_sort(int[] arr){
        int n=arr.length;
        for(int i=0;i<n;i++){
        int minPosition=sacnForMin(arr,i,n-1);
        swap(arr,arr[i],arr[minPosition]);
        }
    }

    private static void swap(int[] arr, int i, int j) {
        int temp=arr[j];
        arr[j]=arr[i];
        arr[i]=temp;
    }
    private static int sacnForMin(int[] arr, int i, int i1) {
        int min=arr[i];
        int position=i;
        for (int j = i; j < i1; j++) {
            if (arr[j]<min){
                min=arr[j];
                position=j;
            }
        }
        return position;
    }

归并排序 ：　归并排序是稳定排序，它也是一种十分高效的排序，能利用完全二叉树特性的排序一般性能都不会太差。java中Arrays.sort()采用了一种名为TimSort的排序算法，就是归并排序的优化版本。每次合并操作的平均时间复杂度为O(n)，而完全二叉树的深度为|log2n|。总的平均时间复杂度为O(nlogn)。而且，归并排序的最好，最坏，平均时间复杂度均为O(nlogn)。


import java.util.Arrays;
public class MergeSort {
    public static void main(String []args){
        int []arr = {9,8,7,6,5,4,3,2,1};
        sort(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void sort(int []arr){
        int []temp = new int[arr.length];//在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
         mergeSort(arr,0,arr.length-1,temp);
    }
    private static void  mergeSort(int[] arr,int left,int right,int []temp){
        if(left<right){
            int mid = (left+right)/2;
            mergeSort(arr,left,mid,temp);//左边归并排序，使得左子序列有序
            mergeSort(arr,mid+1,right,temp);//右边归并排序，使得右子序列有序
            merge(arr,left,mid,right,temp);//将两个有序子数组合并操作
        }
    }
    private static void merge(int[] arr,int left,int mid,int right,int[] temp){
        int i = left;//左序列指针
        int j = mid+1;//右序列指针
        int t = 0;//临时数组指针
        while (i<=mid && j<=right){
            if(arr[i]<=arr[j]){
                temp[t++] = arr[i++];
            }else {
                temp[t++] = arr[j++];
            }
        }
        while(i<=mid){//将左边剩余元素填充进temp中
            temp[t++] = arr[i++];
        }
        while(j<=right){//将右序列剩余元素填充进temp中
            temp[t++] = arr[j++];
        }
        t = 0;
        //将temp中的元素全部拷贝到原数组中
        while(left <= right){
            arr[left++] = temp[t++];
        }
    }
}

归并排序问题延伸

利用归并排序求一个数组中的逆序对

public class MergeSort {
    private static int ORDER_COUNT=0;
    public static void main(String []args) throws InterruptedException {
        int []arr = {9,8,7,6,5,4,3,2,1};
        sort(arr);
        System.out.println(Arrays.toString(arr));
        System.out.println(ORDER_COUNT);
        int [] arr2={2,1,5,3,2};
        Thread.sleep(1000);

        ORDER_COUNT=0;
        sort(arr2);
        System.out.println(Arrays.toString(arr2));
        System.out.println(ORDER_COUNT);
    }
    public static void sort(int []arr){
        int []temp = new int[arr.length];//在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
        mergeSort(arr,0,arr.length-1,temp);
    }
    private static void  mergeSort(int[] arr,int left,int right,int []temp){
        if(left<right){
            int mid = (left+right)/2;
            mergeSort(arr,left,mid,temp);//左边归并排序，使得左子序列有序
            mergeSort(arr,mid+1,right,temp);//右边归并排序，使得右子序列有序
            merge(arr,left,mid,right,temp);//将两个有序子数组合并操作
        }
    }
    private static void merge(int[] arr,int left,int mid,int right,int[] temp){
        int i = left;//左序列指针
        int j = mid+1;//右序列指针
        int t = 0;//临时数组指针
        //求解归逆序对中的数量只需要改进一下while循环方法
        while (i<=mid && j<=right){
            if(arr[i]<=arr[j]){  //此时没有逆序对
                temp[t++] = arr[i++];
            }else {  //否则产生了逆序对，我们需要对逆序对做出统计
                temp[t++] = arr[j++];
                ORDER_COUNT+=mid-i+1;//+1的作用是将0的序列变为按下标的序列,
                // mid+1是左边的总数，i是第一个比右边数值大的坐标
            }
        }
        while(i<=mid){//将左边剩余元素填充进temp中
            temp[t++] = arr[i++];
        }
        while(j<=right){//将右序列剩余元素填充进temp中
            temp[t++] = arr[j++];
        }
        t = 0;
        //将temp中的元素全部拷贝到原数组中
        while(left <= right){
            arr[left++] = temp[t++];
        }
    }
}

 

快速排序 

//快速排序
  // 分而治之  先选一个枢纽  左边元素全部小于枢纽  右边元素全部大于枢纽
//1.第一步选取主元   取头中尾的中位数  例如8,12,3的中位数就是8

  //选取主元
    public static void Median(int[] arr, int left, int right) {
        int center = (left + right) / 2;  // 一定是左中右的顺序  left<center<right
        if (arr[left] > arr[center]) swap(arr, left, center);

        if (arr[left] > arr[right]) swap(arr, left, right);

        if (arr[center] > arr[right]) swap(arr, center, right);

        swap(arr, right-1, center);   //之后只需考虑arr[left+1]....arr[right-2]


    }

    //子集划分
    public static void quickSoort(int[] arr, int left, int right) {
        if (left < right) {
            Median(arr, left, right);
            int pivot = right - 1;
            int i = left;  //左指针
            int j = right - 1;  //右指针
            while (true){
                while (arr[++i] < arr[pivot]) { }   //i=left+1
                while (j > left && arr[--j] > arr[pivot]) { }    // right-2
                if (i < j) {
                    swap(arr, i, j);
                } else {
                    break;
                }
            }
            if (i < right) {
                swap(arr, i, right - 1);
            }
            quickSoort(arr, left, i - 1);
            quickSoort(arr, i + 1, right);
    }//if

    }


    public static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

表排序v ：待排元素不是一个简单的整数，待排元素是一个类，一个对象，你在排序的过程中不需要移动原始数据

 物理排序： n个数字的排列由若干个独立的环组成


桶排序：

基数排序 ： 次位优先

多关键字排序:

vivo的面试题 

import java.util.Arrays;
/**
 * 比较两个字符串大小规则如下：
 * 1.如果两个字符串长度不相同，则短字符串比长字符串小
 * 2.如果两个字符串长度相同，则按照A~ Z,a~z,0~9的大小关系排序
 */
public class StringSort {
    public static void main(String[] args) {
        String[] strs = {"a", "Abc", "123", "1", "abc", "CBD", "abcd", "a"};
        sort(strs);
        for (String str:strs) {
            System.out.print(str+"\t");
        }
    }
    /**
     * 比较a和b的大小
     * @param a
     * @param b
     * @return
     */



 public static boolean less2(String a, String b){
        if (a.length()<b.length()) return true;
        else if (a.length()==b.length()){
            for (int i = 0; i <a.length() ; i++) {
                if (a.charAt(i)>='0'&&a.charAt(i)<='9') {
                    if (b.charAt(i) >= '0' && b.charAt(i) <= '9') 
                     return b.charAt(i)>a.charAt(i)?true:false;
                    if (b.charAt(i)>='A'&&b.charAt(i)<='z') return false;
                }else {
                    if (b.charAt(i) >= '0' && b.charAt(i) <= '9') return true;
                    else return b.charAt(i)>a.charAt(i)?true:false;
                }
            }
        }
        return false;
    }





    public static boolean less(String a,String b){
        if (a.length()<b.length()) {
            return true;
        }else if (a.length()>b.length()) {
            return false;
        }else{
            for (int i = 0;i<a.length();i++){
                if(a.charAt(i)>=48&&a.charAt(i)<=57){
                    if(b.charAt(i)>=48&&b.charAt(i)<=57){
                        return a.charAt(i)<b.charAt(i);
                    }else{
                        return false;
                    }
                }else{
                    if(b.charAt(i)>=48&&b.charAt(i)<=57){
                        return true;
                    }else{
                        return (int)a.charAt(i)<(int)b.charAt(i);
                    }
                }
            }
            return true;
        }
    }
    /**
     * 以下为归并排序模板
     * @param arr
     */
    public static void sort(String []arr){
        String []temp = new String[arr.length];//在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
        mergeSort(arr,0,arr.length-1,temp);
    }
    private static void  mergeSort(String[] arr,int left,int right,String []temp){
        if(left<right){
            int mid = (left+right)/2;
            mergeSort(arr,left,mid,temp);//左边归并排序，使得左子序列有序
            mergeSort(arr,mid+1,right,temp);//右边归并排序，使得右子序列有序
            merge(arr,left,mid,right,temp);//将两个有序子数组合并操作
        }
    }
    private static void merge(String[] arr,int left,int mid,int right,String[] temp){
        int i = left;//左序列指针
        int j = mid+1;//右序列指针
        int t = 0;//临时数组指针
        while (i<=mid && j<=right){
            if(less(arr[i],arr[j])){
                temp[t++] = arr[i++];
            }else {
                temp[t++] = arr[j++];
            }
        }
        while(i<=mid){//将左边剩余元素填充进temp中
            temp[t++] = arr[i++];
        }
        while(j<=right){//将右序列剩余元素填充进temp中
            temp[t++] = arr[j++];
        }
        t = 0;
        //将temp中的元素全部拷贝到原数组中
        while(left <= right){
            arr[left++] = temp[t++];
        }
    }
}

 

 

 

牛课练习  反转数组

题目描述

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

 

输入一个链表，反转链表后，输出新链表的表头。

//反转数组
 public ListNode ReverseList(ListNode head){
     if(head==null){
        return null;
 }
     ListNode next=null;
     listNode pre=null;
      while(head!=null){
        next=head.next;
        head.next=pre;
        pre=head;
        head=next;
    }
        retuen pre;
}

衍生  局部链表反转 

 

public class ReverseList {

    public static void main(String[] args) {
        ListNode l1=new ListNode(1);
        ListNode l2=new ListNode(2);
        ListNode l3=new ListNode(3);
        ListNode l4=new ListNode(4);
        ListNode l5=new ListNode(5);
        ListNode l6=new ListNode(6);
        ListNode l7=new ListNode(7);
        ListNode l8=new ListNode(8);
        l1.next=l2;
        l2.next=l3;
        l3.next=l4;
        l4.next=l5;
        l5.next=l6;
        l6.next=l7;
        l7.next=l8;
        ListNode next=l1;
        for (int i = 0; i <8 ; i++) {
            System.out.print(next.val);
            next=next.next;
        }
        System.out.println();

//        ListNode newHead=reverseList(l1);
//        for (int i = 0; i <8 ; i++) {
//            System.out.println(newHead.val);
//            newHead=newHead.next;
//        }

        reversePartOfList(l1,l1,l8);
        ListNode frist=l8;
        for (int i = 0; i <8 ; i++) {
            System.out.print(frist.val);
            frist=frist.next;
        }
    }

    //下面开始测试局部链表翻转  123456789----123 987654    123456789     123 654 789
     public static void reversePartOfList(ListNode node,ListNode begin,ListNode end){

         ListNode p1=new ListNode(0);
         p1.next=node;
         ListNode p2=new ListNode(9);
         ListNode temp0=p1;
         while(temp0.next!=null){
             temp0=temp0.next;
         } temp0.next=p2;   //将9 和 尾部最后一个节点相连



         ListNode temp1=p1;
        while (temp1.next!=begin){
             temp1=temp1.next;
        } p1=temp1;//哨兵1  记录断开的前一个节点
         System.out.println(p1.val);


         ListNode temp2=p1;
         while (temp2.next!=null&&temp2.next!=end){
             temp2=temp2.next;
         }
         p2=temp2.next.next;//哨兵  记录断开的后一个节点
         System.out.println(p2.val);

         end.next=null;
         p1.next=null;
         ListNode partBegin=reverseList(begin);

         ListNode temp3=partBegin;
         while (temp3.next!=null){
             temp3=temp3.next;
         }
         ListNode partEnd=temp3;
         System.out.println(partBegin.val+"   "+partEnd.val);
         p1.next=partBegin;
         partEnd.next=p2;


     }

    //题目描述
    //输入一个链表，反转链表后，局部翻转链表
    public static ListNode reverseList(ListNode head) {
        if (head==null){
            return null;
        }
        ListNode pre=null;
        ListNode next=null;
        while(head!=null){
            next=head.next;
            head.next=pre;
            pre=head;
            head=next;
        }
            return pre;
    }
}

 代码较为冗余   经过多个测试代码 是正确的   如果有问题 还望指出。

 

 头插法局部链表反转

逻辑  四个指针 head  pre  cur next     head为哨兵不动  pre为尾节点值不变位置在移动   每次就是将cur插在head后面，将pre与next相连，举例  1 2 3 4        翻转23      就是 1=head   2=pre   3=cur  4=next  将3插在2前 完成头插

                                             翻转234    就是在上一步基础上      将4插在 32前面 1后面   就完成了翻转

核心代码

//找到   head pre cur 三个节点   构造next节点
next=cur.next;
pre.next=head.next;
head.next=cur;
pre.next=next;
cur=next;

0 1 2 3 4 5 6 7 8 
第i次0    next值3   cur值2   head值0   pre值1    
第i次1    next值4   cur值3   head值0   pre值1   
第i次2    next值5   cur值4   head值0   pre值1   
第i次3    next值6   cur值5   head值0   pre值1   
第i次4    next值7   cur值6   head值0   pre值1   
第i次5    next值8   cur值7   head值0   pre值1   
0 7 6 5 4 3 2 1 8 

public class ReverseListByHead {
    public static void main(String[] args) {
        ListNode head=new ListNode();
        ListNode l1=new ListNode(1);
        ListNode l2=new ListNode(2);
        ListNode l3=new ListNode(3);
        ListNode l4=new ListNode(4);
        ListNode l5=new ListNode(5);
        ListNode l6=new ListNode(6);
        ListNode l7=new ListNode(7);
        ListNode l8=new ListNode(8);
        head.next=l1;
        l1.next=l2;
        l2.next=l3;
        l3.next=l4;
        l4.next=l5;
        l5.next=l6;
        l6.next=l7;
        l7.next=l8;
        print(head);
        reverseByHead(head,1,7);
        print(head);
    }



    public static void print(ListNode head) {
        while (head != null) {
            System.out.print(head.val + " ");
            head = head.next;
        }
        System.out.println();
    }
    /**
     * 翻转链表的从结点m到结点n的部分
     *
     * @param head 头节点
     * @param from 翻转的开始位置
     * @param to 翻转的结束位置
     * @return 翻转后的新链表
    12345678        1 234567 8    1 765432 8
    初始化的Head  头节点为空
     */
    public static void reverseByHead(ListNode head, int from, int to) {
        if(from>to)return;
        ListNode cur=head.next;
        int i;
        for ( i = 0; i <from-1 ; i++) {  //找到断开的前一个节点
            head=cur;    //将前一个节点 标记为 head
            cur=cur.next;    //
        }
        ListNode pre=cur;   //反转的第一个节点即使翻转后的最后一个节点
        cur=cur.next;
        to--;              //必须减减  否则会数组越界
        ListNode next=null;
        for (;i<to;i++){
            next=cur.next;
            cur.next=head.next; //  1234 5678    1=head    2= pre    3=cur    4=next       3.next=(1.next)2    3->2
            head.next=cur;       // 1->3->2
            pre.next=next;        //1->3->2->4 5678
            System.out.println("第i次"+i+ "    "+"next值"+next.val+"   "+"cur值"+cur.val+"   "+"head值"+head.val+"   "+"pre值"+pre.val+"   ");
            cur=next;           //推火车   13245678        1=head   3=head.next  2=pre   4=cur   5=next
        }

    }
}

 

 

 

飞飞学Java
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
JavaScript实现链表插入排序和链表归并排序
10-21
主要介绍了JavaScript实现链表插入排序和链表归并排序,较为详细的分析了插入排序和归并排序,对于学习JavaScript数据结构具有一定参考借鉴价值,需要的朋友可以参考下。
链表必学算法（三）：归并法
12-14
/*归并法：用于合并两个链表*/ /* * SCs in different cases * author: Whywait */ typedef struct node { Elemtype data; struct node* next; } Lnode; /*case ONE*/ Lnode* merge1(Linklist& LA, Linklist& LB) ...
ASCII码 or 正则表达式 匹配数字
qq_31217363的博客
08-07 1614
1、字符串匹配为数字： if(str.charAt(i)>=48 && str.charAt(i)<=57){ str2+=str.charAt(i); } 2、用正则表达式 public static boolean isNumericzidai(String str) { Pattern pattern = Pattern.compile("-?[0-9]+\\.?[0-9]*"); Matcher isNum = pattern.matcher(str); if
[LeetCode]初级算法-字符串-字符串转整数（atoi）
AntioniaMao的博客
07-25 270
标题：字符串转整数（atoi） 实现 atoi，将字符串转为整数。 在找到第一个非空字符之前，需要移除掉字符串中的空格字符。如果第一个非空字符是正号或负号，选取该符号，并将其与后面尽可能多的连续的数字组合起来，这部分字符即为整数的值。如果第一个非空字符是数字，则直接将其与之后连续的数字字符组合起来，形成整数。 字符串可以在形成整数的字符后面包括多余的字符，这些字符可以被忽略，它们对于函数没有...
排序算法
huanchengdao的博客
04-30 196
package com.example.lib.sort; /** * Created by mengjk on 18-4-28. */ public class Sort { public static void main(String[] args){ int[] array={7,12,1,6,3,10,8,26,5,3,11}; maop...
排序（三）归并排序
weixin_30633405的博客
01-11 57
参考文档 https://www.cnblogs.com/chengxiao/p/6194356.html 原理： 归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。即...
算法学习：双向链表的创建和读取
09-20
算法学习：双向链表的创建和读取
判断链表是否相交的几种算法1
08-03
可以看到如果把h1链表的尾节点的next指针指向h2链表的第一个节点，那么可以看到如果h1和h2相交，则h2变成了一个循环单链表，因此只需判断h2是否为循环链表
arithmetic java算法冒泡排序、二叉树、数组、链表、队列学习简单示例
07-31
arithmetic java算法冒泡排序、二叉树、数组、链表、队列学习简单示例 private static void mpSoft(String [] data) { for (int i = 0; i < data.length - 1; i++) { System.out.println(Arrays.toString(data)); ...
node-v9.6.0-x86.msi
04-29
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
Python基于机器学习的分布式系统故障诊断系统源代码，分布式系统的故障数据进行分析，设计故障诊断模型，高效地分析并识别故障类别
04-29
基于技术手段（包括但不限于机器学习、深度学习等技术）对分布式系统的故障数据进行分析，设计故障诊断模型，高效地分析并识别故障类别，实现分布式系统故障运维的智能化，快速恢复故障的同时大大降低分布式系统运维工作的难度，减少运维对人力资源的消耗。在分布式系统中某个节点发生故障时，故障会沿着分布式系统的拓扑结构进行传播，造成自身节点及其邻接节点相关的KPI指标和发生大量日志异常
JavaScript前端开发的核心语言前端开发的核心语言
最新发布
04-29
javascript 当今互联网时代，JavaScript已经成为了前端开发的核心语言它是一种高级程序设计语言，通常用于网页的交互和动态效果的实现。JavaScript的灵活性以及广泛的使用使得它变得异常重要，能够为用户带来更好的用户体验。 JavaScript的特点之一是它的轻量级，它可以在网页中运行无需单独的编译或下载。这意味着网页可以更快地加载并且用户无需安装额外的软件才能运行网页上的JavaScript代码。此外，与HTML和CSS紧密结合，可以直接在HTML文档中嵌入，使得网页的开发变得非常便捷。 JavaScript具有动态性，它可以在浏览器中实时修改页面内容和样。它可以通过操作DOM（文档对象模型来动态地修改网页的结构和布局，并且可以根据用户的行为实时地响应各种事件，如点击、标悬停、滚动等。这使得开发者可以轻松地为网页添加交互性和动态效果，提供更好的用户体验。 JavaScript也是一种面向对象的语言。它支持对象、类、继承、多态等面向对象编程的概念，使得代码结构更加清晰和可维护。开发者可以创建自定义的对象和方法，对功能进行封装和复用，提高代码的可读性和可维护性。
四则运算自动生成程序安装包
04-29
四则运算自动生成程序安装包
基于Linux的私有文件服务器(网盘).zip
04-29
基于Linux的私有文件服务器(网盘)
源代码-access 管理 系统 API 文件.zip
04-29
源代码-access 管理 系统 API 文件.zip
海康机器人智能读码器工业协议操作手册V1.0.2.pdf
04-29
海康机器人智能读码器工业协议操作手册V1.0.2.pdf
256ssm-mysql-jsp 在线捐赠系统.zip（可运行源码+数据库文件+文档）
04-29
根据需求，确定系统采用JSP技术，JAVA作为编程语言，MySQL作为数据库。整个系统要操作方便、易于维护、灵活实用。主要实现了系统用户管理、注册用户管理、信息发布管理、医疗物品分类管理、项目信息管理、捐赠项目管理、志愿者申请管理、个人求助管理、个人捐赠统计、系统管理等功能。 前台用户模块包括： 1. 首页：网站打开的第一个页面，显示网站的最新信息。 2. 用户注册/登录、3. 新闻资讯、4. 暖心故事、5. 我要求助、6. 我要捐赠、7. 我们的项目、8. 志愿者中心：实现志愿者中心的列表显示、9. 系统简介、10. 在线留言、11. 用户后台 后台管理员模块包括： 1. 系统用户管理、2. 注册用户管理、3. 信息发布管理、4. 医疗物品分类管理、5. 项目信息管理、6. 捐赠项目管理、7. 志愿者申请管理、8. 个人求助管理：管理员可以设置个人求助审核状态，可以删除个人求助审核信息。 9. 个人捐赠统计：管理员可以查看个人捐赠统计信息。 10. 系统管理：管理员可以对留言板信息进行查看、回复或删除 关键词：医药捐赠系统；JSP;MySQL
系统性文献综述的撰写（Systematic Review）-范文2.pdf
04-29
参考范文：Findings on Teaching Machine Learning inHigh School: A Ten -Year SystematicLiterature Review 用于学习研究，侵权请联系本人删除
设计一个算法实现链表翻转
05-22
链表翻转是一个经典的算法问题，可以使用迭代或递归两种方法来实现。这里我提供一种迭代的实现方法，具体步骤如下： 1. 定义三个指针 prev、curr 和 next，初始时 prev 和 curr 都指向 null，next 指向链表的第一个...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值