数据结构与算法的练习日记

已于 2024-02-29 17:07:52 修改
阅读量139 收藏 1
点赞数 6
分类专栏： 算法基础 文章标签： java 算法
于 2024-02-17 03:30:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zkj000000/article/details/135756779
版权

数据结构与算法的练习日记

文章目录

前言:

  1. 1-3
  2. 4-

一、Leetcode

1.leetcode 24 两两交换链表中的节点

题目：给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

/**
思路：
*/
class Solution {
    public ListNode swapPairs(ListNode head) {
       if(head==null||head.next==null){
           return head;

       }
       ListNode dummyHead=new ListNode(0);
       dummyHead.next=head;
       ListNode temp=dummyHead;
       while(temp.next!=null && temp.next.next!=null){//能创建出着两个新节点
           ListNode node1=temp.next;
            ListNode node2=temp.next.next;
            temp.next=node2;
            node1.next=node2.next;
            node2.next=node1;
            temp=node1;

       }
       return dummyHead.next;

    }
}

2.leetcode 283 移动零

题目：给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

  • 开始的错误解法：
  • 在这里插入图片描述
class Solution {
    public void moveZeroes(int[] nums) {
        int j=nums.length-1;
        int i=0;
        while(i<j){//双指针
            while(nums[j]==0){
                j--;
            }
            if(nums[i]==0){
                int temp=nums[i];
                nums[i] = nums[j];
                nums[j] = temp;
                j--;
            }
             i++;
        }
    }
}
  • 正确的解法：

class Solution {
    public void moveZeroes(int[] nums) {
        int n = nums.length, left = 0, right = 0;
        while (right < n) {
            if (nums[right] != 0) {//如果右指针不是0；左指针的左边都是非0的；
                swap(nums, left, right);//让0都在左右指针中间
                left++;
            }
            right++;//右指针不断向右移动
        }
    }

    public void swap(int[] nums, int left, int right) {
        int temp = nums[left];
        nums[left] = nums[right];
        nums[right] = temp;
    }
}

3 leetcode 485 最大连续 1 的个数

题目：给定一个二进制数组 nums ， 计算其中最大连续 1 的个数。

class Solution {
    public int findMaxConsecutiveOnes(int[] nums) {
        int maxCount =0;
        int count =0;
        int n=nums.length;
        for(int i=0;i<n;i++){
            if(nums[i] == 1) {//如果1，就加；
                count++;
            }else{//如果是0，就清零，比较一次；
                maxCount=Math.max(maxCount,count);
                count=0;
            }
        }
        maxCount=Math.max(maxCount,count);
        return maxCount;


    }
}

4 leetcode 203移除链表元素

题目：给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode removeElements(ListNode head, int val) {
        while(head!=null && head.val==val ){//不能写反
            head=head.next;
        } 
        if(head == null){//然后再判断一下边界
            return head;
        }
        ListNode temp=head;
        
        while(temp.next!=null){
            ListNode tempNext=temp.next;
            if(tempNext.val==val){
                temp.next=tempNext.next;
            }else{
                temp=temp.next;
            }
        }
        return head;
    }
}

5 leetcode 160相交链表

题目：给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
         //把所有headA 链表添加 到hashSet 中然后headB中 有则就结束
        Set<ListNode> visited =new HashSet<ListNode>();
        ListNode temp=headA;
        while(temp!=null){
            visited.add(temp);
            temp=temp.next;

        }
        temp=headB;
        while(temp!=null){
            if(visited.contains(temp)){
                return temp;
            
            }
            temp=temp.next;
        }
        return null;
       
        

    }
}

6 leetcode 150. 逆波兰表达式求值

