JZoffer(数组；字符串；链表)

已于 2022-08-16 22:40:36 修改
阅读量306 收藏
点赞数
分类专栏： JZoffer 算法 文章标签： java
于 2022-04-15 22:56:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_58006481/article/details/124194981
版权
这篇博客主要探讨数组、字符串和链表的相关问题，包括二维数组查找、旋转数组最小数字、调整数组顺序、查找出现次数超过一半的数字、和为s的两个数字、字符串替换、翻转单词顺序、字符串转整数、字符串排列，以及从尾到头打印链表的多种解法。重点讲解了插入排序思想和摩尔投票法。
摘要由CSDN通过智能技术生成

目录

一、数组相关问题

1.二维数组中的查找_牛客网

2.JZ11 旋转数组的最小数字_牛客网

3.调整数组顺序使奇数位于偶数前面_牛客网

相对位置变化情况：

相对位置不变情况：应用到插入排序思想⭐

4.JZ39 数组中出现次数超过一半的数字_牛客网

方法一：应用到Map集合

方法二：排序，找中间值

方法三：摩尔投票法⭐

5.力扣_和为s的两个数字

二、字符串相关问题

1.字符串替换

2.翻转单词顺序

3.力扣_字符串转整数

4.力扣_字符串的排列

三、链表相关

JZ6 从尾到头打印链表_牛客网

方法一：定义栈结构

方法二：链表保存数组中逆置数组--list集合的设置和查询元素

方法三：递归⭐

一、数组相关问题

1.二维数组中的查找_牛客网

      在一个二维数组array中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

public class Solution {
    public boolean Find(int target, int [][] array) {
  if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return false;
        }
        //从右上角循环判断，一次排除一行或一列
        int i=0;
        int j=array[0].length-1;
        while(i<array.length&&j>=0){
            if(target<array[i][j]){
                j--;
            }else if(target>array[i][j]){
                i++;
            }else{
                return true;
            }
        }
        return false;
    }
}

2.JZ11 旋转数组的最小数字_牛客网

      有一个长度为 n 的非降序数组，比如[1,2,3,4,5]，将它进行旋转，即把一个数组最开始的若干个元素搬到数组的末尾，变成一个旋转数组，比如变成了[3,4,5,1,2]，或者[4,5,1,2,3]这样的。请问，给定这样一个旋转数组，求数组中的最小值。

分析：应用到二分查找

         旋转的深浅最后导致的是最小值在数组的左or右半部分。分为两个递增部分，旋转后的左半部分是非递减的，右半部分也是非递减的，左半部分整体大于右半部分。确定mid位置，最小值无非三种情况：mid左侧，mid右侧，就是mid。

      起始left指向最左侧，right最右侧，若mid<left对应值，说明当前mid对应索引值不属于前半部分（即第一个递增部分），而属于右半部分，应该在左边去找；如果当前值>=左侧left对应值，那么当前值属于左半部分，应该在右边去找。

if(arr[mid]>=arr[left]){

        //mid大于最左侧的值，此时mid属于前半升序部分

        //所以最小值在右半部分，就不用在[left,mid]之间找了

        left=mid;

}

else if(arr[mid]<arr[left]){

        //中间值mid属于原数组后半部分升序序列

        //目标值就在mid左边

        right=mid；

}

注意：因为题目是非递减数组，有可能数据重复，arr[left]=arr[mid]=arr[right]时，无法判断往哪边去找最小值，需要单独拎出来判断：

        （定位左右中位置，左->右遍历，int i=left+1，v=arr[left]，当arr[i]<v（即遍历到的值<这几个相等值时，这个v就是答案（左右是两个递增部分））时，v=arr[i]）

若：

if(right-left==1){//说明数据已经相邻

        mid=right;

        break;

}

此时说明left和right已经相邻，此时右侧right一定就是这个有序数旋转后最小值位置对应索引

