数据结构与算法（数组、链表）

已于 2024-08-17 23:00:46 修改
阅读量414 收藏 10
点赞数 4
文章标签： 算法
于 2024-07-28 00:26:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yanshengren520/article/details/140743738
版权

数据结构与算法

基础查找算法

二分查找

二分查找也称折半查找，是在一组有序(升序/降序)的数据中查找一个元素，它是一种效率较高的查找方法。

/**
  * 二分查找法：
  * @param arr    数组，（升序/降序）
  * @param target 要查询到值
  * @return int 查询到会返回（该值的下标），没有查询到返回（-1）
 */
public static int binarySearchB(int[] arr, int target) {
    int i = 0;
    int j = arr.length;
    while (i < j) {
        // 中间值 （向下取整）
        int m = (j + i) / 2;   
        if (target < arr[m]) {
            // 左边位置
            j = m;
        } else if (arr[m] < target) {
            // 右边位置
            i = m + 1;
        } else {
            // 当前位置
            return m;
        }
    }
    return -1;
}

顺序查找

顺序查找，时间复杂度是O(n)。

for (int i = 0; i < arr.length; i++) {
   if (arr[i] == target) {
      return i;
   }
}

时间复杂度

时间频度：一个算法花费的时间与算法中语句执行次数成正比，它算法执行语句次数多，它就花费时间长；T(n)

时间复杂度按n越大来排序：常数阶O(1)、对数阶O(logn)、线性阶O(n)、线性对数阶O(nlogn)、平方阶O(n²)、立方阶O(n³)、…、指数阶O(2的n次方)。

例子：

// O(N)的时间复杂度
for(i=1; i<=n; ++i){
   j = i;
   j++;
}

// O(logN)的时间复杂度
int i = 1;
while(i<n){
    i = i * 2;
}

// O(n²) 的时间复杂度
for(x=1; i<=n; x++){
   for(i=1; i<=n; i++) {
       j = i;
       j++;
    }
}

数组

数组是由一组元素组成的数据结构，每个元素至少有一个索引来标识。数组的起始位置BaseAddress，公式：BaseAddress + i * size（数据类型，int数组就是4，double就是8），可以计算出i元素的地址。

int[] arr = new int[]{1,2,3};

数组的结构：

  • 8个字节markword
  • 4个字节class指针（压缩class指针）
  • 4个节的数组大小
  • 数组元素，如果大小不是8字节的倍数，会自动补齐

数组的随机访问，时间复杂度是O(1)。

案例：

/**
 * 自定义-数组-结构：[1 2 3 4]
 */
public class T implements Iterable<Integer> {

    private int size = 0;             // 数组的个数
    private int num = 10;             // 数组的容量
    private int[] arr = new int[num]; // 初始化数组

    /**
     * 添加对象
     */
    public void add(int element) {
        add(element, size);
    }

    // 扩容
    private void kr() {
        if (size >= num) {
            num += num >> 1;
            int[] newArr = new int[num];
            System.arraycopy(arr, 0, newArr, 0, size);
            arr = newArr;
        }
    }

    /**
     * 添加对象 （指定下标的位置 进行创建对象）
     * @return
     */
    public void add(int element, int index) {
        // 例子：
        // int[] arr = new int[]{1,2,3}
        // int[] arr = new int[]{1,[5],2,3}
        // index = 1   新数组从 1+1=2，开始，拷贝个数：3-1=2，拷贝2个（2,3）
        if (index >= 0 && index < size) {
            kr();
            // 参数1：原数组、参数2：原数组的下标、参数3：新的数据、参数4：要拷贝的位置、参数5：拷贝的个数
            System.arraycopy(arr, index, arr, index + 1, size - index);
        }
        arr[index] = element;
        size++;
    }

    /**
     * 获取单条
     */
    public int get(int index) {
        return arr[index];
    }

    // 遍历方式1
    public void foreach() {
        for (int i = 0; i < size; i++) {
            System.out.println(arr[i]);
        }
    }

    // 遍历方式2
    public void foreach2(Consumer<Integer> consumer) {
        for (int i = 0; i < size; i++) {
            consumer.accept(arr[i]);
        }
    }

    // 遍历方式3
    public IntStream foreach3() {
        int[] ints = Arrays.copyOf(arr, size);
        return IntStream.of(ints);
    }

