数据结构：第二章（二）

已于 2022-10-06 10:17:02 修改
阅读量490 收藏 8
点赞数 3
分类专栏： 数据结构与算法 文章标签： java 数据结构 算法
于 2022-04-24 20:38:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49883619/article/details/124291807
版权

视频链接：https://www.bilibili.com/video/BV1HQ4y1d7th

视频范围P65 - P86

目录描述

1.冒泡排序

思想：通过对待排序序列从前往后依次比较相邻元素值，若发现逆序则交换，使值较大的元素从前逐步移向后面，就像水中气泡

package sort;

import java.util.Arrays;

public class BubblingSort {
    public static void main(String[] args) {
        int[] arrays = new int[]{4,5,6,3,2,1};

        //第一层for循环控制行数
        for (int i = 0; i < arrays.length - 1; i++) {
            //控制比较次数
            for (int j = 0; j < arrays.length - 1 - i; j++) {
                if (arrays[j] > arrays[j + 1]){
                    int temp = 0;
                    temp = arrays[j];
                    arrays[j] = arrays[j + 1];
                    arrays[j + 1] = temp;
                }
            }
        }

        System.out.println(Arrays.toString(arrays));//输出为：[1, 2, 3, 4, 5, 6]
    }
}

2.快速排序

  1. 快速排序是对冒泡排序的一种改进。
  2. 通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另一部分所有的数据都要小,然后再按此方法对这两部分数据分别进行快速排序
  3. 整个排序过程可以递归进行，以此达到整个数据变成有序序列

思想演示图：

在这里插入图片描述

package QuickSort;

import java.awt.*;
import java.util.Arrays;
import java.util.Scanner;

public class QuickSort {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String str = in.nextLine();

        String[] results = str.split(",");

        int[] arrays = new int[results.length];

        for (int i = 0; i < results.length ; i++) {
            arrays[i] = Integer.parseInt(results[i]);
        }

        sort(arrays,0,arrays.length - 1);

        System.out.println(Arrays.toString(arrays));

    }


    private static void sort(int[] arrays, int low, int high) {
        int i,j,pivot;

        if (low >= high){
            return;
        }

        i = low;
        j = high;

        //选择节点，这里选择数组的第一个数作为节点
        pivot = arrays[low];

        while (i < j){
            //从右往左找比节点小的数，循环结束要么找到了，要么i = j
            while(arrays[j] >= pivot && i < j){
                j--;
            }
            //从左往右找比节点大的数，循环结束要么找到了，要么i = j
            while (arrays[i] <= pivot && i < j){
                i++;
            }
            //如果i!=j说明都找到了，就交换这两个数
            if(i < j){
                int temp = arrays[i];
                arrays[i] = arrays[j];
                arrays[j] = temp;
            }
        }

        //i==j 一轮循环结束，交换节点的数和相遇点的数
        arrays[low] = arrays[i];
        arrays[i] = pivot;
        //数组分两半，再重复上面操作
        sort(arrays,low,i - 1);
        sort(arrays,i + 1,high);
    }
}

3.插入排序

插入排序属于内部排序，是对于排序的元素以插入的方式寻找该元素的适当位置，以达到排序的目的。
在这里插入图片描述

package sort;

import java.util.Arrays;

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

        int[] arrays = new int[]{2,5,6,3,4,7,8};

        //获取每一个元素
        for (int i = 1; i < arrays.length; i++) {
            //比较次数
            for (int j = i; j >= 1 ; j--) {
                if (arrays[j] < arrays[j - 1]){
                    int temp = 0;
                    temp = arrays[j];
                    arrays[j] = arrays[j - 1];
                    arrays[j - 1] = temp;
                }else {
                    break;
                }
            }
        }
        System.out.println(Arrays.toString(arrays));//输出为：[2, 3, 4, 5, 6, 7, 8]
    }
}

4.选择排序

选择排序也属于内部排序法，是从预排序的数据中按指定的规则选择某一个元素，再以规则交换位置后达到的排序目的。
在这里插入图片描述

package sort;

import java.util.Arrays;

public class SelectSort {
    public static void main(String[] args) {
        int[] arrays = new int[]{3,2,4,5,6,8,7,1};

        for (int i = 0; i < arrays.length; i++) {
            for (int j = arrays.length - 1; j > i; j--) {
                if (arrays[j] < arrays[i]){
                    int temp = 0;
                    temp = arrays[j];
                    arrays[j] = arrays[i];
                    arrays[i] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arrays));//输出为：[1, 2, 3, 4, 5, 6, 7, 8]
    }
}

5.希尔排序