import java.util.ArrayList;
public class Solution {
    public int minNumberInRotateArray(int [] array) {
        if(array.length==0||array==null){
            return 0;
        }
        int left=0;
        int right=array.length-1;
        int mid=0;
        while(array[left]>=array[right]){//也可以是left<right,题目中这么写只是为了时刻保证左半部分是大于等于右半部分的值的
            //left表示最左侧，right表示最右侧
            //当左边值>右边值时循环
           
            if(right-left==1){
                mid=right;
                break;//左右相差一就已经遍历到最后了，right就是最小的结果
            }
             mid=left+((right-left)>>1);
            if(array[left]==array[right]&&array[right]==array[mid]){
                //三者相等，从左到右遍历
               
                for(int i=left;i<right;i++){
                    if(array[i]>array[i+1]){
                     return array[i+1];
                      
                    }
                }
               //从头到尾只有一个数时，那个循环进不去的
                 return numbers[mid];
            
            }
            //此时，right,left,mid索引对应的值不会同时相等,二分更新条件
            if(array[mid]>=array[left]){
                left=mid;
            }else{
                right=mid;
            }
        }
        return array[mid];
    }
}

3.调整数组顺序使奇数位于偶数前面_牛客网

      输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。

相对位置变化情况：

public class Solution {
    public void reOrderArray(int [] array) {
        int left=0;
        int right=array.length-1;
        while(left<right){
            while(left<right && ((array[left]&1)!=0)){
                left++;
            }
            while(left<right &&( (array[right]&1)==0)){
                right--;
            }
            if(left<right){
                int temp=array[left];
                array[left]=array[right];
                array[right]=temp;
            }
        }
    }
}

扩展：

      输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变.

相对位置不变情况：应用到插入排序思想⭐

从前往后，把偶数后移，腾出位置，放入奇数（奇数前插会有问题）【ps:插入排序是前插】

       遍历遇到奇数暂停保存（定义k，最后保存的奇数依次给k下标对应位置，k从0开始遍历），进行数的向后搬移（arr[j]=arr[j-1]，搬移k+1...i的元素），搬移完后，将暂存的奇数放在k位置k++存下一个奇数即可...这样就能保证相对位置不发生变化。

public class Solution {
    public void reOrderArray(int [] array) {
        if(array==null&&array.length==0){
            return;
        }
        //定义k，每次暂存的奇数放在k位置，k从0开始
           int k=0;
       for(int i=0;i<array.length;i++){
          
           //判断，当奇数是开始进行数的搬移【该奇数之前的偶数整体后移】
           if((array[i]&1)==1){
               int j=i;
               //暂存j处的奇数
               int val=array[j];
               while(j>k){
                   //k...j-1的所有数统一后移
                   array[j]=array[j-1];
                   j--;
               }
               //搬移完后将暂存奇数放在k位置
               array[k]=val;
               k++;
           }
       }
    }
}
import java.util.*;
public class Solution {
    public void reOrderArray(int [] array) {
        int len=array.length;
        int k=0;//记录已经排序好的奇数的个数
        for(int i=0;i<len;i++){
            if((array[i]&1)==1){
                int j=i;
                //将奇数j交换到k+1位置【奇数不断前插】
                while(j>k){
                    int temp=array[j];
                    array[j]=array[j-1];
                    array[j-1]=temp;
                    j--;
                }
                //出循环奇数j就交换到了k+1位置,k++继续循环
                k++;
            }
        }
        
    }
}

4.JZ39 数组中出现次数超过一半的数字_牛客网

      给一个长度为 n 的数组，数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组[1,2,3,2,2,2,5,4,2]。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。

【注意：题目已知一定有一个数超过一半了，如果没有这句话，问你求超过一半的数，一定要记得得到结果后统计这个数字的次数看是否满足超过一半这个条件】

方法一：应用到Map集合

将数以及对应次数统计到Map集合中，再遍历Map集合，找到最大val【或者更容易地做法是直接找到>array.length/2的val】

import java.util.*;

public class Solution {
    public int MoreThanHalfNum_Solution(int [] array) {
        if(array==null){
            return 0;
        }
        Map<Integer,Integer> map=new HashMap<>();
      
        //遍历数组元素，将元素与其对应出现次数存储到val中
        for(int i=0;i<array.length;i++){
            if(map.containsKey(array[i])){
                //当前元素存储在Map中                
                map.put(array[i],map.get(array[i])+1);
            }else{
                //当前元素在Map中不存在
                map.put(array[i],1);
            }
        }
        //遍历Map集合，找出val值>array.length/2的值
        int res=0;
        for(Map.Entry<Integer,Integer> entry:map.entrySet()){
            if(entry.getValue()>(array.length/2)){
                res=entry.getKey();
            }
        }
        return res;
    }
}

