【尚硅谷】数据结构与算法——排序算法2.0

已于 2023-03-22 17:06:09 修改
阅读量452 收藏 1
点赞数
分类专栏： 数据结构与算法代码内容 文章标签： 排序算法 算法 java
于 2023-03-13 14:55:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54533016/article/details/129442580
版权

文章目录

前言

跟着B站的尚硅谷学习数据结构与算法，语言为java，目前是第九个代码内容——排序
课程传送门：尚硅谷——排序算法2.0

一、冒泡排序

1.基本介绍

冒泡排序（Bubble Sorting）的基本思想是：通过对待排序序列从前向后（从下标较小的元素开始），依次比较相邻元素的值，若发现逆序交换，使值较大的元素逐渐从前移向后部，就像水底下的水泡一样逐渐往上冒。

因为排序的过程中，各元素不断接近自己的位置，如果一趟比较下来没有进行交换，就说明序列有序，因此要在排序过程中设置一个标志 flag 判断元素是否进行过交换。从而减少不必要的比较。（这里说的优化，可以在冒泡排序写好后，再进行）

2.应用实例

我们举一个具体的案例来说明冒泡法，我们将五个无序的数： 3、9、-1、10、20

在这里插入图片描述
冒泡排序规则：
1）一共进行数组的 大小-1 次大的循环
2）每一趟排序的次数再逐渐的减少
3）如果发现再某次排序中，没有发生一次交换，可以提前结束冒泡排序，这就是优化。

使用冒泡排序法将其排成一个从小到大的有序数列。

package com.sort;


import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;

public class BubbleSort {
    public static void main(String[] args) {
        int arr[] = {3,9,-1,10,20};

        //为了容量理解，我们把冒泡排序的演变过程展示给大家

        //测试
        System.out.println("排序前");
        System.out.println(Arrays.toString(arr));

        bubbleSort(arr);

        System.out.println("排序后");
        System.out.println(Arrays.toString(arr));


    }

    public static void bubbleSort(int arr[]){
        //第一场排序，就是将最大的数排在最后
        int temp = 0;
        boolean flag = false;
        for (int i = 0; i < arr.length-1; i++){
            for (int j = 0; j < arr.length - 1 - i; j++){
                //如果前面的数比后面的数大，则交换
                if (arr[j] > arr[j+1]){
                    flag = true;
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }

            System.out.println("第" + (i+1) + "趟排序后的数组");
            System.out.println(Arrays.toString(arr));

            if (!flag){
                break;
            }else {
                flag = false;
            }
        }
    }
}

3.速度测试

package com.sort;


import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = new int[80000];
        for (int i = 0; i < 80000; i++){
            arr[i] = (int)(Math.random() * 8000000);
        }

        Date data1 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-mm-dd HH:mm:ss");
        String date1Str = simpleDateFormat.format(data1);
        System.out.println("排序前的时间是 = " + date1Str);

        bubbleSort(arr);

        Date data2 = new Date();
        String date2Str = simpleDateFormat.format(data2);
        System.out.println("排序后的时间是 = " + date2Str);
    }

    public static void bubbleSort(int arr[]){
        //第一场排序，就是将最大的数排在最后
        int temp = 0;
        boolean flag = false;
        for (int i = 0; i < arr.length-1; i++){
            for (int j = 0; j < arr.length - 1 - i; j++){
                //如果前面的数比后面的数大，则交换
                if (arr[j] > arr[j+1]){
                    flag = true;
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }

            if (!flag){
                break;
            }else {
                flag = false;
            }
        }
    }
}

二、选择排序

1.基本介绍

选择排序（select sorting）也是一种简单的排序方法。它的基本思路是：第一次从 arr[0]~arr[n-1] 中选取最小值，与 arr[0] 交换，第二次从 arr[1]~arr[n-1] 中选取最小值，与 arr[1] 交换，第三次从 arr[2]~arr[n-1] 中选取最小值，与 arr[2] 交换，…，第 i 次从 arr[i]~arr[n-1] 中选取最小值，与 arr[i] 交换。总共经过 n-1 次，得到一个按排序码从小到大排序的有序列表。

在这里插入图片描述

2.应用实例

有一群牛，颜值分别是101，34，119，1 请使用选择排序从低到高进行排序[ 101, 34, 119, 1]

