数据结构与算法笔记（十二）

最新推荐文章于 2024-07-10 22:41:59 发布
最新推荐文章于 2024-07-10 22:41:59 发布
阅读量110 收藏 1
点赞数
文章标签： 数据结构与算法 python
原文链接：https://my.oschina.net/bzhangpoorman/blog/3019931
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

一、排序
1.什么是排序
    排序是将一堆杂乱无章的数据，按某个关键字重新排列成有序的序列。排序分为稳定排序和不稳定排序：
  • 稳定排序：如果在待排序的序列中存在多个具有相同关键字的元素，在使用某种排序后，这些相同的关键字的元素在序列中的相对次序未发生改变，则称这种排序方法是稳定的，常见的稳定排序有冒泡排序、插入排序、基数排序，归并排序等。
  • 不稳定排序：与稳定排序相反，在使用某种排序后，这些相同关键字的元素在序列中的次序发生了改变，则是不稳定排序，常见的额不稳定排序有选择排序、希尔排序、快速排序等。
    例子：排序前有（22, 33,12,57, 33,98,16, 33）；若经过排序后得到的是（12,16,22, 33, 33, 33,57,96）,则这种排序是稳定排序；若得到的是（12,16,22, 33, 33, 33,57,96）就是不稳定排序。
 
    排序还可以分为比较排序和非比较排序，其中大部分的排序都是比较排序，即通过比较关键字来判断大小，作为其排序的依据。但也有不需要通过比较的排序方法，如基数排序，计数排序等。下面是常见排序的分类图：
54061e24f8d221e9dafd80b47999a2515d9.jpg
 
    常见排序方法的比较：
acab46f32f10de2ac56df1a88c2f0196e89.jpg
    可以看出时间复杂度最高的就是三种基本排序：（简单）插入排序，（简单）选择排序，冒泡排序。
 
二、交换排序
1.冒泡排序
    交换排序就是根据关键值的比较结果来交换这两个关键字在序列中的位置。常见的交换排序有冒泡排序和快速排序。
    冒泡排序是一种简单的交换排序算法。它通过不断的遍历整个序列，每次比较两个元素，如果满足要求就交换位置，不满足就不交换。每遍历一趟序列找出一个最大（或最小）的元素，直到没有可以在交换的元素为止。此时表明排序完成。其一般步骤为（以升序为例）：
  1. 比较相邻的两个元素。若第一个元素比第二个大，就将这两个元素的位置交换。
  2. 对序列中的所有相邻元素都执行步骤1的工作，这样就末尾元素就是该序列中最大的元素。
  3. 重复以上2个步骤，每次都能使一个元素有序，直到所有元素都有序为止。
    冒泡排序的实现： 

/**
* 冒泡排序的简单实现
* Created by bzhang on 2019/3/7.
*/
public class Sorted {

      public static void main(String[] args) {
            int[] data = {1,8,6,4,12,9,78,13};
            bubbleSort(data);
            for (int i=0;i<data.length;i++){
                  System.out.println(data[i]);
            }
      }

      public static void bubbleSort(int[] data){
            int len = data.length;
            int t = 0;
            for (int i=0;i<len-1;i++){
                  for (int j=0;j<len-1-i;j++){
                        if (data[j]>data[j+1]){
                              t = data[j];
                              data[j] = data[j+1];
                              data[j+1] = t;
                        }
                  }
            }
      }

}
 
 
2.快速排序
    快速排序是冒泡排序的改进版，我们知道冒泡排序的比较交换是在相邻单元中进行的，每次只能比较一对元素，造成总的比较次数和移动次数较多。为了提高效率，快速排序便孕育而生，快速排序采用分治法：即先从序列中选取一个基准数；然后将比基准数大的放到基准数的右边，小的放到左边；再将左右区间看做两个序列重复之前的操作，直到各个区间只有一个数为止。
  
/**
* 排序的简单实现
* Created by bzhang on 2019/3/7.
*/
public class Sorted {


      public static void main(String[] args) {
            int[] data = {100,1,8,6,4,12,9,78,13,50,16,24};
            fastSort(data);
            for (int i=0;i<data.length;i++){
                  System.out.println(data[i]);
            }
      }