//val值>array.length/2的值其实也相当于找val最大值,可以按如下找最大val值办法实现，区别不大：
import java.util.*;

public class Solution {
    public int MoreThanHalfNum_Solution(int [] array) {
        if(array==null){
            return 0;
        }
        Map<Integer,Integer> map=new HashMap<>();
       int maxCount=0;
        //遍历数组元素，将元素与其对应出现次数存储到val中
        //同时记录val出现次数，找出最大次数对应的key
       for(int i=0;i<array.length;i++){
           map.put(array[i],map.getOrDefault(array[i],0)+1);
           maxCount=(maxCount>map.get(array[i])?maxCount:map.get(array[i]));
       }
        int res=0;
        for(Map.Entry<Integer,Integer> entry:map.entrySet()){
            if(entry.getValue()==maxCount){
                res=entry.getKey();
            }
        }
        return maxCount>array.length/2?res:0;
    }
}

方法二：排序，找中间值

import java.util.*;
public class Solution {
    public int MoreThanHalfNum_Solution(int [] array) {
        Arrays.sort(array);
        return array[array.length/2];
    }
}

方法三：摩尔投票法⭐

       第一个数先设为被投票人，票数默认设为一票。给他票，票数++，票不给他，票数--。若他的票多于一半（或着说是所有候选人中最多的），最后票数抵消的结果自然还是他的票是正数，他就是结果了，注意，当他票数归零时就替换新的候选人（即他票为0时正好遍历到的人）。

public class Solution {
    public int MoreThanHalfNum_Solution(int [] array) {
        if(array==null||array.length==0){
            return 0;
        }
        int target=array[0];
        int times=1;
        for(int i=1;i<array.length;i++){
            //当times=0时说明已经抵消完了，没必要让当前target再和后面数据比较了，将当前arr[i]这个数换给target.即换候选人，这里无需times=1，因为下面还会判断当前候选人是否和target相等，这里换过一定相等，所以这个循环完还是times=1
            if(times==0){
                target=array[i];
            }
            if(target==array[i]){
                times++;
            }else{
                times--;
            }
        }
        return target;
    }
}

假如不确定每个人人数是否超过一半，但问题要找超过一半的数，则还要继续加判断：

public class Solution {
    public int MoreThanHalfNum_Solution(int [] array) {
        if(array==null||array.length==0){
            return 0;
        }
        int target=array[0];
        int times=1;
        for(int i=1;i<array.length;i++){
            //当times=0时说明已经抵消完了，没必要让当前target再和后面数据比较了，将当前arr[i]这个数换给target
            if(times==0){
                target=array[i];
              
            }
            if(target==array[i]){
                times++;
            }else{
                times--;
            }
        }
        //已经找出候选人target，现在重新统计该候选人的票数
        times=0;
        for(int i=0;i<array.length;i++){
            if(array[i]==target){
                times++;
            }
        }
        //票数统计完毕，看是否超过一半，超过一半才能返回target
        return times>array.length/2?target:0;
        
    }
}

摩尔投票法涉及题目：leetcode169、229

5.力扣_和为s的两个数字

/**
 * 输入一个递增排序的数组和一个数字s，在数组中查找两个数，使得它们的和正好是s
 * 如果有多对数字的和等于s，则输出任意一对即可。
 **/
public class Num57_和为s的两个数字 {
    public int[] twoSum(int[] nums, int target) {
        //利用双指针，left,right。nums[left]+nums[right]>target，则right左移
        // <target，则left右移，相等则输出这两个数即可
        int left=0;
        int right=nums.length-1;
        int[] array=new int[2];
        while(left<right){
            int sum=nums[left]+nums[right];
            if(sum>target){
                right--;
            }else if(sum<target){
                left++;
            }else{//找到了
                array[0]=nums[left];
                array[1]=nums[right];
                break;
            }
        }
        return array;
    }
}

二、字符串相关问题

1.字符串替换

请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。

分析：对原始字符串调整，定义old指针指向字符串结尾，定义new指针指向新结尾，两个都向前--，old结尾的字符逐步挪到new处，碰到空格单独处理，不挪空格，让'%''2''0'给new.