在这里插入图片描述
选择排序规则：
1.选择排序一共有数组大小-1 轮排序
2.每 1 轮排序，又是一个循环
-先假定当前的这个数是最小数
-然后和后面的每一个数作比较，如果发现有当前数更小的数，就重新确定最小数，并得到下标
-当遍历到数组的最后时，就得到本轮最小数和下标
-交换（代码）

package com.sort;

import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;

public class SelectSort {
    public static void main(String[] args) {
        int[] arr = {101,34,119,1,-1,2,5,778};

        System.out.println("排序前");
        System.out.println(Arrays.toString(arr));

        selectSort(arr);

        System.out.println("排序后");
        System.out.println(Arrays.toString(arr));
    }

    //选择排序
    public static void selectSort(int[] arr){
        //在推导的过程中，有所规律
        for (int i = 0; i < arr.length; i++){
            int minIndex = i;
            int min = arr[i];
            for (int j = i + 1; j < arr.length;j++){
                if (min > arr[j]){
                    min = arr[j];
                    minIndex = j;
                }
            }

            //将最小值放在arr[0]，即交换
            if (minIndex != i){
                arr[minIndex] = arr[i];
                arr[i] = min;
            }

            System.out.println("第"+ i +"轮后");
            System.out.println(Arrays.toString(arr));
        }


        //使用逐步推导的方式来，讲解选择排序
        //第一轮
        //原始数组： 101 34 119 1
        //第一轮排序： 1 34 119 101
        //算法：先简单后复杂，就是把一个复杂的算法，拆分成简单的问题

//        //第一轮
//        int minIndex = 0;
//        int min = arr[0];
//        for (int j = 0 + 1; j < arr.length;j++){
//            if (min > arr[j]){
//                min = arr[j];
//                minIndex = j;
//            }
//        }
//
//        //将最小值放在arr[0]，即交换
//        if (minIndex != 0){
//            arr[minIndex] = arr[0];
//            arr[0] = min;
//        }
//
//        System.out.println("第一轮后");
//        System.out.println(Arrays.toString(arr));
//
//        //第二轮
//        minIndex = 1;
//        min = arr[1];
//        for (int j = 1 + 1; j < arr.length;j++){
//            if (min > arr[j]){
//                min = arr[j];
//                minIndex = j;
//            }
//        }
//
//        //将最小值放在arr[0]，即交换
//        if (minIndex != 1){
//            arr[minIndex] = arr[1];
//            arr[1] = min;
//        }
//
//
//        System.out.println("第二轮后");
//        System.out.println(Arrays.toString(arr));
//
//        //第三轮
//        minIndex = 2;
//        min = arr[2];
//        for (int j = 2 + 1; j < arr.length;j++){
//            if (min > arr[j]){
//                min = arr[j];
//                minIndex = j;
//            }
//        }
//
//        //将最小值放在arr[0]，即交换
//        if (minIndex != 2){
//            arr[minIndex] = arr[2];
//            arr[2] = min;
//        }
//
//
//        System.out.println("第三轮后");
//        System.out.println(Arrays.toString(arr));
    }
}

3.速度测试

package com.sort;

import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;

public class SelectSort {
    public static void main(String[] args) {
        int[] arr = new int[80000];
        for (int i = 0; i < 80000; i++){
            arr[i] = (int)(Math.random() * 8000000);
        }

        Date data1 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-mm-dd HH:mm:ss");
        String date1Str = simpleDateFormat.format(data1);
        System.out.println("排序前的时间是 = " + date1Str);

        selectSort(arr);

        Date data2 = new Date();
        String date2Str = simpleDateFormat.format(data2);
        System.out.println("排序后的时间是 = " + date2Str);
    }

    //选择排序
    public static void selectSort(int[] arr){
        //在推导的过程中，有所规律
        for (int i = 0; i < arr.length; i++) {
            int minIndex = i;
            int min = arr[i];
            for (int j = i + 1; j < arr.length; j++) {
                if (min > arr[j]) {
                    min = arr[j];
                    minIndex = j;
                }
            }

            //将最小值放在arr[0]，即交换
            if (minIndex != i) {
                arr[minIndex] = arr[i];
                arr[i] = min;
            }

        }
    }
}

三、插入排序

插入式排序属于内部排序法，是对于排序的元素以插入的方式找寻该元素的适当位置，以达到排序的目的。