题目：给你一个字符串数组 tokens ，表示一个根据 逆波兰表示法 表示的算术表达式。
请你计算该表达式。返回一个表示表达式值的整数。

  • 逆波兰表达式：
    逆波兰表达式是一种后缀表达式，所谓后缀就是指算符写在后面。
    平常使用的算式则是一种中缀表达式，如 ( 1 + 2 ) * ( 3 + 4 ) 。
    该算式的逆波兰表达式写法为 ( ( 1 2 + ) ( 3 4 + ) * ) 。
    逆波兰表达式主要有以下两个优点：
    去掉括号后表达式无歧义，上式即便写成 1 2 + 3 4 + * 也可以依据次序计算出正确结果。
    适合用栈操作运算：遇到数字则入栈；遇到算符则取出栈顶两个数字进行计算，并将结果压入栈中

/**
适合用栈操作运算：遇到数字则入栈；遇到算符则取出栈顶两个数字进行计算，并将结果压入栈中
*/
import java.util.Stack;
class Solution {
    public int evalRPN(String[] tokens) {
    Stack<Integer> stack =new Stack<>();
    int length=tokens.length;
    for(int i=0;i<length;i++){
        String token=tokens[i];
            if(isNumber(token)){
                stack.push(Integer.parseInt(token));//String类型转化为Integer
            }else {
                int num2=stack.pop();
                int num1=stack.pop();
                switch (token) {
                    case "+":
                        stack.push(num1 + num2);
                        break;
                    case "-":
                        stack.push(num1 - num2);
                        break;
                    case "*":
                        stack.push(num1 * num2);
                        break;
                    case "/":
                        stack.push(num1 / num2);
                        break;
                    default:
                }   
            }
        }
        return stack.pop();
    }
    public boolean isNumber(String token){
        return !("+".equals(token)||"-".equals(token)||"*".equals(token)||"/".equals(token));
    }
}

7 leetcode 141环形链表（是否有无环）

题目：给你一个链表的头节点 head ，判断链表中是否有环。

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public boolean hasCycle(ListNode head) {
        ListNode temp1=head;
        ListNode temp2=head;
        //判断是否有环，使用快慢指针，空间复杂度最低
        //也可以用hashset法
        //最笨的用两重循环一次比较一个节点前面是否出现
        if(temp1==null){
            return false;
        }
        if(temp2.next==null||temp2.next.next==null){
            return false;
        }
        while(temp2!=null&&temp2.next!=null){//temp2跑得快
            temp1=temp1.next;//先后移后判断
            temp2=temp2.next.next;
            if(temp1==temp2){
                return true;
            }
            
        }
        return false;
    }
}

8 leetcode 9回文数

题目：给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。

回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。

例如，121 是回文，而 123 不是。

class Solution {
    public boolean isPalindrome(int x) {
        //转换为字符串（回文字符串），就很简单
        String str1=String.valueOf(x);  //x.toString()
        // String str2=x+"";
        // return str1.equals(str2.reverse());//String 是不可变，没有reverse(),要用StringBuilder来新建字符串
        StringBuilder strbu=new StringBuilder();
        strbu.append(str1);//要这样添加
        return str1.equals(strbu.reverse().toString());
    }
}

9 leetcode

题目：

10 leetcode

题目：

11 leetcode

题目：

12 leetcode

题目：

13 leetcode

题目：

14 leetcode

题目：

二、Acwing

1.Acwing

三、其他练习：

1.用hashSet 判断字符串是否有重复元素；

package Practice;
import java.util.HashSet;
public class CharacterRepeat {


    public static boolean isRepeat(String str){
        int length=str.length();
        for(int i=0;i<length;i++){
            for(int j=i+1;j<length;j++){
                if(str.charAt(i)==str.charAt(j)){
                    return true;
                }
            }
        }
        return false;
    }
    public static boolean isRepeat2(String str){
        int length=str.length();
        HashSet<Character> set=new HashSet<>();
        for(int i=0;i<length;i++){
            if(set.contains(str.charAt(i))){
                return true;
            }else{
                set.add(str.charAt(i));
            }
        }
        return false;
    }


    public static void main(String[] args) {
        boolean result=isRepeat2("abcdefg");
        System.out.println(result);

        boolean result2=isRepeat2("abcdefgabc");
        System.out.println(result2);

    }
}

2.用hashMap 计算一个字符串每种字符有多少个；