public class Solution {
    public String replaceSpace(StringBuffer str) {
    	//先统计字符串中空格字符个数
        int count=0;
        for(int i=0;i<str.length();i++){
            if(str.charAt(i)==' '){
                count++;
            }
        }
        int new_length=str.length()+2*count;
        //新老下标
        int old_index=str.length()-1;
        int new_index=new_length-1;
        //原始字符串长度设置为新长度
        str.setLength(new_length);
        //整体后移
        while(old_index>=0&&new_index>=0){
            if(str.charAt(old_index)==' '){
                //空格，new放入%20
                str.setCharAt(new_index--,'0');
                str.setCharAt(new_index--,'2');
                str.setCharAt(new_index--,'%');
            }else{
                //正常字符，简单一位一位挪动即可
                //old_index的值设置给new_index位置值
                str.setCharAt(new_index,str.charAt(old_index));
                  new_index--;
            }
            old_index--;    
        }
        return str.toString();
    }
}

2.翻转单词顺序

注意：

分割字符串s：按单个空格分割是s.split(' ');可以按按连续空格分割是s.split("\\s+")；

去除字符串s的开头结尾空白字符：s.trim();

/**
 * 输入一个英文句子，翻转句子中单词的顺序，但单词内字符的顺序不变。为简单起见，标点符号和普通字母一样处理。
 * 例如输入字符串"I am a student. "，则输出"student. a am I"。
 **/
public class Num58_1_翻转单词顺序 {
    public static String reverseWords(String s) {
        s = s.trim();//去除字符串开头和末尾的空白字符
        // 正则匹配连续的空白字符作为分隔符分割
        String[] array=s.split("\\s+");//字符串按空格（中间是连续空格也当作一个空格分割）分割转为字符串数组
        int left=0;int right=array.length-1;
        while (left<right){
            String temp=array[left];
            array[left]=array[right];
            array[right]=temp;
            left++;
            right--;
        }
        StringBuilder sb=new StringBuilder();
        for (int i = 0; i < array.length; i++) {
            sb.append(array[i]);
            if(i!=array.length-1){
                sb.append(" ");
            }
        }
        String res= sb.toString();

        return res;
    }

    public static void main(String[] args) {
        String s=" a good   example ";
        reverseWords(s);
    }
}

3.力扣_字符串转整数

public class Num67_字符串转换为整数 {
    public int strToInt(String str) {
        //去除两边空格并转化为字符串数组
        char[] array=str.trim().toCharArray();
        if(array.length==0){
            return 0;
        }
        //最大数字2147483647除以10：是否越界有两个可能，一个是10*214748365直接越界，一个是10*214748364+9越界【10*res+x】
        int bndry = Integer.MAX_VALUE / 10;
        //索引位
        int i=1;
        //符号位
        int sign=1;
        //总值
        int res=0;
        if(array[0]=='-'){//首位为负号
            sign=-1;
        }else if(array[0]!='+'){//首位不是’+‘也不是’-‘，将索引归到0位置去循环里判断是数字还是其他符号
            i=0;
        }
        for (int j = i; j < array.length; j++) {
            //判断当前是否字符
            if(array[j]<'0'||array[j]>'9'){//当前位不是正负号与数字，不必再计算直接返回【注意题目中特殊符号不影响数字】
                break;
            }
            //判断数字res越界情况
            if(res>bndry||(res==bndry&&array[j]>'7')){
                //正数越界返回最大值，负数返回最小值
                return sign==1?Integer.MAX_VALUE:Integer.MIN_VALUE;
            }
            //此时当前字符是数字且未越界
            res=res*10+(array[j]-'0');
        }
        return sign*res;//带符号位
    }
}

4.力扣_字符串的排列

/**
 * 输入一个字符串，打印出该字符串中字符的所有排列。
 * 你可以以任意顺序返回这个字符串数组，但里面不能有重复元素
 **/

import java.lang.reflect.Array;
import java.util.*;

