当前位置： 首页 > wzjs >正文

网站banner大图百度如何发布作品

wzjs 2025/8/13 17:36:52
网站banner大图,百度如何发布作品,网站的销售怎么做,网站名字怎样做版权、链表基础概念链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序通过链表中的指针链接实现。核心特点：节点1 -> 节点2 -> 节点3链表类型对比：类型特点示意图单向链表只有 next 指针A → B → C → null双向链…
、链表基础概念

链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序通过链表中的指针链接实现。核心特点：节点1  ->  节点2   ->  节点3

链表类型对比：
类型特点示意图
单向链表只有 next 指针A → B → C → null
双向链表有 prev 和 next 指针null ⇄ A ⇄ B ⇄ C ⇄ null
循环链表尾节点指向头节点A → B → C → A

  • 与数组的对比：
    特性数组(ArrayList)链表(LinkedList)
    内存连续性连续内存块非连续内存块
    随机访问O(1)O(n)
    头部插入O(n)O(1)
    内存利用率可能浪费空间按需分配
    CPU缓存友好性高低

二、LinkedList 核心解析
2.1 类结构分析
public class LinkedList<E>extends AbstractSequentialList<E>implements List<E>, Deque<E>, Cloneable, Serializable {transient int size = 0;transient Node<E> first; // 头节点transient Node<E> last;  // 尾节点private static class Node<E> {E item;Node<E> next;Node<E> prev;}
}
2.2 时间复杂度全景图
操作时间复杂度原理说明
addFirst()/addLast()O(1)直接修改头尾指针
getFirst()/getLast()O(1)直接访问头尾节点
removeFirst()/removeLast()O(1)修改头尾指针
get(int index)O(n)需要遍历到指定位置
add(int index, E e)O(n)找到位置后修改指针（O(1)）
contains(Object o)O(n)必须遍历所有元素

三、LinkedList 使用详解
3.1 构造方法
// 示例1：空链表
LinkedList<String> list1 = new LinkedList<>();// 示例2：从集合初始化
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
LinkedList<String> list2 = new LinkedList<>(names);
3.2 核心操作方法

1. 添加元素：

// 尾部添加（推荐）
linkedList.add("Tail"); // 头部添加
linkedList.addFirst("Head");// 指定位置插入
linkedList.add(2, "Middle");

2. 删除元素：

// 删除头部
String head = linkedList.removeFirst();// 删除尾部
String tail = linkedList.removeLast();// 按值删除（删除第一个匹配项）
linkedList.remove("Bob");// 按索引删除
linkedList.remove(1);

3. 访问元素

// 获取头部（不删除）
String first = linkedList.getFirst();// 获取尾部（不删除）
String last = linkedList.getLast();// 随机访问（效率低）
String item = linkedList.get(3);

4. 队列操作（实现Deque接口）：