package Practice;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class StrCounter {

public static HashMap<Character,Integer> getStrCounter(String str){
    HashMap<Character,Integer>  counter=new HashMap<>();
    int length=str.length();
    for(int i=0;i<length;i++){
        Character c=str.charAt(i);
        if(counter.containsKey(c)){
            Integer count=counter.get(c);
            count++;
            counter.put(c,count);
        }else{
            counter.put(c,1);
        }
    }
    return counter;


}


    public static void main(String[] args) {
        HashMap<Character,Integer> counter=new HashMap<>();
        counter=getStrCounter("abcdefgabcd");
       for(Map.Entry<Character,Integer> entry:counter.entrySet()){
           System.out.println(entry.getKey()+" "+entry.getValue());
       }
    }
}

3.用Stack 反转字符串；

package Practice;

import java.util.Stack;

public class StrReverse {


    public static String reverseStr(String str) {

        Stack<Character> stack = new Stack<>();
        int length = str.length();
        for (int i = 0; i < length; i++) {
            char c = str.charAt(i);
            stack.push(c);
        }
        String newStr = new String();
        while (!stack.empty()) {
           newStr += stack.pop();
        }
        return newStr;
    }






    public static void main(String[] args) {
        String s = reverseStr("abcdefg");

        System.out.print(s);

    }
}

4.反转链表

package Practice;

public class reverseLinkedList {

    /**
     * 反转链表非递归方法：
     * 1.定义三个指针，分别指向当前节点，当前节点的前一个节点，当前节点的后一个节点
     * 2.后一个节点先保存起来当前节点的下一个节点，(让后移知道地方)；
     * 3.然后开始反转，当前节点的下一个节点指向pre节点，然后pre节点，和当前节点都向后移动；
     * 4.当前节点指向后一个节点，继续循环，直到当前节点为空；
     * 5.最后返回pre节点；
     *
     * 备注：每次只有一个指针转换，然后两个指针后移（后移到cur和next）;
     * @param head
     * @return
     */

    public static ListNode reverseLinkedList(ListNode head) {
        ListNode pre = null;//前一个节点
        ListNode cur = head;//当前节点
        while (cur != null) {
            ListNode next = cur.next;//后一个节点,让下面的后移操作知道地方
            cur.next = pre;//反转
            pre = cur;//后移
            cur = next;//后移
        }
        return pre;
    }


    public static void main(String[] args) {
        ListNode head = new ListNode(1);
        ListNode node1 = new ListNode(2);
        ListNode node2 = new ListNode(3);
        ListNode node3 = new ListNode(4);
        head.next = node1;
        node1.next = node2;
        node2.next = node3;
        ListNode list = reverseLinkedList(head);

        while (list != null) {
            System.out.print(list.val + " ");
            list = list.next;
        }
    }
}


class ListNode {
    int val;
    ListNode next;

    ListNode(int x) {
        val = x;
    }
}

5.

四、递归与递推联系：

1.递归实现指数型枚举

题目：从 1∼n 这 n个整数中随机选取任意多个，输出所有可能的选择方案

-算法思路：递归树，每个数字可以选可以不选（一个位置一个位置的数，往后深度遍历）

 递归函数dfs：该函数接收一个参数u，表示当前正在处理排列中的第u个位置。
- 基准情况(*边界结束条件*)：如果u > n，说明已经生成了一个完整的排列，此时打印出该排列并返回。
- 递归过程（*深度遍历递归*）：从1到n遍历所有数字，对于每一个数字i：
		---  检查是否使用过：如果i没有被使用过（即used[i]为false），则进行以下操作：
						* 将i放入当前位置u（即state[u] = i）。
						* 标记i为已使用（即used[i] = true）。
						* 递归调用dfs(u + 1)以处理下一个位置。
						* 回溯：在返回到当前层之前，需要撤销之前的操作，即将state[u]重置为0，used[i]重置为				false，以便进行下一个分支的搜索。

import java.util.Scanner;