/**
 * 思路：回溯
 * 1.定义递归函数：permutationHelper(i,sb) 表示当前排列为sb，下一个待填入的空位是第i个空位（下标从0开始）。那么该递归函数分为两个情况:
 *      1)i==n,我们填完了n个空位，sb放入答案数组中，递归结束
 *      2)i<n,考虑i填何字符，填入遍历到的未标记的字符，然后用标记bool标记已经填过的字符，然后继续下一个空位填写，即调用permutationHelper(i,sb)
 *      3)调完函数回溯时，我们需要要撤销该空位填的字符以及对该字符的标记，并继续向当前空位尝试填入其他没被标记过的字符
 * 2.去重（保证每个排列只出现一次）：每一个空位的重复字符只能被填写一次
 *      具体：对原字符串排序，保证相同的字符都相邻，在递归函数中，我们限制每次填入的字符一定是这个字符所在重复字符集合中「从左往右第一个未被填入的字符」
 *      即如下的判断条件：
 *      if (bool[j] || (j > 0 && !bool[j - 1] && s[j - 1] == s[j])) {
 *      //bool[j]:j没有被标记是false，此时判断后面若j-1没被标记且j-1与j对应值等，执行continue（重复字符的第一个才能执行调用，j在j-1后还和j-1一样自然不能调用）
 *       continue;
 *      }
 */
public class Num38_字符串的排列 {
    List<String> res;
    boolean[] bool;
    public String[] permutation(String s) {
        res=new ArrayList<>();
        bool=new boolean[s.length()];
        //1.字符串中的字符进行排序，让重复的在一块
        char[] array=s.toCharArray();
        Arrays.sort(array);
        StringBuilder sb=new StringBuilder();
        //2.将有序字符串进行不同排列,结果存储在res中
        permutationHelper(array,0,s.length(),sb);
        //3.输出字符串数组
        int size=res.size();
        String[] strs=new String[size];
        for (int i = 0; i < size; i++) {
            strs[i]=res.get(i);
        }
        return strs;
    }

    //将字符串组合成不同的顺序排列，保存在StringBuilder中
    //递归+回溯
    private void permutationHelper(char[] array, int i, int length, StringBuilder sb) {
        if(i==length){
            //递归出口，填完了length个空位，sb内所有的内容保存到res中，返回即可
            res.add(sb.toString());
            return;
        }
        for (int j = 0; j < length; j++) {
            //去重
            if(bool[j]||(j>0&&!bool[j-1]&&array[j]==array[j-1])){
                continue;
            }
            //当前位置标记为已判断过
            bool[j]=true;
            sb.append(array[j]);//当前数字加入sb中
            //进行下一个位置的数字插入
            permutationHelper(array,i+1,length,sb);
            //回溯——撤销该空位填的字符以及对该字符的标记
            sb.deleteCharAt(sb.length()-1);
            bool[j]=false;
        }
    }
    //方法2：也是回溯但使用到Set去重
    Set<String> set=new HashSet<>();
    boolean[] b;
    public String[] permutation1(String s){
        char[] array=s.toCharArray();
        b=new boolean[s.length()];
        StringBuilder sb=new StringBuilder();
        dfs(array,0,sb);//从array的第一个索引遍历直到最后一个索引
        //得到了set集合，变为String[]
        int size=set.size();
        String[] res=new String[size];
        set.toArray(res);//set集合变为String[]（Set<String>），和下面注释掉的两行代码效果一样
//        int idx = 0;
//        for (String str : set) res[idx++] = str;
        return res;
    }

    private void dfs(char[] array, int i, StringBuilder sb) {
        int length=array.length;
        //递归终止条件：i遍历完最后一个字符后
        if(i==length){
            set.add(sb.toString());//set添加操作时就会去重
            return;
        }
        //循环判断下一个字符填的是哪个字母
        for (int j = 0; j < length; j++) {
            if(b[j])continue;//当前位不能放已经放过的字符
            b[j]=true;
            sb.append(array[j]);
            dfs(array,i+1,sb);
            //回溯——撤销该位置填的字符以及对该字符的标记
            sb.deleteCharAt(sb.length()-1);
            b[j]=false;
        }
    }

}

三、链表相关

JZ6 从尾到头打印链表_牛客网

      输入一个链表的头节点，按链表从尾到头的顺序返回每个节点的值（用数组返回）

分析：多结构混合使用、递归

方法一：定义栈结构

不断遍历链表，将链表元素入栈，入后顺序出栈，得到结果.

import java.util.Stack;
import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> list=new ArrayList<>();
        if(listNode==null){
            return list;
        }
        //定义栈，遍历链表，让链表不断入栈
        Stack<Integer> stack=new Stack<>();
        while(listNode!=null){
            stack.push(listNode.val);
            listNode=listNode.next;
        }
        while(!stack.empty()){
            list.add(stack.pop());
        }
        return list;
    }
}