1.基本介绍

插入排序（Insertion Sorting）的基本思想是：把 n 个待排序的元素看成为一个有序表和一个无序表，开始时有序表中只包含一个元素，无序表中包含 n-1 个元素，排序过程中每次从无序表中取出第一个元素，把它的排序码依次与有序表元素的排序码进行比较，将它插入到有序表中的适当位置，使之称为新的有序表。

2.应用实例

有一群小牛，考试成绩分别是：101，34，119，1 请从小到大排序

ppackage com.sort;

import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;

public class InsertSort {
    public static void main(String[] args) {
        int[] arr = {101,34,119,1};
        insertSort(arr);
    }

    //插入排序
    public static void insertSort(int[] arr){
        //使用逐步推导的方法来讲解，便于理解
        for (int i = 0; i < arr.length; i++){
            int insertVal = arr[i];
            int insertIndex = i - 1;

            while (insertIndex >= 0 && insertVal < arr[insertIndex]){
                arr[insertIndex + 1] = arr[insertIndex];
                insertIndex--;
            }
            //当退出while循环时，说明插入的位置找到， insertIndex + 1
            if (insertIndex + 1 != i){
                arr[insertIndex + 1] = insertVal;
            }


            System.out.println("第" + i + "轮排序");
            System.out.println(Arrays.toString(arr));
        }



        //第一轮{101,34,119,1} => {34,101,119,1}
        //定义待插入的数
//        int insertVal = arr[1];
//        int insertIndex = 1 - 1;
//
//        //说明
//        //1.insertIndex >= 0 保证在给insertVal找插入值的时候不越界
//        //2.insertVal < arr[insertIndex] 待插入的数，还没有找到插入位置
//        //3.就需要持 arr[insertIndex] 后移
//        while (insertIndex >= 0 && insertVal < arr[insertIndex]){
//            arr[insertIndex + 1] = arr[insertIndex];
//            insertIndex--;
//        }
//        //当退出while循环时，说明插入的位置找到， insertIndex + 1
//        arr[insertIndex + 1] = insertVal;
//
//        System.out.println("第一轮排序");
//        System.out.println(Arrays.toString(arr));
//
//        //第二轮
//        insertVal = arr[2];
//        insertIndex = 2 - 1;
//
//        while (insertIndex >= 0 && insertVal < arr[insertIndex]){
//            arr[insertIndex + 1] = arr[insertIndex];
//            insertIndex--;
//        }
//        //当退出while循环时，说明插入的位置找到， insertIndex + 1
//        arr[insertIndex + 1] = insertVal;
//
//        System.out.println("第二轮排序");
//        System.out.println(Arrays.toString(arr));
//
//        //第三轮
//        insertVal = arr[3];
//        insertIndex = 3 - 1;
//
//        while (insertIndex >= 0 && insertVal < arr[insertIndex]){
//            arr[insertIndex + 1] = arr[insertIndex];
//            insertIndex--;
//        }
//        //当退出while循环时，说明插入的位置找到， insertIndex + 1
//        arr[insertIndex + 1] = insertVal;
//
//        System.out.println("第三轮排序");
//        System.out.println(Arrays.toString(arr));
    }
}

3.速度测试

package com.sort;

import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;

public class InsertSort {
    public static void main(String[] args) {

        int[] arr = new int[80000];
        for (int i = 0; i < 80000; i++){
            arr[i] = (int)(Math.random() * 8000000);
        }

        Date data1 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-mm-dd HH:mm:ss");
        String date1Str = simpleDateFormat.format(data1);
        System.out.println("排序前的时间是 = " + date1Str);

        insertSort(arr);

        Date data2 = new Date();
        String date2Str = simpleDateFormat.format(data2);
        System.out.println("排序后的时间是 = " + date2Str);
    }

    //插入排序
    public static void insertSort(int[] arr){
        //使用逐步推导的方法来讲解，便于理解
        for (int i = 0; i < arr.length; i++){
            int insertVal = arr[i];
            int insertIndex = i - 1;

            while (insertIndex >= 0 && insertVal < arr[insertIndex]){
                arr[insertIndex + 1] = arr[insertIndex];
                insertIndex--;
            }
            //当退出while循环时，说明插入的位置找到， insertIndex + 1
            if (insertIndex + 1 != i){
                arr[insertIndex + 1] = insertVal;
            }
        }
    }
}