public class Main{
    public static int n;
    public static int[] state;
    public static void dfs(int u){
        if(u>n){//最后一层，已经生成了一组数，可以输出结束了；
            for(int i=1;i<=n;i++){
                if(state[i]==2){
                    System.out.print(i+" ");
                }
            }
            System.out.println();
            return;
        }
        
        state[u]=1;//1是不选，2是选
        dfs(u+1);
        state[u]=0;
        
        state[u]=2;
        dfs(u+1);
        state[u]=0;
        
    }
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        n=sc.nextInt();
        state=new int[n+1];
        dfs(1);
    }
}

2.递归实现排列型枚举

题目：把 1∼n 这 n个整数排成一行后随机打乱顺序，输出所有可能的次序。

算法思路：-依然递归搜索树，（循环依次）一个位置一个位置选（“深度遍历”），结束（到达边界）的时候将所有位置的数打印出来

import java.util.Scanner;
public class Main{
   
   public static int n;//一共n个数字
   public static int[] state;//每一个位置u的存入的数i，
   public static boolean[] used;//判断是否使用过；
    
    public static void dfs(int u){
        if(u>n){
            for(int i=1;i<=n;i++){
                System.out.print(state[i]+" ");
            }
            System.out.println();
            return;
        }
        for(int i=1;i<=n;i++){//从一到都要进行递归分支
            if(!used[i]){//如果没有用过
                state[u]=i;//第一个位置，写入i，
                used[i]=true;//i代表用过了
                dfs(u+1);
                state[u]=0;//回复状态
                used[i]=false;
            }
        }
        
    }
     public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        n=sc.nextInt();
        state=new int[n+1];
        used=new boolean[n+1];
        dfs(1);//递归搜索树
    }
}

3、递归实现组合型枚举

题目：从 1∼n 这 n个整数中随机选出 m个，输出所有可能的选择方案

import java.util.Scanner;


//基本和其他几道递归题目一样,只有一步要注意，看文中注释的地方
public class Main{
      public static int m,n;
    public static int[] state;
    
    public static void dfs(int u){
        if(u>m){
            for(int i=1;i<=m;i++){//依然是一位一位填数字
                System.out.print(state[i]+" ");
                
            }
            System.out.println();
            return;
        }
        for(int i=state[u-1]+1;i<=n;i++){//要i从上一位的数值大小开始
            state[u]=i;
            dfs(u+1);
            state[u]=0;
        }
    }
  
    
    
    
    
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        n=sc.nextInt();
        m=sc.nextInt();
        state=new int[m+1];
        dfs(1);
    }
}

4.简单的斐波那契数列输出

方法1：

//用递推计算
import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        int n;
        n=sc.nextInt();
        int[] f=new int[n];
        f[0]=0;
       
        if(n==1){
            System.out.print(f[0]);
            
        }else if(n==2){
             f[1]=1;
            System.out.print(f[0]+" "+f[1]+" ");
        }else{
             f[1]=1;
            System.out.print(f[0]+" "+f[1]+" ");
            for(int i=2;i<n;i++){
            f[i]=f[i-1]+f[i-2];
            System.out.print(f[i]+" ");
            }
        }
        
    }
    
}

方法2：

 //两个数交替滚动计算
public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int a=0;
        int b=1;
       
        for(int i=1;i<=n;i++){
            System.out.print(a+" ");
            int sum=a;
            a=b;
            b+=sum;
        }
    }

5、（快排小练习）

在这里插入图片描述

import java.util.Scanner;


public class Main{
    
    
    public static void quickSort(int[] a,int left,int right){
        if(left>=right){//边界条件，如果left>=right:说明已经拍好顺序了
            return;
        }
        int i=left-1;
        int j=right+1;
        int mid=a[left+right>>1];
        while(i<j){
            do i++;while(a[i]<mid);//两个指针如果满足条件就向中间移动，如果都不满足，就交换两个数
            do j--;while(a[j]>mid);
            if(i<j){
                int temp=a[i];
                a[i]=a[j];
                a[j]=temp;
            }
        }
        quickSort(a,left,j);//分别递归排 mid 左边，和右边
        quickSort(a,j+1,right);
        
        
        
        
    }
    
    
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int k=sc.nextInt();
        int[] a=new int[n];
        