方法二：链表保存数组中逆置数组--list集合的设置和查询元素

将数全部保存到链表中，在链表中手动逆置所有的数

import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> list=new ArrayList<>();
        for(;listNode!=null;listNode=listNode.next){
            list.add(listNode.val);
        }
        //逆置这个链表
        int l=0;
        int r=list.size()-1;
        while(l<r){
            int temp=list.get(l);
            list.set(l,list.get(r));
            list.set(r,temp);
            l++;
            r--;
        }
        return list;
    }
}

方法三：递归⭐

import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
         ArrayList<Integer> list=new ArrayList<>();
        printListFromTailToHeadHelper(listNode,list);
        return list;   
    }
    private void printListFromTailToHeadHelper(ListNode listNode,ArrayList<Integer> list){
        if(listNode==null){
            return;
        }
        printListFromTailToHeadHelper(listNode.next,list);//一直递归直到递归到尾部返回放入list
        //listNode之后的节点处理完毕了
        list.add(listNode.val);
    }
}

林纾y
关注
专栏目录
如何通过数组或字符串直观地创建链表
lenfranky的博客
05-06 1087
在前段时间集中做了leetcode上树的相关的题目之后，最近准备做链表相关的题目了。与之前的问题相同，如果每次测试代码的时候，自己创建测试用例，或者调用leetcode给的例子，都要手动去创建一个链表的话，效率未免太低，也会打断做题时候的思路，因此，也整理出了一个用来创建链表的代码，贴出来以供参考。 相关文章 这里有可以参考的创建和直观展示一棵树的方法： 如何直观地打印一棵树 如何直观地创建一...
JavaScript将数组转换为链表的方法
10-15
在JavaScript中，数组是一种常见的数据结构，而链表则是另一种常用的数据结构，它们各有优势。在某些场景下，我们可能需要将数组转换为链表，例如在实现特定算法或者优化某些操作时。本文将深入探讨如何使用...
JZ-offer 简单二叉树相关
lucky_ferry的博客
11-30 392
一、输出二叉树的镜像 左右子节点交换即可，采用递归的思路最简单 function mirrorTree(root){ if(root == null) return null; //交换左右子节点，定义一个中间变量，实现交换 let temp = root.left; root.left = root.right; root.right = temp; //往下递归，直到为空 mirrorTree(root.left); mirrotTree(root.right); } 二、二叉树的深度 给
JZ-offer-二叉树的层序遍历
lucky_ferry的博客
11-30 221
我们知道，二叉树的搜索分为深度优先搜索和广度优先搜索 深度优先搜索，简单来说就是竖着遍历，分为前序遍历，中序遍历和后序遍历 广度优先搜索，就是横着搜索，因为也叫层序遍历 一、JZ-offer-32(1) 从上到下打印出二叉树的每个节点，同一层的节点按照从左到右的顺序打印。 层序遍历一般用到队列的概念。利用了队列具有先进先出的特性， 具体实现过程就是：每次弹出一个节点，就判断该节点是否有子节点，有就将其加入到队列中，这样就实现了队列中的元素始终是按层排队的。 function levalOrd.
JZoffer51-数组中的逆序对(归并排序解决)
m0_58006481的博客
03-19 211
求数组中的逆序对：再归并排序时顺带求逆序对数目（归并的并（merge）操作就是将小数组合回大数组，此时顺带可以计算逆序对数目）
C++中字符数组与字符串
无
10-10 3132
C++中字符数组和字符串的一些总结
C语言用链表存储字符串
jlfcc的博客
03-28 1134
【代码】C语言用链表存储字符串。
字符串数组的赋值问题
m0_54673847的博客
07-23 2743
串的存储形式主要有顺序存储结构和链式存储结构两种。顺序存储结构包括定长顺序存储和堆分配存储，其中堆分配存储因其灵活性而更常用。链式存储结构则适用于需要频繁插入或删除字符的场景，但由于空间利用率和操作的复杂性，其使用相对较少。在某些高级编程语言中，字符串还可能采用特殊的存储形式，如Java的String类。参考4条信息源串一般采用什么存储形式文件图片指令启。
数组和链表
weixin_45922730的博客
11-05 1113
一、数组 1、数组的定义 2、数组在内存中的存储方式 3、数组的基本操作 4、数组的优势和劣势 二、链表 1、链表的定义 2、单向链表 3、双向链表 4、链表的基本操作 4、删除元素 三、数组和链表的不同
数组转链表
AI悦创·编程私教1v1
09-29 1158
你好，我是悦创。 下面我逐步解释数组转链表的完整过程，结合刚才制作好的动画。首先解释问题是什么： 想要输出的链表示意图如下： 算法的伪代码如下所示： 下面每个迭代步，逐个分析。 第一步，head 指向创建的第一个节点： 第二步，同时让 tmp 指针指向此节点： 第三步，进入遍历，并创建第二个节点，同时令第一个节点指向第二个节点，如下所示，同时 tmp 指向此节点，至此完成第二个节点的串接： 依次串接第三个节点： 串接第四个节点： 这步中，同时让 tmp 指向第四个节点： 同理，完成最后一个
C语言双向链表实现对字符串的存储
weixin_51927215的博客
03-18 2613
双向链表实现字符串的存储—— 头文件结构体声明双向链表节点
如何给链表数组赋值.rar_如何 链表 数组 赋值_链表_链表数组赋值_链表赋值
09-22
链表数组，顾名思义，是链表和数组的结合体，即数组中的每个元素都是一个链表。这种结构常用于需要同时处理多个独立链表的情况，例如在图的邻接表表示中。给链表数组赋值涉及到链表的创建、插入、遍历以及数组的初始...
JavaSE-数组集合和链表集合 数组和链表.docx
04-18
### JavaSE中的数组集合与链表集合解析 #### 一、数组集合 数组集合是一种基本的数据结构，在Java中被广泛使用。它具有以下特点： 1. **有序性**：数组集合中的元素按照一定的顺序排列，这使得我们可以通过索引...
C语言程序设计数组字符串指针实用教案.ppt
12-12
在C语言中，字符串可以用字符数组来表示。例如，char str[20]; 定义了一个字符数组str，长度为20。 使用指针访问字符串的方法是，char *p; p = str; 访问字符串str的元素。 数组和指针的关系 数组和指针是紧密...
【JAVA开源】基于Vue和SpringBoot的高校学科竞赛平台
杨荧的CSDN博客
10-10 1405
教师功能有个人中心，题目类型管理，竞赛题库管理，竞赛类型管理，竞赛信息管理，报名信息管理，竞赛评分管理，参赛名单管理，晋级名单管理，获奖名单管理，竞赛总结管理，报销清单管理，成绩申诉管理，参赛信息管理，参赛信息管理，往年成绩管理，获奖情况管理。
Netty 相比原生IO模型的优势
lssffy的博客
10-09 630
Java提供了多种I/O模型，每种模型都有其适用的场景和特点，随着网络应用需求的变化，I/O模型也在不断发展。阻塞I/O（BIO，Blocking I/O）传统的I/O模型，使用简单，但每次I/O操作都会阻塞线程。每个请求需要独立的线程来处理，这在并发请求较少时问题不大，但在高并发情况下，线程资源将成为瓶颈。非阻塞I/O（NIO，Non-Blocking I/O）引入了多路复用技术，一个线程可以处理多个连接，避免了BIO中每个连接占用一个线程的问题。通过Selector。
Backend - Java 基础
是萝卜干呀的博客
10-11 559
知识量决定了未来能走多远
Hex编码
最新发布
weixin_74305514的博客
10-13 100
emps;是一种将数据转换为十六进制表示的方法。Hex编码使用16个字符来表示数据。&emps;
Spring Boot 整合 Minio
cmh1008611的博客
10-09 931
5‌‌.Optional‌是Java 8引入的一个新的容器对象，它提供了非常丰富的API，主要是为了解决空指针异常的问题。Optional类允许你创建一个可能为null的值的容器，从而避免了直接使用null值可能导致的空指针异常。自动处理异常：在使用 @SneakyThrows 注解的方法中，如果抛出任何类型的检查性异常（即编译器要求显式捕获或声明的异常），Lombok 会自动将其包装成运行时异常（RuntimeException），从而避免了需要显式捕获或声明这些异常的麻烦。可以用于自动装配和依赖注入。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值