        //快速排序的简单实现
      public static void fastSort(int[] data){
            int start = 0;
            int end  =data.length-1;
            fastSort(data,start,end);


      }

        //递归实现快速排序
      private static void fastSort(int[] data, int start, int end) {
            if ((end-start)<1){
                  return;
            }
            int basic = data[start];
            int index = start;
            int over = end;
            int tmp = 0;
            for (int i = start+1;i<=end;i++){
                  if (basic>data[i]){
                        data[index] = data[i];
                        data[i] = basic;
                        index++;
                  }else {
                        tmp = data[over];
                        data[over] = data[i];
                        data[i] = tmp;
                        over--;
                  }
            }
            fastSort(data,start,index-1);
            fastSort(data,index+1,end);


      }

}

 

 
三、插入排序
1.简单插入排序
    插入排序是一种直观的排序算法，它是通过选取一个数，寻找其在一个有序序列中的位置，对其进行插入操作从而得到一个新的有序序列。
    示例：已知一个有序序列{3,6,9,11,13,17}，若有元素10要插入该序列，则其插入排序步骤为：
  1. 比较查找10在原序列中的位置（大于9，小于11），为索引3的位置（原11的位置）。
  2. 将11的位置空出，并放入10。
  
/**
* 排序的简单实现
* Created by bzhang on 2019/3/7.
*/
public class Sorted {

      public static void main(String[] args) {
            int[] data = {100,1,8,6,4,12,9,78,13,50,16,24};
            insertSort(data);
            for (int i=0;i<data.length;i++){
                  System.out.println(data[i]);
            }
      }

      //插入排序的简单实现
      public static void insertSort(int[] data){
            int len = data.length;
            boolean flag = false;   //标志位，false执行比较语句，true执行移动语句
            int tmp = 0;
            for (int i = 1;i<len;i++){
                  for (int j = 0;j<=i;j++){
                        //查找元素位置，查找到后，将待插入位置的元素往后移动1位
                        if (flag){
                              int t = data[j];
                              data[j] = tmp;
                              tmp = t;
                        }else {
                              if (data[i]<data[j]){
                                    tmp = data[j];
                                    data[j] = data[i];
                                    flag = true;
                              }
                        }


                  }
                  flag = false;
            }
            
      }

}

 

 
2.希尔排序
    希尔排序是简单插入排序的改进版，简单插入排序是挨个选取待插入元素来与一个有序序列比较查找出待插入位置，希尔排序则是将带插入序列以k（k为小于序列长度的正整数）为间隔分成若干个子序列后执行简单插入排序，然后缩小k值，循环执行前面步骤，当k=1时，序列便有序。
    示例：对{3,16,22,14,8,6,17,33,41,26,11,43,38,24}使用希尔排序，间隔为4。
  1. 将序列以间隔4分为4个子序列，{3,8,41,38};{16,6,26,24};{22,17,11};{14,33,43}（这里是为了方便查看分组，实际并没有分成4个序列，所有元素还是在一个序列之中）。分别使用简单插入排序得到{3,8,38,41}；{6,16,24,26}；{11,17,22,}；{14,33,43}，即得到{3,6,11,14,8,16,17,33,38,24,22,43,41,26}这样一个序列。
  2. 再将1中得到的序列以间隔k=3进行简单插入排序，直到k=1时的排序完成，就得到一个有序的序列。
  
/**
* 排序的简单实现
* Created by bzhang on 2019/3/7.
*/
public class Sorted {

      public static void main(String[] args) {
            int[] data = {100,1,8,6,4,12,9,78,13,50,16,24};
            shellSort(data,4);
            for (int i=0;i<data.length;i++){
                  System.out.println(data[i]);
            }
      }