    // 遍历方式4
    @Override
    public Iterator<Integer> iterator() {
        return new Iterator<Integer>() {
            int i = 0;

            @Override
            public boolean hasNext() {
                return i < size;  // 判断是否有下一个元素
            }

            @Override
            public Integer next() {
                return arr[i++];  // 获取当前元素，并移动下一个元素
            }
        };
    }

    // 删除 - 根据下标进行删除元素
    private int remove(int index) {
        int element = get(index);
        if (index < size - 1) {
            System.arraycopy(arr, index + 1, arr, index, size - index - 1);
        }
        size--;
        return element;
    }
}

二维数组：

// 二维数组
int[][] arr = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9},
};
// 遍历二维数据
for (int i = 0; i < arr.length; i++) {
    for (int j = 0; j < arr[i].length; j++) {
        System.out.println(arr[i][j]);
    }
}

链表

链表是数据元素的线性结构，其每个元素都指向下一个元素，元素存储上并不是连续的；链表的头节点是哨兵，它不储存元素，用来边界判断。

分为：单向链表（每个元素只知道下一个元素）、双向链表（每个元素都知道上一个元素和下一个元素）、循环链表（链表尾节点指向头节点）

性能：随机访问，时间复杂度O(n)，插入是O(i)，插入结束位置是O(n)，而插入头节点是O(1)，中间位置是index+O(1)。

案例：

/**
 * 自定义-链表-结构：1 2 3 4
 */
public class T implements Iterable<Integer> {

    private static class Node {
        private int value; //值
        private Node next; //下一个节点
        public Node(int value, Node next) {
            this.value = value;
            this.next = next;
        }
    }

    private Node head; // 头节点

    // 添加头节点
    public void addFirst(int element) {
        head = new Node(element, head);
    }

    // b 遍历 （有1种方式）
    public void loop1() {
        Node n;
        for (n = head; n != null; n = n.next) {
            System.out.println(n.value);
        }
    }

    // b 遍历 （有2种方式）
    public void loop2(Consumer<Integer> consumer) {
        Node n;
        for (n = head; n != null; n = n.next) {
            consumer.accept(n.value);
        }
    }

    // b 遍历 （有3种方式）
    @Override
    public Iterator<Integer> iterator() {
        return new Iterator<Integer>() {
            Node n = head;
            @Override
            public boolean hasNext() {
                return n != null;  // 判断是否有下一个元素
            }
            @Override
            public Integer next() {
                int value = n.value;
                n = n.next;
                return value;  // 返回当前元素，并移动下一个元素
            }
        };
    }

    // 添加尾节点
    public void addLast(int element) {
        Node lastNode = getLastNode();
        if (lastNode == null) {
            addFirst(element);
            return;
        }
        lastNode.next = new Node(element, null);
    }

    // 找到最后一个节点
    private Node getLastNode() {
        if (head == null) {
            return null;
        }
        Node n;
        for (n = head; n.next != null; n = n.next) {
        }
        return n;
    }

    // 根据下标获取单条数据
    public int getIndex(int index) {
        Node node = getNode(index);
        if (node == null) {
            System.out.println("下标越界");
            return -1;
        }
        return node.value;
    }

    // 根据下标获取元素
    private Node getNode(int index) {
        Node n;
        int i = 0;
        for (n = head; n != null; n = n.next) {
            if (i == index) {
                return n;
            }
            i++;
        }
        return null; // 没找到
    }

    // 根据索引添加数据
    public void addIndex(int index, int element) {
        if (index == 0) {
            addFirst(element);
            return;
        }
        Node prev = getNode(index - 1);
        if (prev == null) {
            System.out.println("下标越界");
            return;
        }
        prev.next = new Node(element, prev.next);
    }

    // 删除头元素
    public void removeFirst() {
        if (head == null) {
            System.out.println("下标越界");
            return;
        }
        head = head.next;
    }

    // 删除指定元素
    public void remove(int index) {
        if (index == 0) {
            removeFirst();
            return;
        }
        Node prev = getNode(index - 1);
        if (prev == null) {
            System.out.println("下标越界");
            return;
        }
        Node next = prev.next;  // 被删除的节点
        if (next == null) {
            System.out.println("下标越界");
            return;
        }
        prev.next = next.next;
    }
}

链表：有带哨兵的链表、双向链表、环形链表。

链表相关案例：链表反转、有序链表去重、判断链表是否存在环、合并链表、判断链表是否是回文链表、删除倒数节点、根据值删除链表中节点等，可在码云上链表仓库查看。