四、希尔排序

希尔排序是希尔（DonaldShell）于 1959 年提出的一种排序算法，希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一种更高效的版本，也称为缩小增量排序。

1.基本介绍

希尔是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至 1 时，整个文件给分成一组，算法便终止。

在这里插入图片描述
在这里插入图片描述

2.应用实例

有一群小牛，考试成绩分别是 {8，9，1，7，2，3，5，4，6，0} 请从小到大排序，请分别使用
1）希尔排序时，对有序序列在插入时采用交换法，并测试排序速度
2）希尔排序时，对有序列表在插入时采用移动法，并测试排序速度

1）交换法

package com.sort;

import java.util.Arrays;

public class ShellSort {
    public static void main(String[] args) {
        int[] arr = {8,9,1,7,2,3,5,4,6,0};
        shellSort(arr);
    }

    public static void shellSort(int[] arr){
        int temp = 0;

        //根据规律可得
        for (int gap = arr.length / 2; gap > 0; gap /= 2){
            for (int i = gap; i < arr.length; i++){
                //遍历各组中所有的元素（共arr.length / 2组）
                for (int j = i - gap; j >= 0; j -= gap){
                    //如果当前元素大于加上步长后的那个元素，说明交换
                    if (arr[j] > arr[j+gap]){
                        temp = arr[j];
                        arr[j] = arr[j+gap];
                        arr[j+gap] = temp;
                    }
                }
            }
            System.out.println("希尔排序第 " + gap + " 轮后 = " + Arrays.toString(arr));

        }


//        //第一轮
//        //将10个数分成五份
//        for (int i = 5; i < arr.length; i++){
//            //遍历各组中所有的元素（共五组，每组两个元素）
//            for (int j = i -5; j >= 0; j-=5){
//                //如果当前元素大于加上步长后的那个元素，说明交换
//                if (arr[j] > arr[j+5]){
//                    temp = arr[j];
//                    arr[j] = arr[j+5];
//                    arr[j+5] = temp;
//                }
//            }
//        }
//        System.out.println("希尔排序第一轮后 = " + Arrays.toString(arr));
//
//        //第2轮
//        //将10个数分成2份
//        for (int i = 2; i < arr.length; i++){
//            //遍历各组中所有的元素（共五组，每组两个元素）
//            for (int j = i -2; j >= 0; j -= 2){
//                //如果当前元素大于加上步长后的那个元素，说明交换
//                if (arr[j] > arr[j+2]){
//                    temp = arr[j];
//                    arr[j] = arr[j+2];
//                    arr[j+2] = temp;
//                }
//            }
//        }
//        System.out.println("希尔排序第二轮后 = " + Arrays.toString(arr));
//
//        //第3轮
//        //将10个数分成3份
//        for (int i = 1; i < arr.length; i++){
//            //遍历各组中所有的元素（共五组，每组两个元素）
//            for (int j = i - 1; j >= 0; j -= 1){
//                //如果当前元素大于加上步长后的那个元素，说明交换
//                if (arr[j] > arr[j+1]){
//                    temp = arr[j];
//                    arr[j] = arr[j+1];
//                    arr[j+1] = temp;
//                }
//            }
//        }
//        System.out.println("希尔排序第三轮后 = " + Arrays.toString(arr));

    }
}

2）移动法

package com.sort;

import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;

public class ShellSort {
    public static void main(String[] args) {
        int[] arr = {8,9,1,7,2,3,5,4,6,0};
        
       // shellSort(arr);
        shellSort2(arr);
    }

    
    //对交换式的希尔排序进行优化 -> 移位法
    public static void shellSort2(int[] arr){
        //增量gap，并逐步缩小
        for (int gap = arr.length / 2; gap > 0; gap /= 2){
            //从第gap个元素，逐个对其所在的组进行直接插入排序
            for (int i = gap; i < arr.length; i++){
                int j = i;
                int temp = arr[j];
                if (arr[j] < arr[j-gap]){
                    while(j - gap >= 0 && temp < arr[j - gap]){
                        //移动
                        arr[j] = arr[j-gap];
                        j -= gap;
                    }
                    //当退出while后，就给temp找到插入的位置
                    arr[j] = temp;
                }
            }
            System.out.println("希尔排序第 " + gap + " 轮后 = " + Arrays.toString(arr));
        }
    }
}