      //希尔排序
      public static void shellSort(int[] data,int k){
            int len = data.length;
            boolean flag = false;   //标志位，false执行比较语句，true执行移动语句
            int tmp = 0;
            while (k>=1){
                  for (int i = k;i<len;i++){
                        for (int j = i%k;j<=i;j+=k){
                              //查找元素位置，查找到后，将待插入位置的元素往后移动k位
                              if (flag){
                                    int t = data[j];
                                    data[j] = tmp;
                                    tmp = t;
                              }else {
                                    if (data[i]<data[j]){
                                          tmp = data[j];
                                          data[j] = data[i];
                                          flag = true;
                                    }
                              }
                        }
                        flag = false;
                  }
                  k=k/2;
            }
      }
}

 

 
四、选择排序
1.简单选择排序
    选择排序也是一种简单直观的排序算法，其原理是在待排序的序列中找出最大（或最小）的元素，存放到序列的起始位置，在从剩余的无序序列中找出最大（或最小）的元素，排到有序序列的下个位置。重复前面步骤，直到排序完成。
  
/**
* 排序的简单实现
* Created by bzhang on 2019/3/7.
*/
public class Sorted {

      public static void main(String[] args) {
            int[] data = {100,1,8,6,4,12,9,78,13,50,16,24,99,45,62,21,39};
            selectedSort(data);
            for (int i=0;i<data.length;i++){
                  System.out.println(data[i]);
            }
      }

      //简单选择排序实现
      public static void selectedSort(int[] data){
            int len = data.length;
            int max = 0;
            int index = 0;
            for (int i=0;i<len;i++){
                  index = i;
                  max = data[i];
                  for (int j = i+1;j<len;j++){
                        if (max>data[j]){
                              max = data[j];
                              index = j;
                        }
                  }
                  data[index] = data[i];
                  data[i] = max;
            }
      }
}

 

 
2.堆排序
    堆排序利用的是堆的性质来实现排序，什么是堆呢？堆其实就是完全二叉树，堆又分为大根堆（最大堆）和小根堆（最小堆）：
  1. 大根堆就是每个父节点的数据大于子节点中的数据。
  2. 小根堆则相反，每个父节点的数据小于子节点。
8be1632f6d33bd471ced7b0d7a9118e99b9.jpg e89501db93bd9b542402a4f8c4ffabad7df.jpg
 
    堆排序就是利用堆的特性来实现排序：每次将堆顶元素（即最大值或最小值），放在序列的最后面，然后再将剩余元素重新调整为大根堆（或小根堆），再取堆顶元素，以此类推，最终使序列有序。 

/**
* 排序的简单实现
* Created by bzhang on 2019/3/7.
*/
public class Sorted {

      public static void main(String[] args) {
            int[] data = {100,1,8,6,4,12,9,78,13};
            heapSort(data);
            for (int i=0;i<data.length;i++){
                  System.out.println(data[i]);
            }
      }

      //堆排序的简单实现
      public static void heapSort(int[] data){
            int len = data.length;
            int temp = 0;
            for (int i=len-1;i>=0;i--){
                  buildHeap(data,i+1);
                  temp = data[i];
                  data[i] = data[0];
                  data[0] = temp;
            }
      }

      //建立大根堆
      private static void buildHeap(int[] data, int len) {
            for (int i=len-1;i>0;i--){
                  int temp = 0;
                  if (data[i]>data[(i-1)/2]){
                        temp = data[i];
                        data[i] = data[(i-1)/2];
                        data[(i-1)/2] = temp;
                  }
            }
      }
}
 
 
五、归并排序
1.归并排序
    归并排序也是分治法的一个运用，它是通过先将分为n个（n为2就是二路归并，n>2则是多路归并）序列，再将每个子序列继续分为n个子序列的子序列，如此反复划分，直到每个序列中的元素<=m个（m>=2），是每个序列有序，在合并每个子序列。得到最终有序的序列。
   af2ff4477a4f08dd28c4f2dd46919bcecf8.jpg 
  
/**
* 排序的简单实现
* Created by bzhang on 2019/3/7.
*/
public class Sorted {

      public static void main(String[] args) {
            int[] data = {100,1,8,6,4,12,9,78,13,101,102,103,104,105,110};
            mergeSort(data);
            for (int i=0;i<data.length;i++){
                  System.out.println(data[i]);
            }
      }