  1. 希尔排序(Shell’s Sort)是插入排序的一种，又称“缩小增量排序”(Diminishing IncrementSort)是插入排序算法的一种更高效的改进版本，该方法因D.L.Shell于1959年提出而得名
  2. 希尔排序是非稳定排序算法
  3. 希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序;随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

在这里插入图片描述

package sort;

import java.util.Arrays;

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

        //实现增量的变化
        for (int gap = arrays.length / 2; gap > 0 ; gap /= 2) {
            for (int i = gap; i < arrays.length; i++) {
                for (int j = i - gap; j >= 0; j -= gap) {
                    if (arrays[j] > arrays[j + gap]){
                        int temp = 0;
                        temp = arrays[j];
                        arrays[j] = arrays[j + gap];
                        arrays[j + gap] = temp;
                    }
                }
            }
        }
        System.out.println(Arrays.toString(arrays));//输出为：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    }
}

6.归并排序

  1. 归并排序（Merge Sort）是建立在归并操作上的一种有效，稳定的排序算法
  2. 该算法是采用分治法（Divide and Conquer）的一个非常典型的应用
  3. 将已有序的子序列合并，得到完全有序的序列;即先使每个子序列有序，再使子序列段间有序
  4. 若将两个有序表合并成一个有序表，称为二路归并。

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

 package sort;

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

public class MSort {
    public static void main(String[] args) {
        int[] array = new int[]{6,9,4,7,1,2,0,5,3,8};
        //临时数组
        int[] temp = new int[array.length];

        sort(array,0,array.length - 1,temp);

        System.out.println(Arrays.toString(array));//输出为：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

    }

    public static void sort(int[] array,int left,int right,int[] temp){
        if (left < right){
            //求出中间值
            int mid = (left + right) / 2;

            //向左边分解
            sort(array,left,mid,temp);

            //向右边分解
            sort(array,mid + 1,right,temp);

            //合并数据
            sum(array,left,right,mid,temp);
        }
    }

    //合并数据
    public static void sum(int[] array,int left,int right,int mid,int[] temp){
        int i = left;
        int j = mid + 1;

        //指向临时数组下标
        int t = 0;

        //开始循环比较左右两边数组元素
        while (i <= mid && j <= right){
            if (array[i] <= array[j]){
                temp[t] = array[i];
                t++;
                i++;
            }else {
                temp[t] = array[j];
                t++;
                j++;
            }
        }

        //把剩余的元素直接存放在临时数组中
        while (i <= mid){
            temp[t] = array[i];
            t++;
            i++;
        }

        while (j <= right){
            temp[t] = array[j];
            t++;
            j++;
        }

        //将临时数组中的元素拷贝到原数组中
        int tempIndex = left;
        int k = 0;
        while (tempIndex <= right){
            array[tempIndex] = temp[k];
            k++;
            tempIndex++;
        }
    }
}

7.查找算法

7.1 线性查找算法

线性查找又称顺序查找，是一种最简单的查找方法
基本思想：从第一个记录开始，逐个比较记录的关键字，直到和给定的K值相等，则查找成功;

package select;

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

        //查询下面数组是否存在某个元素，如果存在则返回索引值，否则返回-1
        int[] array = new int[]{2,4,8,6,4,9,0};
        int i = show(array,4);
        System.out.println(i);
    }

    public static int show(int[] array,int target){
        for (int i = 0; i < array.length; i++) {
            if (array[i] == target){
                return i;
            }
        }
        return -1;
    }
}

7.2 二分查找算法

  1. 二分查找也称折半查找（Binary Search)，它是一种效率较高的查找方法
  2. 折半查找要求线性表必须采用顺序存储结构，而且表中元素按关键字有序排列
package select;

public class BinarySearch {
    public static void main(String[] args) {
        int[] array = new int[]{10,11,12,13,14,15,16,17};
        int target = 17;
        int search = search(array, target);
        System.out.println(search);//输出为：7
    }

    public static int search(int[] array,int target){
        //最小索引指针
        int min = 0;

        //最大索引指针
        int max = array.length - 1;

        while (min <= max){
            int mid = (min + max) / 2;
            if (array[mid] == target){
                return mid;
            }

            if (array[mid] < target){
                min = mid + 1;
            }

            if (array[mid] > target){
                max = mid - 1;
            }
        }

        return -1;
    }
}

