JAVA----数据结构与算法_java 数据结构与算法博客-优快云博客

本文链接：https://blog.youkuaiyun.com/liu_to_liu/article/details/117124751

本文深入探讨了算法的时间复杂度，通过大O表示法分析了斐波纳契数列的递归、循环等实现方式的时间复杂度，指出递归法在大数据规模下效率低下。同时，介绍了动态数组的数据结构，包括接口设计、添加、删除元素的实现，并讨论了扩容策略。文章强调了算法优化的方向——空间与时间的权衡，并提出了根据实际需求调整优化策略的重要性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

数据结构与算法

1、算法
2. 数据结构
- 2.1 线性表

1、算法

1）算法是用于解决特定问题的一系列的执行步骤
2）使用不同算法，解决同一个问题，效率可能相差非常大
3）一般从以下维度来评估算法的优劣

正确性、可读性、健壮性（对不合理输入的反应能力和处理能力）
时间复杂度（time complexity）：估算程序指令的执行次数（执行时间）
空间复杂度（space complexity）：估算所需占用的存储空间

1.1 时间复杂度

大O表示法：描述复杂度，表示的是数据规模n对应的复杂度;仅仅是一种粗略的分析模型，是一种估算，能简单了解一个算法的执行效率
忽略常数、系数、低阶、对数阶一般省略底数

常数 >> O(1)；
2n + 3 >> O(n)；
n^2 + 2n + 6 >> O(n^2)；
4n^3 + 3n^2 + 22n + 100 >> O(n^3)
log2(n)、log9(n)>> O(logn)

在这里插入图片描述

常见的时间复杂度

时间工具类----TimeTool

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

public class TimeTool {
	private static final SimpleDateFormat fmt = new SimpleDateFormat("HH:mm:ss.SSS");

	public interface Task {
		void execute();
	}

	public static void check(String title, Task task) {
		if (task == null)
			return;
		title = (title == null) ? "" : ("【" + title + "】");
		System.out.println(title);
		System.out.println("开始：" + fmt.format(new Date()));
		long begin = System.currentTimeMillis();
		task.execute();
		long end = System.currentTimeMillis();
		System.out.println("结束：" + fmt.format(new Date()));
		double delta = (end - begin) / 1000.0;
		System.out.println("耗时：" + delta + "秒");
		System.out.println("--------------------------------");
	}
}

求第n个斐波纳契数（fibonacci number）

public class Test {
	/**
	 * 斐波纳契数列: 
	 * 				0 1 1 2 3 5 8 13 ... 
	 * 索引： 
	 * 				0 1 2 3 4 5 6  7 ...
	 */

	// 方法一：递归法
	// 时间复杂度 O(2^n)
	public static int fib1(int n) {
		if (n <= 1)
			return n;
		return fib1(n - 1) + fib1(n - 2);
	}

	// 方法二
	// 时间复杂度 O(n)
	public static int fib2(int n) {
		if (n <= 1)
			return n;

		int first = 0;
		int second = 1;
		for (int i = 0; i < n - 1; i++) {
			int sum = first + second;
			first = second;
			second = sum;
		}
		return second;
	}

	// 方法三
	// 时间复杂度 O(n)
	public static int fib3(int n) {
		if (n <= 1)
			return n;

		int first = 0;
		int second = 1;
		while (n-- > 1) {
			second += first;
			first = second - first;
		}
		return second;
	}

	public static void main(String[] args) {
		// 递归法：存在性能问题，随着n的增大，效率会受影响
		TimeTool.check("fib1", new Task() {

			@Override
			public void execute() {
				System.out.println(fib1(30));
			}

		});

		// 方法二的效率明显比递归法高
		TimeTool.check("fib2", new Task() {

			@Override
			public void execute() {
				System.out.println(fib2(30));
			}

		});

		// 方法三的在变量的使用数量要比方法二少
		TimeTool.check("fib3", new Task() {

			@Override
			public void execute() {
				System.out.println(fib3(30));
			}

		});
	}
}