// 作为队列使用
Queue<String> queue = new LinkedList<>();
queue.offer("A");     // 入队
queue.poll();         // 出队// 作为双端队列
Deque<String> deque = new LinkedList<>();
deque.offerFirst("A"); // 队头入
deque.offerLast("Z");  // 队尾入
deque.pollFirst();     // 队头出
3.3 四种遍历方式
// 1. for循环（效率最低）
for(int i=0; i<list.size(); i++) {System.out.println(list.get(i)); // 每次get都是O(n)
}// 2. 增强for循环（推荐）
for(String s : list) {System.out.println(s);
}// 3. 迭代器（最佳实践）
Iterator<String> it = list.iterator();
while(it.hasNext()) {System.out.println(it.next());
}// 4. 倒序迭代器（双向链表特有）
Iterator<String> dit = list.descendingIterator();
while(dit.hasNext()) {System.out.println(dit.next());
}
四、源码深度剖析
4.1 节点插入流程
// add(E e) 方法源码
public boolean add(E e) {linkLast(e); // 核心方法return true;
}void linkLast(E e) {final Node<E> l = last;      // 1. 获取当前尾节点final Node<E> newNode = new Node<>(l, e, null); // 2. 创建新节点last = newNode;              // 3. 更新尾指针if (l == null)               // 4. 处理空链表情况first = newNode;elsel.next = newNode;        // 5. 原尾节点指向新节点size++;                      // 6. 更新大小
}
4.2 随机访问优化
// get(int index) 源码
public E get(int index) {checkElementIndex(index); // 索引检查return node(index).item;  // 核心方法
}Node<E> node(int index) {// 二分查找优化：根据位置选择从头/尾遍历if (index < (size >> 1)) { // 索引在前半部分Node<E> x = first;for (int i = 0; i < index; i++)x = x.next;return x;} else { // 索引在后半部分Node<E> x = last;for (int i = size - 1; i > index; i--)x = x.prev;return x;}
}
4.3 删除操作解析
// remove(int index) 核心流程
public E remove(int index) {checkElementIndex(index);return unlink(node(index)); // 先定位再删除
}E unlink(Node<E> x) {final E element = x.item;final Node<E> next = x.next;final Node<E> prev = x.prev;if (prev == null) {       // 删除的是头节点first = next;} else {prev.next = next;     // 前驱指向后继x.prev = null;        // 断开前驱链接}if (next == null) {       // 删除的是尾节点last = prev;} else {next.prev = prev;     // 后继指向前驱x.next = null;        // 断开后继链接}x.item = null;            // 帮助GCsize--;return element;
}

五、实战应用案例
5.1 LRU缓存实现
class LRUCache<K, V> {private final int capacity;private final Map<K, V> map = new HashMap<>();private final LinkedList<K> list = new LinkedList<>();public LRUCache(int capacity) {this.capacity = capacity;}public V get(K key) {if (map.containsKey(key)) {// 移动到链表头部list.remove(key);list.addFirst(key);return map.get(key);}return null;}public void put(K key, V value) {if (map.containsKey(key)) {list.remove(key);} else if (map.size() >= capacity) {// 淘汰尾部数据K oldestKey = list.removeLast();map.remove(oldestKey);}list.addFirst(key);map.put(key, value);}
}

5.2 多项式相加
class Polynomial {static class Term {int coeff;int exp;Term(int coeff, int exp) {this.coeff = coeff;this.exp = exp;}}public static LinkedList<Term> add(LinkedList<Term> p1, LinkedList<Term> p2) {LinkedList<Term> result = new LinkedList<>();Iterator<Term> it1 = p1.iterator();Iterator<Term> it2 = p2.iterator();Term t1 = it1.hasNext() ? it1.next() : null;Term t2 = it2.hasNext() ? it2.next() : null;while (t1 != null || t2 != null) {if (t1 == null) {result.add(t2);t2 = it2.hasNext() ? it2.next() : null;} else if (t2 == null) {result.add(t1);t1 = it1.hasNext() ? it1.next() : null;} else if (t1.exp > t2.exp) {result.add(t1);t1 = it1.hasNext() ? it1.next() : null;} else if (t1.exp < t2.exp) {result.add(t2);t2 = it2.hasNext() ? it2.next() : null;} else {// 指数相同，系数相加int sum = t1.coeff + t2.coeff;if (sum != 0) {result.add(new Term(sum, t1.exp));}t1 = it1.hasNext() ? it1.next() : null;t2 = it2.hasNext() ? it2.next() : null;}}return result;}
}

 5.3 音乐播放列表

class MusicPlayer {private final LinkedList<String> playlist = new LinkedList<>();private ListIterator<String> iterator;public void addSong(String song) {playlist.addLast(song);if (iterator == null) {iterator = playlist.listIterator();}}public void playNext() {if (iterator.hasNext()) {System.out.println("播放: " + iterator.next());} else {System.out.println("已到列表末尾");}}public void playPrevious() {if (iterator.hasPrevious()) {System.out.println("播放: " + iterator.previous());} else {System.out.println("已到列表开头");}}public void removeCurrent() {iterator.remove();System.out.println("歌曲已移除");}
}
六、经典面试题解析
6.1 链表反转（迭代法）
public static <E> LinkedList<E> reverse(LinkedList<E> list) {LinkedList<E> reversed = new LinkedList<>();for (E item : list) {reversed.addFirst(item); // 利用头插法实现反转}return reversed;
}
6.2 检测环形链表（快慢指针）
public static boolean hasCycle(LinkedList<?> list) {// 模拟快慢指针（实际LinkedList无环）if (list.isEmpty()) return false;Iterator<?> slow = list.iterator();Iterator<?> fast = list.iterator();while (fast.hasNext()) {slow.next(); // 慢指针走一步fast.next(); // 快指针走两步if (!fast.hasNext()) break;fast.next();// 如果相遇则有环if (slow == fast) return true;}return false;
}
6.3 合并有序链表
public static LinkedList<Integer> mergeSortedLists(LinkedList<Integer> list1, LinkedList<Integer> list2) {LinkedList<Integer> merged = new LinkedList<>();Iterator<Integer> it1 = list1.iterator();Iterator<Integer> it2 = list2.iterator();Integer num1 = it1.hasNext() ? it1.next() : null;Integer num2 = it2.hasNext() ? it2.next() : null;while (num1 != null || num2 != null) {if (num1 == null) {merged.add(num2);num2 = it2.hasNext() ? it2.next() : null;} else if (num2 == null) {merged.add(num1);num1 = it1.hasNext() ? it1.next() : null;} else if (num1 < num2) {merged.add(num1);num1 = it1.hasNext() ? it1.next() : null;} else {merged.add(num2);num2 = it2.hasNext() ? it2.next() : null;}}return merged;
}
七、使用场景建议

  • 推荐使用：

    • 频繁在头尾增删元素（队列/栈操作）
    • 不需要随机访问的场景
    • 元素数量变化大的场景
    • 实现特殊数据结构（LRU缓存等）

  • 避免使用：

    • 需要频繁随机访问（超过总操作20%）
    • 内存敏感场景（每个元素额外消耗24字节指针）
    • CPU缓存优化要求高的场景
http://www.dtcms.com/wzjs/304021.html

相关文章：

  • seo 优化 工具seo免费诊断联系方式
  • discuz网站建设百度一下 你知道首页
  • 怀安网站建设石家庄谷歌seo公司
  • 汉南城乡建设局网站seo的方法有哪些
  • 金融网站开发目的搜狗站长平台验证网站
  • 杭州模板建站软件久久seo正规吗
  • 徐汇网站建设北京seo顾问服务
  • 门户网站建设自查整改报告南京seo网站优化推广
  • 计算机多媒体辅助教学网站开发seo 0xu
  • 做网站的哪里有谷歌竞价推广教程
  • 武汉品牌网站建设公司哪家好googleseo排名公司
  • 西安哪家公司网站做的好济南竞价托管
  • dnf免做卡网站网络营销渠道的功能
  • wordpress多站点 域名计算机培训班有用吗
  • php用什么做网站服务器网络营销师培训
  • 做bbs网站教程seo优化排名教程百度技术
  • 电脑哪里做模板下载网站整合营销推广
  • 手机浏览器网页加速器免费发布网站seo外链
  • 政府网站建设定位seo官网优化详细方法
  • 茂名公司网站开发公司百度收录查询方法
  • 网站开发采用的技术方案说明电商平台排名
  • wordpress做企业网站seo优化运营
  • 南京哪里有做公司网站的google广告投放技巧
  • 1高端网站建设产品营销推广的方案
  • 荥阳做网站优化网站seo策划方案
  • 成都学生做网站搜狗网站收录入口
  • 自己做网站模版百度推广价格
  • 好的html5网站模板360优化大师安卓下载
  • 网站图片翻页代码百度推广怎么做
  • java在网站开发上平台推广是什么工作