递归

是一个函数在其定义中直接或间接调用自身的一种方法。直接或间接地调用自身的算法称为递归算法。

案例：

// 1. 阶乘 - 求5的阶乘  1 * 2 * 3 * 4 * 5
public static int f1(int n) {
    if (n == 1) {
        return 1;
    }
    return n * f1(n - 1);
}

斐波那契数列

// 斐波那契数列，也是 多路递归 是：0  1  1  2  3  5  8  13  21.。。（前一个数 + 后一个数 = 下一个值）
public static int f1(int n) {
    if (n == 0) {
        return 0;
    }
    if (n == 1) {
        return 1;
    }
    return f1(n - 1) + f1(n - 2);
}
// 运行
System.out.println(f1(8));
// 优化上面代码，可使用记忆法

排序

冒泡排序

// 冒泡排序 - 1 数组：5 4 3 2 1
public static void test1(int[] arr, int j) {
    if (j == 0) {
        return;
    }
    for (int i = 0; i < j; i++) {
        if (arr[i] > arr[i + 1]) {
            int t = arr[i];
            arr[i] = arr[i + 1];
            arr[i + 1] = t;
        }
    }
    test1(arr, j - 1);
}
// 运行
int[] arr = {5, 4, 3, 2, 1};
test1(arr, arr.length - 1);

插入排序