7.3 插值查找算法

  1. 插值查找，有序表的一种查找方式。插值查找是根据查找关键字与查找表中最大最小记录关键字比较后的查找方法。
  2. 插值查找基于二分查找，将查找点的选择改进为自适应选择，提高查找效率。

二分查找:
m i d = ( l + r ) 2 = l + ( r − l ) 2 mid = \dfrac{(l+r)}{2}=l+ \dfrac{(r-l)}{2} mid=2(l+r)​=l+2(r−l)​
插值查找:
m i d = l + f i n d v a l − a r r y [ l ] a r r a y [ r ] − a r r a y [ l ] ∗ ( r − l ) mid = l+\dfrac{findval-arry[l] }{array[r]-array[l]}*{(r-l)} mid=l+array[r]−array[l]findval−arry[l]​∗(r−l)

package select;

public class InsertSelect {
    public static void main(String[] args) {
        int[] array = new int[]{1,2,3,4,5,6};

        int left = 0;
        int right = array.length - 1;
        int searchVal = 3;

        System.out.println(select(array,left,right,searchVal));//输出为：2
    }

    public static int select(int[] array,int left,int right,int searchVal){
        //防止数组越界
        if (left > right || searchVal < array[0] || searchVal > array[array.length - 1]){
            return -1;
        }

        int mid = left + (right - left)*(searchVal - array[left]) / (array[right] - array[left]);

        int midValue = array[mid];

        if (searchVal > midValue){
            return select(array,mid + 1,right,searchVal);
        }else if(searchVal < midValue){
            return select(array,left,mid - 1,searchVal);
        }else{
            return mid;
        }
    }
}

7.4 斐波那契查找算法

黄金比例又称黄金分割，是指事物各部分间一定的数学比例关系，即将整体一分为二，较大部分与较小部分之比等于整体与较大部分之比,其比值约为1:0.618或1.618:1。因此被称为黄金分割。
斐波那契数列:1,1,2,3,5,8,13,21,34,55,89……，(从第三个数开始，后边每一个数都是前两个数的和)，随着斐波那契数列的递增，前后两个数的比值会越来越接近0.618，利用这个特性，就可以将黄金比例运用到查找技术中。

可以将一个长度为 F(n) 的数组看作左右两段，左边一段长度是 F(n-1)，右边一段长度是 F(n-2)
在这里插入图片描述
斐波那契查找算法相对于二分查找和插值查找的基本思路是一致的，其中最重要的区别就是它们的查找点（或称中间值）的确定。斐波那契查找算法的查找点的计算公式如下：
m i d = l e f t + F ( n − 1 ) − 1 mid = left+F(n-1)-1 mid=left+F(n−1)−1

完整的斐波那契查找的基本思想如下：
在斐波那契数列找一个等于或第一个大于查找表中元素个数的数 F[n]，然后将原查找表的长度扩展为 Fn (如果要补充元素，则重复补充原查找表最后一个元素，直到原查找表中满足 F[n] 个元素)；扩展完成后进行斐波那契分割，即 F[n] 个元素分割为前半部分 F[n-1] 个元素，后半部分 F[n-2] 个元素；接着找出要查找的元素在哪一部分并递归，直到找到

package select;

import java.util.Arrays;

public class FibonacciSelect {
    public static void main(String[] args) {
        int[] array = new int[]{1,1,2,3,5,8,13,21,34,55,89};

        System.out.println(select(array,13));//输出为：6
    }

    //f[k] = f[k - 1] + f[k - 2]
    public static int[] f(){
        int[] f = new int[20];
        f[0] = 1;
        f[1] = 1;
        for (int i = 2; i < f.length; i++) {
            f[i] = f[i - 1] + f[i - 2];
        }
        return f;
    }