      //归并排序的简单实现
      public static void mergeSort(int[] data){
            int high = data.length-1;
            int low = 0;
            int mid = (high+low)/2;
            forkAndMerge(data,low,mid,high);

      }
      //先分支成只有1或2个元素的序列进行排序，后在合并成一个序列
      private static void forkAndMerge(int[] data, int low, int mid, int high) {
            if (high-low<=1){
                  if (data[high]<data[low]){
                        int temp = data[high];
                        data[high] =data[low];
                        data[low] = temp;
                  }
                  return;
            }
            forkAndMerge(data,low,(low+mid)/2,mid);
            forkAndMerge(data,mid+1,(mid+1+high)/2,high);
            merge(data,low,mid,high);
      }


      //合并两个有序的子序列
      private static void merge(int[] data, int low, int mid, int high) {
            int len = high-low+1;
            int[] arrTemp = new int[len];
            int s = 0;
            for (int i=low,j=mid+1;i<=mid||j<=high;){
                  if (i>mid&&j<=high){
                        arrTemp[s++] = data[j];
                        j++;
                  }else if (i<=mid&&j>high){
                        arrTemp[s++] = data[i];
                        i++;
                  }else {
                        if (data[i]<=data[j]){
                              arrTemp[s++] = data[i];
                              i++;
                        }else {
                              arrTemp[s++] = data[j];
                              j++;
                        }
                  }
            }
            for (int i = 0;i<len;i++){
                  data[low+i] = arrTemp[i];
            }
      }
}

 

 
六、非比较排序
1.计数排序
    计数排序不是基于比较的排序算法，它是一种快捷稳定的排序方法， 计数排序对一定量的整数排序时候的速度非常快，一般快于其他排序算法。但计数排序 局限性比较大 ，只限于对整数进行排序，且局限在元素比较集中的情况。
    计数排序的基本原理是：找出待排序序列data的最大值max和最小值min，建立一个长度为max-min+1的数组temp，temp中存放data中min到max之间所有数在数组中的个数，最后将temp中存放的各个元素的数量按索引挨个填充会data中。 

/**
* 排序的简单实现
* Created by bzhang on 2019/3/7.
*/
public class Sorted {

      public static void main(String[] args) {
            int[] data = {6,3,8,22,33,16,18,24};
            countSort(data);
            for (int i=0;i<data.length;i++){
                  System.out.println(data[i]);
            }
      }

      //计数排序的简单实现
      public static void countSort(int[] data){
            int max = getMax(data);
            int min = getMin(data);
            int[] temp = new int[max-min+1];
            //统计min到max之间所有整数在data中出现的次数，存于temp数组中
            for (int i=0;i<data.length;i++){
                  int t = data[i];
                  temp[t-min]+=1;
            }
            int s = 0;
            //依次将temp中存的各个数放到data中。
            for (int i=0;i<temp.length;i++){
                  int k = temp[i];
                  while (k>0){
                        data[s++] = min+i;
                        k--;
                  }
            }
      }

      private static int getMax(int[] data) {
            int max = data[0];
            for (int i=1;i<data.length;i++){
                  if (max<data[i]){
                        max = data[i];
                  }
            }
            return max;
      }

      private static int getMin(int[] data) {
            int min = data[0];
            for (int i=1;i<data.length;i++){
                  if (min>data[i]){
                        min = data[i];
                  }
            }
            return min;
      }
}
 
 
2.桶排序
     桶排序是计数排序的升级版， 但桶排序要求数据的分布必须均匀，否则可能导致数据都集中到一个桶中。
    桶排序的基本原理：找出待排序序列的上下边界（最大值max和最小值min），将其划分为n个大小相同的子区间，各个子区间各自排序，最后合并。 

/**
* 排序的简单实现
* Created by bzhang on 2019/3/7.
*/
public class Sorted {

      public static void main(String[] args) {
            int[] data = {998,1998,2846,1694,4536,1766,8848,3369,6671};
            bucketSort(data);
            for (int i=0;i<data.length;i++){
                  System.out.println(data[i]);
            }
      }