// 插入排序 - 1 数组 4 3 2 1  / 3 4 2 1
public static void test1(int[] arr, int low) {
    if (low == arr.length) {
        return;
    }
    // 已排序的 i 、 未排序的下标（low）
    int t = arr[low]; // 未排序当前对象
    int i = low - 1;
    while (i >= 0 && arr[i] > t) {
        arr[i + 1] = arr[i];
        i--;
    }
    arr[i + 1] = t;
    test1(arr, low + 1);
}
// 运行
int[] arr = {5, 4, 3, 2, 1};
test1(arr, 1); // 默认未排序下标是1，已排序下标是0
优秀的颜
关注
Python3 数据结构与算法的介绍及应用。1. 数据结构：数组、链表、栈等等
12-27
1. 数据结构：数组、链表、栈、队列、树、堆、图； 2. 典型排序算法：冒泡排序、选择排序、插入排序、希尔排序、堆排序、归并排序、快速排序、桶排序、计数排序、基数排序； 3. 查找算法： 顺序查找、二分查找、哈希...
java数组和链表数据结构的区别 数组和链表.pdf
04-18
Java中的数组和链表是两种常见的线性数据结构，各有优缺点，适用于不同的场景。下面我们将详细探讨这两种数据结构的区别。 **数组（Array）** 数组是一种在内存中连续存储相同类型元素的数据结构。它的主要特点...
数据结构： 数组与链表
timberman666的博客
10-02 2480
数据结构： 数组与链表
数据结构——数组与链表
weixin_61015911的博客
04-30 2834
数据结构——数组与链表一、数组理论基础二、链表理论基础1.链表分类1）单链表2）双链表3）循环链表4）块状链表2.链表的存储方式3.链表的定义4.链表的操作1）删除节点2）插入节点3）查找元素4）更新元素5.虚拟头节点的使用6.与数组的对比 一、数组理论基础 数组是存放在连续内存空间上的相同类型数据的集合。可以方便的通过下标索引的方式获取到下标下对应的数据。 不能单独删除、释放数组中的某个元素，只能覆盖。如果要释放，就是全释放（程序运行结束，回收内存栈空间）。 因为数组的在内存空间的地址是连续的，所以我们在
数据结构与算法学习笔记
热门推荐
ityqing的博客
09-25 34万+
本文是王争老师的《算法与数据结构之美》的学习笔记，详细内容请看王争的专栏。有不懂的地方指出来，我做修改。 数据结构与算法思维导图 数据结构指的是“一组数据的存储结构”，算法指的是“操作数据的一组方法”。 数据结构是为算法服务的，算法是要作用再特定的数据结构上的。 最常用的数据结构预算法: 数据结构：数组、链表、栈、队列、散列表、二叉树‘、堆、跳表、图、Tire树 算法： 递归...
算法学习：数组 vs 链表
Allen-
05-08 3650
内存，尤其是随机存取存储器（RAM），是计算机中用于临时存储数据和程序指令的部分。与硬盘相比，内存访问速度快，但信息非持久保存。想象一下，当你在解决一个复杂的算法问题时，那些数字、字符，乃至复杂的数据结构，都需要一个地方暂时停留和操作——这个地方就是内存数组是一种线性数据结构它将元素按照一定的顺序存储在一块连续的内存区域中。每个元素都有一个索引（从0开始），通过索引可以快速访问数组中的任意元素。
数据结构和算法：数组和链表
学习记录
03-13 990
数据结构和算法复习
数据结构与算法
ChengChat
09-19 195
一、线性表 顺序线性表 链式线性表 二、栈和队列 1. 栈的顺序存储结构 单栈 共享栈 2. 栈的链式存储结构 递归、逆波兰式 3. 队列的线性存储结构 顺序队列 循环顺序队列 队列的链式存储结构 链式队列 三、串 kmp匹配算法 四、树 度 深度 森林 表示方法 1. 二叉树 满二叉树 完全二叉树 线索二叉树 森林、树、二叉树之间的转换 2.赫夫曼树 赫夫曼编码 五、图 1....
[数据结构]数组与链表的优缺点和区别 数组和链表.pdf
04-18
数组和链表是两种基本的数据结构，它们各自有其独特的优缺点，适用于不同的场景。下面将详细介绍这两种数据结构以及它们的区别。 首先，数组是一种线性数据结构，它将元素在内存中连续存放，每个元素占用相同的内存...
数据结构（数组和链表） 数组和链表.pdf
04-18
数组和链表是两种最基本且常用的数据结构，各自有着独特的特性和应用场景。 数组是一种线性数据结构，它在内存中占据一块连续的空间。数组的大小在创建时即被固定，无法动态扩展或收缩。数组的每个元素占用相同大小...
【LeetCode】【算法】160.相交链表
passer__jw767的博客
11-05 369
Leetcode 160. 相交链表
【算法】（Python）贪心算法
yannan20190313的博客
11-04 2108
【算法】（Python）贪心算法（最大单元数，买卖股票最佳时机，最低加油次数）
二分查找习题篇(上)
最新发布
zoelinkailuo的博客
11-07 955
给定⼀个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。这里，我们把数组的元素分为两部分——小于等于target的部分[left,Bright] and 大于target的部分[Bright+1,right]。这里，我们把数组的元素分为两部分——平方后小于等于x的部分[1,mid] and 平方后大于x的部分[mid-1, x]和一个目标值，在数组中找到目标值，并返回其索引;
数组类算法【leetcode】
随便写写
11-07 333
给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。二分查找 用于有序数组中，没有重复的数组。首先需要定义一个头（left）和尾(right)，最后通过mid和target对比不断修改头和尾指向的位置。【需要注意区间问题，根据区间的开和闭决定边界条件】推荐练习 leetcode35.
GJ Round (2024.10) Round 8~21
lunjiahao的博客
11-06 866
前言： 点此 返回 GJ Round 目录 Round 8 (10.5) A 给定 nnn 个区间，每个区间 [li,ri][l_i,r_i][li​,ri​]，最大化选取区间对数，使得每对区间 [li,ri],[lj,rj][l_i,r_i],[l_j,r_j][li​,ri​],[lj​,rj​] 满足 [li,ri]∩[lj,rj]=∅[l_i,r_i] \cap [l_j,r_j] =\varnothing[li​,ri​]∩[lj​,rj​]=∅ 先按 lil_ili​ 从小到大排序，再按
【刷题】优选算法
林宇恒的博客
11-06 484
如图，我们先算出最左边(1)和最右边(7)围起来的容量，然后，7不动，1继续和7的左边3，8，4...遍历算出容量，你会发现底是不断缩短的，同时高一直都是1，因为高只有两种情况，比它小或和它相等，所以1和7左边的值算出来的容量都是比1和7的容量小的，因为底在不断变小同时高可能不变也可能变小。根据两个实例和鸽巢原理可以发现不断的平方和最终都会形成环，所以我们可以联想到用快慢指针，慢指针走一步，快指针走两步，最终会在环相遇，判断相遇时是否为1。第一个实例是快乐数，因为会变为1且不断是1的循环。
【LeetCode】【算法】416. 分割等和子集
passer__jw767的博客
11-06 315
LeetCode 416. 分割等和子集
69. x 的平方根
学习历程记录和分享
11-06 184
注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5。由于返回类型是整数，结果只保留 整数部分 ，小数部分将被 舍去。给你一个非负整数 x ，计算并返回 x 的 算术平方根。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值