3.速度测试

1）交换法

package com.sort;

import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;

public class ShellSort {
    public static void main(String[] args) {

        int[] arr = new int[80000];
        for (int i = 0; i < 80000; i++){
            arr[i] = (int)(Math.random() * 8000000);
        }

        Date data1 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-mm-dd HH:mm:ss");
        String date1Str = simpleDateFormat.format(data1);
        System.out.println("排序前的时间是 = " + date1Str);

        shellSort(arr);

        Date data2 = new Date();
        String date2Str = simpleDateFormat.format(data2);
        System.out.println("排序后的时间是 = " + date2Str);
    }

    public static void shellSort(int[] arr){
        int temp = 0;

        //根据规律可得
        for (int gap = arr.length / 2; gap > 0; gap /= 2){
            for (int i = gap; i < arr.length; i++){
                //遍历各组中所有的元素（共arr.length / 2组）
                for (int j = i - gap; j >= 0; j -= gap){
                    //如果当前元素大于加上步长后的那个元素，说明交换
                    if (arr[j] > arr[j+gap]){
                        temp = arr[j];
                        arr[j] = arr[j+gap];
                        arr[j+gap] = temp;
                    }
                }
            }
        }
        
    }
}

2）移动法

package com.sort;

import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;

public class ShellSort {
    public static void main(String[] args) {
//        int[] arr = {8,9,1,7,2,3,5,4,6,0};

        int[] arr = new int[80000];
        for (int i = 0; i < 80000; i++){
            arr[i] = (int)(Math.random() * 8000000);
        }

        Date data1 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-mm-dd HH:mm:ss");
        String date1Str = simpleDateFormat.format(data1);
        System.out.println("排序前的时间是 = " + date1Str);

       // shellSort(arr);
        shellSort2(arr);

        Date data2 = new Date();
        String date2Str = simpleDateFormat.format(data2);
        System.out.println("排序后的时间是 = " + date2Str);
    }

    public static void shellSort(int[] arr){
        int temp = 0;

        //根据规律可得
        for (int gap = arr.length / 2; gap > 0; gap /= 2){
            for (int i = gap; i < arr.length; i++){
                //遍历各组中所有的元素（共arr.length / 2组）
                for (int j = i - gap; j >= 0; j -= gap){
                    //如果当前元素大于加上步长后的那个元素，说明交换
                    if (arr[j] > arr[j+gap]){
                        temp = arr[j];
                        arr[j] = arr[j+gap];
                        arr[j+gap] = temp;
                    }
                }
            }
           // System.out.println("希尔排序第 " + gap + " 轮后 = " + Arrays.toString(arr));

        }


}

    //对交换式的希尔排序进行优化 -> 移位法
    public static void shellSort2(int[] arr){
        //增量gap，并逐步缩小
        for (int gap = arr.length / 2; gap > 0; gap /= 2){
            //从第gap个元素，逐个对其所在的组进行直接插入排序
            for (int i = gap; i < arr.length; i++){
                int j = i;
                int temp = arr[j];
                if (arr[j] < arr[j-gap]){
                    while(j - gap >= 0 && temp < arr[j - gap]){
                        //移动
                        arr[j] = arr[j-gap];
                        j -= gap;
                    }
                    //当退出while后，就给temp找到插入的位置
                    arr[j] = temp;
                }
            }
            //System.out.println("希尔排序第 " + gap + " 轮后 = " + Arrays.toString(arr));
        }
    }
}

总结

以上就是本章要讲的内容，本文仅仅简单复述了老师讲课的文本内容，内容有误麻烦联系。