      //桶排序的简单实现
      public static void bucketSort(int[] data){
            int max = getMax(data);
            int min = getMin(data);
            int len = data.length;
            int bucketSize = (max-min)/data.length+1; //桶的数量
            List<List<Integer>> buckets = new ArrayList<>(bucketSize);
            List<Integer> res = new ArrayList<>();
            //创建bucketSize个桶
            for(int i=0;i<bucketSize;i++){
                  buckets.add(new ArrayList<>());
            }

            for(int i=0;i<len;i++){
                  int index = (data[i]-min)/len;      //放到哪个桶中
                  buckets.get(index).add(data[i]);
            }
            for(int i=0;i<bucketSize;i++){
                  //对各个桶进行排序，可以使用任意一种排序方法，这里直接使用Collections工具类的排序方法
                  Collections.sort(buckets.get(i));
                  res.addAll(buckets.get(i));
            }
            int s = 0;
            for (int t:res) {
                  data[s++] = t;
            }
      }

      private static int getMax(int[] data) {
            int max = data[0];
            for (int i=1;i<data.length;i++){
                  if (max<data[i]){
                        max = data[i];
                  }
            }
            return max;
      }

      private static int getMin(int[] data) {
            int min = data[0];
            for (int i=1;i<data.length;i++){
                  if (min>data[i]){
                        min = data[i];
                  }
            }
            return min;
      }
}

 

2.基数排序
    基数排序的思想是按位比较，从最低位（个位）开始，比较后得到一个新序列，在新序列的基础上在比较次低位（十位），如此反复比较到最高位，即可得到一个有序的序列。
878f86547a76c5ca98896cf3b886d24139b.jpg 

/**
* 排序的简单实现
* Created by bzhang on 2019/3/7.
*/
public class Sorted {


      public static void main(String[] args) {
            int[] data = {998,19,2846,1694,536,1766,8848,9,6671};
            bucketSort(data);
            for (int i=0;i<data.length;i++){
                  System.out.println(data[i]);
            }
      }


      //基数排序的简单实现
      public static void radixSort(int[] data){
            int max = getMax(data);
            int num = getDigits(max);     //计算序列中最大数的位数
            int m = 1;
            for (int i=0;i<=num;i++){
                  m*=10;            //用于取各个位上的值，依次为10，100,1000。。。
                  radixSort(data,m);
            }
      }


      //根据各位置的大小进行排序，依次为个位，十位，百位，千位。。。
      private static void radixSort(int[] data, int m) {
            int temp = 0;
            for (int i= 0; i<data.length-2;i++){
                  if ((data[i]%m)/(m/10)>(data[i+1]%m)/(m/10)){
                        temp = data[i];
                        data[i] = data[i+1];
                        data[i+1] = temp;
                  }
            }
      }

      private static int getDigits(int max) {
            int num = 0;
            for (int i=1;;i*=10){
                  if (max/i>0){
                        num++;
                  }else {
                        return num;
                  }
            }
      }

      private static int getMax(int[] data) {
          int max = data[0];
          for (int i=1;i<data.length;i++){
                if (max<data[i]){
                      max = data[i];
                }
          }
          return max;
      }
}

 

转载于:https://my.oschina.net/bzhangpoorman/blog/3019931