        for(int i=0;i<n;i++){
            a[i]=sc.nextInt();
            
        }
        quickSort(a,0,n-1);
        
        System.out.print(a[k-1]);
        
        
        
    }
}

6、二分查找

题目：给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。

class Solution {
    public int search(int[] nums, int target) {
        int length=nums.length;
        int left=0;
        int right=length-1;
        while(left<=right){//索引就是指针
            int mid=left+right>>1;
            if(target==nums[mid]){
                return mid;
            }else if(target>nums[mid]){
                left=mid+1;
            }else{
                right=mid-1;
            }
        }
        return -1;
    }
}
Lucky ＆powerful
关注
  • 6
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
ACM 入门学习介绍.md
02-21
- 熟悉各种算法和数据结构的应用场景。 - 学会快速定位和修复代码中的错误。 #### 四、必备知识领域 ##### 1. **编程语言** - 掌握C/C++或JAVA的基础语法。 - 理解面向对象编程的基本概念（如类、对象、继承等...
leetcode分类-leetcode-practice:算法和数据结构实践的个人日记，帮助我创建更高效​​的软件
06-29
练习——算法有用，但重新评估我的兴趣更重要。 继续 Udacity AWS ML 课程。 联系 ESG 和 NTUitive 寻求创业线索。 下一个： : 什么是MCTS？？ 构建图书图数据库 申请更多“人才孵化器” Cracking the Coding ...
python自学日记18——数据结构与算法(2)
zxbylx1120471286的博客
10-28 223
python自学日记18——数据结构与算法(2) 这两天找了很多关于Python讲解数据结构和算法的书和视频，最终确定下来《python数据结构与算法分析》以及北京大学线上课程“数据结构与算法python版”，先看了课程后来发现好像课程结构和这本书差不多，就当配套视频看了。 刚开始还是从一些理论知识开始，虽然也想马上开始敲代码，但是理论内容还是需要掌握一些的，确实有给自己带来一些新的认识。我也一直...
如何学习数据结构与算法
阔码人生
05-05 441
为什么要学习数据结构 随着人工智能的发展，人工智能已经渗透到各个行业，算法工程师非常火爆，急缺大量人才，年薪也越来越高。刚毕业30-40万很常见，很多人都想学习算法，那究竟如何下手呢？ 遇到一个实际问题，需要解决两个事情： （1）如何将数据存储到计算机中； （2）用什么方法策略解决问题；前者是数据结构，后者是算法。只有数据结构没有算法，相当于只把数据存储到计算机中而没有有效的方法去处理，就像一幢只有框架的烂尾楼；若只有算法，没有数据结构，就像沙漠的海市蜃楼，只不过是空中楼阁罢了。 数据 是一切输入到计算机的
c++数据结构与算法【adam drozdek】通关日记1
hsccbg的博客
11-15 83
unit1 面向对象程序设计 使用软件：vs 2022 只是本人的学习笔记罢了
python自学日记20——数据结构与算法(4)
zxbylx1120471286的博客
10-30 455
python自学日记20——数据结构与算法(4) 1.用python实现栈 栈是一种后进先出的线性有序集合，每当python需要实现像栈这样的抽象数据结构时，就可以创建类。我看到后进先出就想到了沃尔玛这种大型仓库的进库出库顺序有的是后进先出。还有一摞书放和拿都是从顶部。 可以用列表来实现栈，最符合的情况是把列表的尾部当做栈的顶部处理，这样添加、删除元素都是比较简单的，代码如下： class Sta...
数据结构练习&插入数据
醉蕤的博客
09-06 556
数据结构练习&插入数据
如何学好数据结构与算法？这篇文章带你搞定这个难题
qq13321123的博客
06-13 726
参考视频‘算法之神’左神带你搞定这道BAT大厂高频面试题/数据结构与算法/既需要思路又需要coding能力 为什么要学习数据结构 随着人工智能的发展，人工智能已经渗透到各个行业，算法工程师非常火爆，急缺大量人才，年薪也越来越高。刚毕业30-40万很常见，很多人都想学习算法，那究竟如何下手呢？ 遇到一个实际问题，需要解决两个事情： （1）如何将数据存储到计算机中；（2）用什么方法策略解决问题；前者是数据结构，后者是算法。只有数据结构没有算法，相当于只把数据存储到计算机中而没有有效的方法去处理，就像一幢只有
数据结构与算法解析 -- 链表篇
Eureka1024的博客
06-13 1677
**2020-6-13 ** 从来如此，便对吗？ – 鲁迅《狂人日记》 一、概述 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域（对于双向链表也会存储上一个节点的地址域）。 常见的三种链表结构： 单链表 双向链表 循环链表 双向循环链表 二、链表的结构形式分析 2.1、单链表 链表.
菜鸟日记之数据结构1
qq_65363200的博客
07-27 875
本周学习了数据结构中的几个部分，分别为：顺序表，链表，栈，队列。
算法日记-01-算法和数据结构概览
qq_33820545的博客
03-01 168
算法日记-01-算法和数据结构概览 文章目录算法日记-01-算法和数据结构概览1.数据结构2.算法3.如何解题？4.刷题方法5.小结 1.数据结构 一维 基础：数组arry（string），链表 linked list 高级：栈 stack，队列 queue，双端队列 deque，集合 set，映射 map（hash or map），etc 二维 树 tree，图 graph 高级：二叉...
ocaml-diary:OCaml 练习和例子的日记
06-07
本资料集合——"ocaml-diary"，提供了一系列OCaml编程的练习和示例，涵盖了基础到进阶的数据结构，包括列表、队列、堆和树，以及欧拉文件等。以下是对这些主题的深入解析： 1. **列表(List)**：OCaml中的列表是不可...
《算法设计综合实训》题目.docx
03-05
栈是一种后进先出（LIFO）的数据结构，适合处理逆序操作。我们需要编写一个函数，接受一个4位整数并返回其数字逆序后的值。例如，输入7631，输出1367。题目给出了输入输出的格式，包括T组测试数据，每组数据包含一个...
【Spring框架】
最新发布
m0_71941456的博客
08-18 843
Spring框架的功能远不止于此，它还包括Spring MVC、Spring Data、Spring Security等多个模块，每个模块都有其独特的应用场景。
手撕快排——三种实现方法（附动图及源码）
jsjs1346的博客
08-16 905
🤖💻👨‍💻👩‍💻🌟🚀🤖🌟👨‍💻👩‍💻👨‍💻👩‍💻🚀是一种高效的排序算法，广泛应用于各种场景。它采用策略，将一个数组分成两个子数组，然后递归地对这两个子数组进行排序。本文将介绍三种快速排序的实现方法，并附上相应的源码。⚙️一、快速排序的基本原理一个基准元素（pivot）分成两个子数组递归合并O(n log n)O(n log n)O(n^2)后文我们将给出优化方案O(log n)📚三、实现霍尔方法是快速排序原始版本中使用的分区方法。
网上商品订单转手系统bootpf
weixin_43213064的博客
08-18 474
【代码】springboot网上商品订单转手系统bootpf
旅游网站
weixin_43213064的博客
08-16 1122
【代码】springboot旅游网站
总结常见报错信息
m0_68903702的博客
08-16 346
在@Controller注解中，返回的是字符串或者是字符串匹配的模板名称，即直接渲染视图，与html页面配合使用的，java后端的代码要结合html的情况进行渲染,使用model对象（或者modelandview）的数据将填充user视图中的相关属性，然后展示到浏览器；而在@RestController中，返回的应该是一个对象，即return一个user对象，这时，在没有页面的情况下，也能看到返回的是一个user对象对应的json字符串。情形一：若前端传入Json格式，后端使用。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值