大鱼-
关注
专栏目录
面向对象（上）（尚硅谷）
sch19990320的博客
08-27 332
尚硅谷面向对象
尚硅谷Java数据结构与算法第二章——数据结构和算法概述
yw_1121的博客
04-15 168
尚硅谷Java数据结构与算法第二章——数据结构和算法概述
C++ 排序算法
afl291529699的博客
08-20 142
C++ 常见排序算法 /*! @brief 冒泡排序 * * 算法之原理： 相邻的数据进行两两比较，小数放在前面，大数放在后面, * 这样一趟下来，最小的数就被排在了第一位，第二趟也是如此，如此类推，直到所有的数据排序完成。 \n * 时间复杂度： 平均 O(n^2) 最坏 O(n^2) \n * 空间复杂度： O(1) \n * 算...
数据结构与算法(13):插入排序(介绍,实例,推导代码)
qq_42400763的博客
09-17 195
一:插入排序 插入排序算法的介绍: 插入法排序属于内部排序法,是对于预排序的元素以插入的方式找寻该元素的适当位置,然后达到排序的目的 插入排序的基本思想 插入排序的基本思想:把N个待排序的元素看成一个有序表和一个无序表,开始时有序表中只包含一个元素,无序表中包含有n-1个元素,排序过程中每次从无序表中取出第一个元素,把它的排序码,依次与有序表的元素的排序码进行比较,将它插入到有序表中的适当位置,使之成为新的有序表. **理解:**从无序表中每次挑出一个元素,并在有序表中进行排序 二:插入排序的应用实例
Java数据结构与算法（六）：排序
风信子
10-20 304
1. 介绍 排序也称排序算法，排序是将一组数据，依指定的顺序进行排列的过程。 2. 分类 内部排序：指将需要处理的所有数据都加载到 内部存储器（内存） 中进行排序。 外部排序：数据量过大，无法全部加载到内存中，需要借助 外部存储（文件等） 进行排序； 3. 算法的时间复杂度 3.1 度量一个程序（算法）执行时间的方法 事后统计的方法 该方法可行，但是有两个问题：一是要想对设计的算法的运行性能进行评测，需要实际运行该程序；二是所得时间的统计量依赖于计算机的硬件、软件等环境因素，这种方式，要在同一台计算
八大排序算法 详细注释
mrhanzhou5273的博客
03-18 168
1. 排序算法的介绍和基本知识 1.1 内排序和外排序 内排序是指待排序序列完全存放在内部寄存器中（如内存）进行排序的过程 外排序是指待排序的数据元素过多，必须把他们放在外部寄存器上（如文件）。排序过程中需要借助外寄存器。   1.2 稳定排序和不稳定排序 若对于任意一组序列，相同关键字之间前后的位置关系在排序前后保持一致，则为稳定排序。如（1,5,3,2,3’），排序后如果是（1,2,3,3’,5），则为稳定排序，如果是（1,2,3’,3,5），则为不稳定排序。 我们在实际运用中，可能会针对一个对象的
Vue2.0+Vue3.0从入门到精通（尚硅谷学习笔记）--Vue2.0
qq_48105178的博客
10-20 1743
尚硅谷Vue2.0学习笔记
【尚硅谷】chapter1 Vue核心_尚硅谷Vue2.0+Vue3.0全套教程丨vuejs从入门到精通
qq_37581764的博客
10-04 912
Vue基础Vue-cli 做工程开发Vue-router 在Vue中实现前端入门Vuex 保管数据element-ui ui组件库Vue是一套用于构建用户界面的渐进式JavaScript框架构建用户界面：提供数据，前端需要通过界面展示出来渐进式：Vue可以自底向上逐层应用简单应用：只需一个轻量小巧的核心库复杂应用：可以引入各式各样的Vue插件MVVM模型M: 模型 model 对应data中的数据V：视图View 模版VM：视图模型ViewModel，Vue实例对象。
尚硅谷vue全家桶（vue2+vue3）笔记
hyx_1225的博客
07-26 526
对要显示的数据进行特定格式化后再显示（适用于一些简单逻辑的处理）。何时会被调用？指令与元素成功绑定时（一开始）指令所在的模板被重新解析时（注意不是依赖数据改变时，区分与computed）【钩子函数参数】el：指令所绑定的元素，可以用来直接操作 DOM。binding：一个对象，包含以下 property：name：指令名，不包括v-前缀。value中，绑定值为2。oldValue：指令绑定的前一个值，仅在update和钩子中可用。无论值是否改变都可用。expression。
尚硅谷JAVA基础笔记吐血整理
jiey0407的博客
06-22 1776
第1章 JAVA语言概述第2章 基本语法第3章 数组形参：方法定义时，声明的小括号内的参数实参：方法调用时，实际传递给形参的数据方法的形参传递机制：值传递如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值相同点：1、定义变量的格式：数据类型 变量名=变量值2、先声明后使用3、变量都有其作用域不同点：1、在类中声明的位置不同，属性直接定义在类的{}内，局部变量声明在方法内，方法形参，代码块内，构造器 形参、构造器内部的变量2、权限修
尚硅谷 SpringCloud 第二季学习笔记【已完结】
m0_54850467的博客
06-22 1746
https://spring.io/projects/spring-cloud#overview更详细的版本对应查看方法：https://start.spring.io/actuator/info题外话：boot版已经到2.2.4为最新，为什么选2.2.2？ SpringCloud和SpringBoot版本对应关系以前：现在（2020年）：约定 > 配置 > 编码 如果有依赖下载不下来就先把 pom 文件中的 注释掉，等下载完成后在取消注释即可Maven中的DependencyManagement和De
尚硅谷java基础（上）涛哥
2301_80072871的博客
07-26 172
涛
Java 学习路线大全，再也不用迷路啦（持续更新）
腾讯全栈-ITCJF
10-14 2773
路线特点 最新，完整一条龙，从入门到入土（⭐ 表示推荐学习） 给出目标、学习建议、关键知识点、最优资源以及各类资源推荐（视频、书籍、文档、项目、工具等） 划分阶段、更有计划，且在最后给出持续学习的方向、探索 Java 程序员发展的无限可能 前言 首先呢，我们要了解 Java 的应用场景和就业方向，看看和自己的学习目的是否一致，目前，Java 的岗位需求多，是后台开发的主流编程语言，功能强大，还是很值得学习的。 阶段 1：Java 入门 目标 培养兴趣、快速上手 前期准备 准备好一款在线、随时随地
Day02_JUC面试题(尚硅谷)
weixin_45014721的博客
08-19 2131
1.什么是指令重排？指令重排：在实际运行时，代码指令可能并不是严格按照代码语句顺序执行的。大多数现代微处理器都会采用将指令乱序执行，在条件允许的情况下，直接运行当前有能力立即执行的后续指令，避开获取下一条指令所需数据时造成的等待。通过乱序执行的技术，处理器可以大大提高执行效率。而这就是指令重排。int x=1;①int y=2;②x=x+5;③y=x*x;④//我们期望的执行顺序是①②③④，但可能执行的顺序会变成②①③④等//可不可能是 ④①②③？
【算法】冒泡排序
博客不会写，怎么办？抓紧练习咯！
09-12 406
冒泡排序是一种简单的排序算法，基本思想是通过重复遍历待排序的数列，比较相邻元素并交换它们的位置，以将较大（较小）的元素 “冒泡” 到数列的末端。最好的情况：O(n) ，此时说明我们的数据已经处于一个有序的状态。1、稳定性：即相等的元素在排序后仍保持原有的顺序性。2、简单：实先简单，易理解，不易使用在大型数据中。最坏和平均的情况：O(n的2次方)四、java代码示例。
从零开始学数据结构系列之第六章《希尔排序》
铁匠匠匠的博客
09-14 921
​ 希尔排序是对插入排序的优化，基本思路是先选定一个整数作为增量，把待排序文件中的所有数据分组，以每个距离的等差数列为一组，对每一组进行排序，然后将增量缩小，继续分组排序，重复上述动作，直到增量缩小为1时，排序完正好有序。​ 我们发现，当被排序的对象越接近有序时，插入排序的效率越高，那我们是否有办法将数组变成接近有序后再用插入排序，此时希尔大佬就发现了这个排序算法，并命名为希尔排序。逆序有序的数组排序时，时间复杂度为O ( n 2 ) O(n^2)O(n 2)，此时效率最低。如果是最开始的分组方法的话。
排序算法-交换排序
weixin_74312694的博客
09-16 979
1. 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序2. 时间复杂度：O(N*logN)如果还想了解更多排序欢迎大家前往我的主页。
【数据结构】排序算法---希尔排序
最新发布
2301_80191662的博客
09-16 1348
希尔排序的详细讲解，还含有动图演示
C#数据结构与算法实战——基于.NET Framework 2.0
"C#数据结构和算法的经典书籍，适合深入学习C#的读者，以C#语言和.NET Framework 2.0版本为基础编写。" 本文档介绍的是一本关于C#数据结构和算法的经典教程，它填补了国内C#语言讲解数据结构教材的空白。作者在编写...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值