weixin_34309435
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
韩顺平老师尚硅谷Java数据结构与算法194集笔记
10-12
这是我从B站上看韩老师讲的数据结构与算法后整理的笔记 代码经过运行，欢迎批评指正 有些地方我感觉还是挺难的 大都经过我自己的语言进行描述，韩老师中期的表达可能或多或少也影响可阅读性，望先生们见谅
数据结构与算法笔记.pdf
11-20
数据结构与算法笔记.pdf 数据结构与算法是计算机科学中两个紧密相关的概念。数据结构是指计算机中存储、组织和管理数据的方式，而算法是指解决问题的步骤和方法。在这份笔记中，我们将详细介绍算法的五个特性、算法...
数据结构与算法学习笔记（十二）——堆
weixin_43837952的博客
05-09 341
堆 1、堆是一个完全二叉树，堆中的每一个节点的值都必须大于等于（小于等于）其子树中每个节点的值。 2、每个节点的值都大于等于其子树中的每个节点的值，此为大顶堆。大顶堆的堆顶元素为最大的元素 3、每个节点的值都小于等于其子树中的每个节点的值，此为小顶堆。小顶堆的堆顶元素为最小元素 上图中的1、2均为大顶堆，3为小顶堆，4不是堆 查找、插入、删除 1、查找：堆是完全二叉树，因此堆的存储方式也是数组存储。因此只要知道一个节点就可以推出其他节点的存储位置。 2、插入：若直接往叶子节点中插入一个元素会使堆不满足堆的
数据结构与算法课程笔记（十二）
Motseturtle的博客
05-16 3434
实验十二 线性表查找一、 实验目的二、 实验环境三、 实验内容和步骤（根据ListInArray项目完成实验，已整合折半查找） 一、 实验目的 （1） 掌握顺序查找、折半查找、索引查找的算法思想； （2） 掌握折半查找算法的实现方法； （3） 分析折半查找成功和失败的条件； （4） 熟练应用折半查找。 二、 实验环境 Windows 7以上版本的操作系统，Visual Studio 2010版以上编程环境。 三、 实验内容和步骤（根据ListInArray项目完成实验，已整合折半查找） 下面所示是在序列{
leetcode 23 合并K个排序链表（Merge k Sorted Lists）
pirlo-san的博客
10-01 98
题目描述 Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity. Example: Input: [ 1->4->5, 1->3->4, 2->6 ] Output: 1->1->2->3->...
Merge Sort
03-12 110
character:the sort time is proportional to any input array with length of N. Introduction to merge:if two arrays are already sorted,after merge operation,the combined array is also sorted. the ...
《算法导论》——MergeSort
weixin_30686845的博客
07-16 131
前言： 　　在今后的日子里，我将持续更新博客，讨论《算法导论》一书中的提到的各算法的C++实现。初来乍到，请多指教。 今日主题：　　 　　今天讨论《算法导论》第二章算法基础中的归并排序算法。下面是该算法的代码Merge.h： 　　 #include <stdlib.h> namespace dksl { /* * 归并 * numArray为整形数组 ...
数据结构与算法学习笔记
ityqing的博客
09-25 33万+
本文是王争老师的《算法与数据结构之美》的学习笔记，详细内容请看王争的专栏。有不懂的地方指出来，我做修改。 数据结构与算法思维导图 数据结构指的是“一组数据的存储结构”，算法指的是“操作数据的一组方法”。 数据结构是为算法服务的，算法是要作用再特定的数据结构上的。 最常用的数据结构预算法: 数据结构：数组、链表、栈、队列、散列表、二叉树‘、堆、跳表、图、Tire树 算法： 递归...
数据结构——学习笔记——入门必看【建议收藏】
热门推荐
刘鑫磊
02-09 40万+
（2）静态查找表&动态查找表的区别用法【顺序查找-线性查找-折半查找-二分查找-有序表查找-插值查找-斐波那契查找-索引顺序表查找-分块查找】单独使用顺序存储结构（即数组）无法很好地实现树的存储概念，不过如果充分利用顺序存储和链式存储结构的特点，则完全可以实现对数的存储结构的表示。深度为 2，则至多只有 3 个结点：根结点，根结点的左子树，根结点的右子树···指的是这样一个数列：1、1、2、3、5、8、13、21、……（3）四中常见的多路查找树【2-3 树$2-3-4 树$B 树$B+ 树】的区别用法。
数据结构与算法笔记(1)
lqt214133的博客
04-01 2919
数据结构是一种存储和组织数据的方式，便于访问和修改。根据视点不同可以将其分为与。逻辑结构：数据对象中数据元素之间的相互关系1、集合结构：除同属于同一个集合外没有任何关系2、线性结构：数据元素之间为一对一的关系3、树形结构：元素存在一对多的关系4、图形关系：数据元素之间是多对多的关系物理结构：数据的的逻辑结构在计算机中方的存储形式也称“存储结构”1、顺序结构：数据元素存放在地址连续相同的存储单元中，其数据间的逻辑关系和物理关系是一致的。
数据结构与算法——知识点总结
记录知识，学习分享
06-02 2万+
本文包含数据结构与算法主要的基本知识点，便于知识的梳理和回顾。 如需详细了解具体知识点请自行结合课本或者网上查阅。 目录 1、概述 2、线性表 3、栈 4、队列 5、串 6、多维数组和广义表 7、树和二叉树 8、图 9、查找 10、排序 1、概述 从 2、线性表 3、栈 4、队列 5、串 6、多维数组和广义表 7、树和二叉树 8、图 9、查找 10、排序 ...
《王道》数据结构笔记整理2022
池鱼
08-21 21万+
数据结构第一章绪论1.1数据结构的基本概念1.2数据结构的三要素1.3算法的基本概念1.4算法的时间复杂度1.5算法的空间复杂度 第一章绪论 1.1数据结构的基本概念 1.数据：数据是信息的载体，是描述客观事物属性的数、字符以及所有能输入到计算机中并被程序识别和处理的符号的集合。 2.数据元素：数据元素是数据的基本单位，通常作为一个整体进行考虑和处理。一个数据元素可由若干数据项组成，数据项是构成数据元素的不可分割的最小单位。例如，学生记录就是一个数据元素，它由学号、姓名、性别等数据项组成。 3.数据对象:数
数据结构与算法笔记+LeetCode经典例题分析
11-02
这份资料集合了"数据结构与算法笔记"以及"LeetCode经典例题分析"，旨在深入理解和熟练运用这些概念。 首先，我们来看八大排序算法。这包括冒泡排序、插入排序、选择排序、快速排序、归并排序、堆排序、希尔排序和...
数据结构与算法Python版学习笔记一
12-21
在学习数据结构与算法的过程中，Python作为一种流行的编程语言，被广泛用于实现各种算法。这篇学习笔记主要关注在Python中处理输入输出（I/O）时的一些关键点，这对于在在线判题平台（Online Judge，简称OJ）上测试...
7.10飞书一面面经
最新发布
东篱君的博客
07-10 1197
B+树的⾮叶⼦节点不存放实际的记录数据，仅存放索引，所以数据量相同的情况下，相⽐存储即存索引⼜存记录的 B 树，B+树的⾮叶⼦节点可以存放更多的索引，因此 B+ 树可以⽐ B 树更「矮胖」，查询底层节点的磁盘 I/O次数会更少。主从复制：单节点Redis的并发能力是有上限的，要进一步提高Redis的并发能力，可以搭建主从集群，实现读写分离。B+ 树有⼤量的冗余节点（所有⾮叶⼦节点都是冗余索引），这些冗余索引让 B+ 树在插⼊、删除的效率都更⾼，⽐如删除根节点的时候，不会像 B 树那样会发⽣复杂的树的变化；
leetcode--验证二叉搜索树
liulanba的博客
07-09 675
给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。有效 二叉搜索树定义如下：节点的左子树只包含 小于 当前节点的数。节点的右子树只包含 大于 当前节点的数。所有左子树和右子树自身必须也是二叉搜索树。示例 1：输入：root = [2,1,3]输出：true示例 2：输入：root = [5,1,4,null,null,3,6]输出：false解释：根节点的值是 5 ，但是右子节点的值是 4。提示：树中节点数目范围在[1, 104] 内。
[高频 SQL 50 题(基础版)]第一千七百五十七题，可回收且低脂产品
weixin_45201305的博客
07-10 293
low_fats 是枚举类型，取值为以下两种 ('Y', 'N')，其中 'Y' 表示该产品是低脂产品，'N' 表示不是低脂产品。recyclable 是枚举类型，取值为以下两种 ('Y', 'N')，其中 'Y' 表示该产品可回收，而 'N' 表示不可回收。没什么难度，作为基础题五十题的第一题练手，现在也开始陆续写一些SQL，作为记录，和leetcode一起，大家都加油。编写解决方案找出既是低脂又是可回收的产品编号。是该表的主键（具有唯一值的列）。
力扣104题：二叉树最大深度
m0_56332819的博客
07-10 199
二叉树最大深度，C语言
java数据结构与算法笔记
07-25
Java数据结构与算法笔记是在学习B站尚硅谷Java数据结构与算法视频时所做的记录。\[1\]这个笔记包括了稀疏数组的作用和一个代码实例，以及不同时间复杂度的案例和空间复杂度的概念。\[2\]\[3\]在这个笔记中，你可以...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值