    //mid = low + f(k - 1) - 1
    public static int select(int[] array,int key){

        int low = 0;
        int hight = array.length - 1;
        int k = 0;
        int mid = 0;
        int[] f = f();

        //找分割点
        while (hight > f[k] - 1){
            k++;
        }

        //将原查找表的长度扩展为 fk
        int[] temp = Arrays.copyOf(array,f[k]);

        //如果要补充元素，则重复补充原查找表最后一个元素
        for (int i = hight + 1; i < temp.length; i++) {
            temp[i] = array[hight];
        }

        //进行查找
        while (low <= hight){
            mid = low + f[k - 1] - 1;

            //f[k - 1]+ f[k - 2] = f[k];
            if (key < temp[mid]){
                hight = mid - 1;
                k--;
            }else if(key > temp[mid]){
                low = mid + 1;
                k -= 2;
            }else{
                if (mid <= hight){
                    return mid;
                }else {
                    return hight;
                }
            }
        }
        return -1;
    }
}
计算机量子狗
关注
  • 3
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构与算法——八大排序算法及总结（JAVA实现，图文详解）
nswdiphone6的博客
02-22 600
这里写目录标题一级目录二级目录三级目录排序算法1.冒泡排序2.选择排序3.插入排序4.希尔排序5.快速排序6.归并排序7.基数排列**8.堆排序**八大排序算法总结 一级目录 二级目录 三级目录 排序算法 1.冒泡排序 ​ 比较相邻的元素。如果第一个比第二个大，就交换他们两个。对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。 ​ 针对所有的元素重复以上的步骤，除了最后一个，即需要进行length-1次。 ​ 第一次是对n个数进行n-1次
数据结构第二章参考答案.doc
12-17
数据结构第二章参考答案.doc
数据结构：八种数据结构大全
緑水長流*z
07-29 19万+
数据结构 1.1 数据结构概述 数据结构是计算机存储、组织数据的方式；通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。数据结构的优良将直接影响着我们程序的性能；常用的数据结构有：数组（Array）、栈（Stack）、队列（Queue）、链表（Linked List）、树（Tree）、图（Graph）、堆（Heap）、散列表（Hash）等； 1.2 数据结构的分类 1.2.1 排列方式 1）集合 集合：数据结构中的元素之间除了“同属一个集合” 的相互关系外，别无其他关系； 2）线性结构 线性
数据结构C语言严蔚敏版(第二版)超详细笔记附带课后习题
热门推荐
chongyang_的博客
11-07 25万+
根据此书所做随笔笔记。 一、绪论 1.1、数据机构的研究内容 用计算机解决实际问题时，步骤：首先分析实际问题，从中抽象出一个适当的数学模型，然后设计一个解决此数学模型的算法，最后编程，调试，测试。 寻求数据模型的实质是分析问题，从中提取出计算机处理的对象，并找出这些对象之间的关系，然后用数学的语言加以描述。 关键：分析问题中所用到的数据是如何组织的，研究数据之间存在什么样的关系。 由于数据必须在计算机中处理，因此不能局限于数据本身的数学问题的研究，还必须考虑数据的物理结构，即数据在计算机中的存储结构。 1.
数据结构 第二章 线性表作业
weixin_41360517的博客
08-05 5045
线性表作业（共50分） 答案链接链接 一、完成下面选择题（每空2分，共14分）。 1. 顺序存储结构中数据中数据元素之间逻辑关系是由（ ）表示的，链接存储结构中的数据元素之间的逻辑关系是由（ ）表示的。 A．线性结构 B．非线性结构 C．存储位置 D．指针 2. 线性表是（ ）。 A．一个有限序列，可以为空 ...
数据结构第二章
weixin_43575775的博客
01-17 4万+
如何运用这些理论和方法解决其他的问题。解决这些问题的方法是什么？是系统性的方法还是一门技术。如何学好数据结构 三多。计算机为什么是二进制？数据结构目标是什么？深度思考比勤奋更重要。
数据结构（C语言版） 第二章 线性表 知识梳理+作业习题详解
繁凡さん的博客
04-29 6万+
单链表顺序存储结构 单链表强调元素在逻辑上紧密相邻，所以首先想到用数组存储。但是普通数组有着无法克服的容量限制，在不知道输入有多少的情况下，很难确定出一个合适的容量。对此，一个较好的解决方案就是使用动态数组。首先用malloc申请一块拥有指定初始容量的内存，这块内存用作存储单链表元素，当录入的内容不断增加，以至于超出了初始容量时，就用calloc扩展内存容量，这样就做到了既不浪费内存，又可以让单链...
数据结构第二章 思维导图
qq_44232564的博客
12-22 1705
【最详细】数据结构（C语言版 第2版）第二章课后习题答案 严蔚敏 等 编著
weixin_43899069的博客
11-01 5万+
第 2 章线性表 1．选择题 （ 1）顺 序表中 第一个 元 素的存储 地址 是 100 ，每 个元素的 长度 为 2，则 第 5 个 元 素 的 地 址 是 （ ）。 A． 110 B ． 108 C． 100 D． 120 答案： B 解释：顺序表中的数据连续存储，所以第 5 个元素的地址为： 100+2*4=108 。 （ 2）在 n 个结点的顺序表中，算法的时间复杂度是 O(1) 的操作是（） 。 A ．访问第 i 个结点（ 1≤ i≤ n）和求第 i 个结点的直接前驱（ 2≤ i≤ n） B ．在
软考——软件设计师：第四章：数据结构&算法分析与设计考点总结（完整篇）
胜天半子祁同伟
08-19 3万+
软考——软件设计师：第四章：数据结构&算法分析与设计考点总结（完整篇）
数据结构第二章-线性表（详细知识点总结）
疯子书生的博客
11-25 1万+
第二章 线性表 【考纲内容】 （一）线性表的定义和基本操作 （二）线性表的实现 顺序存储；链式存储；线性表的应用 【框架】 2.1 线性表的定义和操作 2.1.1 线性表的定义 线性表是具有相同数据类型的n（n>=0）个数据元素的有限序列，其中n为表长，当n=0时，线性表是一个空表。若用L命名线性表，则其一般表示为                &nbs
数据结构：第二章 线性表.ppt
06-07
数据结构：第二章 线性表.ppt
数据结构：第二章栈.ppt
09-17
数据结构：第二章栈.ppt
java环境部署
JiuMeilove的博客
06-04 397
如果你电脑已经下载了 jdk ，那你可以跳过这一步了我这里下载的是java21 你们可以选择自己需要下载的游览进去的页面是这样子的（相比以前这个页面发生很大变化了），可以看见目前 jdk 已经发行到 17 了，jdk 它又分了三个个操作系统，一个是 Linux、一个是 macOS、以及 windows，如果你是在 windows 操作系统上，那当然就下载 windows 对应的 jdk，其次的话就是还会区分你操作系统的处理器是 32 位的还是 64 位的，可以点击 我的电脑 - 属性 查看。
finereport 9.0 Tomcat 集群-来自帆软
最新发布
chenmingfa110的博客
06-07 577
APACHE_HOME ％为你的安装目录。对于每个新来的session，Apache按照节点配置中的lbfactor比重选择访问节点，如果某节点node1不能访问，则寻找下一可访问节点，并且将此node1就在该访问session的访问黑名单中，以后该session的访问直接不考虑node1，即使node1又可以访问了。注：由于这里三个tomcat全在一台机器上，所以需要修改三种类型的端口号，如果是在不同的机器上，则只需要修改AJP13的connector的port，其他端口号不需要修改。
java中Overload和Override的区别
codedadi的博客
06-04 579
当调用Dog对象的makeSound方法时，将执行Dog类中的方法，而不是Animal类中的方法。定义：在子类中，有一个与父类同名、同参数列表、同返回类型（或协变返回类型）的方法，则称子类中的该方法为父类同名方法的重写。子类方法的访问权限不能低于父类方法的访问权限（如父类方法为public，则子类方法也必须是public）。Override（重写）：子类与父类之间，方法名、参数列表和返回类型（或协变返回类型）相同。定义：在同一个类中，方法名相同但参数列表（参数类型、参数数量或参数顺序）不同的多个方法。
Spring异步任务@Async的默认线程池执行器是如何初始化的
简放视野的专栏
06-03 641
Spring异步任务@Async的默认线程池执行器，是从哪里来？是如何初始化的？ 【结论】异步任务@Async的默认线程池执行器是通过TaskExecutionAutoConfiguration#applicationTaskExecutor自动注入的。
拼图小游戏
lazy_girl_666的博客
06-03 720
把A对象的属性值完全拷贝给B对象，也叫对象拷贝，对象复制。
线程池的工作原理
qq_42301955的博客
06-05 546
线程池总结
数据结构吕云翔第二章
09-27
数据结构吕云翔的第二章主要讲解了线性表和链表。线性表是一种数据结构，它包括顺序表和链表两种形式。顺序表是一种使用连续的存储空间存储数据元素的线性表，而链表是一种使用链式存储结构存储数据元素的线性表。 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值