Java版基础数据结构算法 - 单链表和双向链表、顺序栈和链式栈、循环队列和链式队列

单链表循环队列 // // queue_.cpp // Cycle // // Created by ljpc on 2018/5/30. // Copyright © 2018年 ljpc. All rights reserved. // #include "queue_.h" void creatCycleQueue(CycleQueue* que) // 创建一个循环队列指针que { que->size_ = 0; que->rear = NULL; } bool is. 阅读详情

知识的学习在于点滴记录,坚持不懈;知识的学习要有深度和广度,不能只流于表面,坐井观天;知识要善于总结,不仅能够理解,更知道如何表达!

数组和链表

在大家接触链表之前,都大量的使用过数组,数组有‘1好2不好’,怎么解释呢?

1好是,数组的内存是绝对连续的,因此数组的随机访问操作非常的快,时间复杂度是 O ( 1 ) O(1) O(1),为常量时间,例如arr[20]和arr[2000]的访问花费的时间是一样的。

2不好是 :
a.数组在定义的时候,必须指定其大小,实际应用中,当数组元素满了以后,要进行扩容,扩容的代码虽然简单,如arr = Arrays.copyOf(arr, arr.length*2)就能够达到2倍扩容的效果,但是当数组的元素数量比较大的话,扩容需要经过开辟更大块内存,拷贝数据,GC回收原来的旧内存等步骤,其效率就比较低了,扩容花费的时间也长了。当扩容一段时间后,数组内存空间特别大,但是随着删除操作,最后只有少量的有效元素(如10000个数组元素空间,却只存储了10个有效元素),内存就被浪费了,这时候就得缩容(如ArrayList数组集合的缩容实现),其效率也比较低。

b.在数组中,插入元素或者删除元素,都需要经过大量数据的移动。插入操作会引起插入点后面的元素都向后进行移动;删除操作会引起删除点后面的元素都向前进行移动,这两个操作的时间花费都是 O ( n ) O(n) O(n),是线性时间,说明随着数组的元素数量越多,插入删除操作的效率越低。

区别于数组,那么链表就有‘1不好2好’:

2好是:
a.链表的每一个元素节点都是独立new出来的,也就是说链表中所有元素节点内存并不是连续的,而是上一个节点记录了下一个节点的地址,这样内存的使用效率就非常的高,在存储数据量比较大的时候,不需要大片连续的内存空间,因此只要当前JVM可用内存足够大,链表就可以无限生成新的节点,不存在大块内存开辟,大量数据拷贝,GC回收旧内存的内存扩容问题,这一点要比数组优秀!

b.在链表中插入数据,只需要生成新的节点接入链表中就可以,不涉及其它数据节点的移动;在链表中删除数据,只需要把待删除节点从原链表中卸载下来就可以,也不涉及其它数据节点的移动,也就是数据插入和删除的时间复杂度是 O ( 1 ) O(1) O(1),常量时间,速度很快(这个指的是插入删除操作本身花费的时间,往往在链表中做插入和删除操作的时候,首先会遍历链表,找到合适的位置,那么链表搜索的时间是 O ( n ) O(n) O(n),为线性时间)。

1不好是,因为链表中节点的内存不是连续的,所以就不能像数组那样支持元素的随机访问(就是通过指定下标,访问对应的元素的值),当在链表中访问一个元素节点时,总是要从头节点开始,一个个往后遍历,链表元素越多,遍历的时间就越长,因此链表遍历搜索的时间是 O ( n ) O(n) O(n),为线性时间,没有数组随机访问 O ( 1 ) O(1) O(1)的效率好。

结论:所以一般插入删除操作多,用链表;随机访问多,用数组。当然还需要具体情况具体分析。数组和链表各操作时间复杂度对比如下:

名称插入删除查找&搜搜随机访问
数组 O ( n ) O(n) O(n) O ( n ) O(n) O(n) O ( n ) O(n) O(n) O ( 1 ) O(1) O(1)
单链表 O ( 1 ) O(1) O(1) O ( 1 ) O(1) O(1) O ( n ) O(n) O(n)不支持

单链表代码实现

/**
 * 带头节点的单链表的实现
 * @param <T>
 */
class Link<T extends Comparable<T>>{

    /**
     * 指向单链表的头节点,其地址域中记录了链表第一个节点的地址
     */
    HeadEntry<T> head;

    /**
     * 初始化链表,生成头节点被head指向
     */
    public Link(){
        this.head = new HeadEntry<>(0, null, null);
    }

    /**
     * 单链表的头插法
     * @param val
     */
    public void insertHead(T val){
        Entry<T> node = new Entry<>(val, this.head.next);
        this.head.next = node;
        this.head.cnt += 1; // 更新头节点中链表节点的个数
    }

    /**
     * 单链表的尾插法
     * @param val
     */
    public void insertTail(T val){
        Entry<T> node = head;
        while(node.next != null){
            node = node.next;
        }
        node.next = new Entry<>(val, null);
        this.head.cnt += 1; // 更新头节点中链表节点的个数
    }

    /**
     * 单链表中删除所有值是val的节点
     * @param val
     */
    public void remove(T val){
        Entry<T> pre = head;
        Entry<T> cur = head.next;

        while(cur != null){
            if(cur.data == val){
                // val节点的删除
                pre.next = cur.next;
                cur = pre.next; // 重置cur,继续向后删除链表中所有值为val的节点
                this.head.cnt -= 1; // 更新头节点中链表节点的个数
            } else {
                pre = cur;
                cur = cur.next;
            }
        }
    }

    /**
     * 打印单链表的所有节点元素的值
     */
    public void show(){
        Entry<T> cur = this.head.next;
        while (cur != null) {
            System.out.print(cur.data + " ");
            cur = cur.next;
        }
        System.out.println();
    }

    /**
     * 获取链表节点的个数
     * @return
     */
    public int size() {
        return this.head.cnt;
    }

    /**
     * 单链表的节点类型
     * @param <T>
     */
    static class Entry<T>{
        T data; // 链表节点的数据域
        Entry<T> next; // 下一个节点的地址

        public Entry(T data, Entry<T> next) {
            this.data = data;
            this.next = next;
        }
    }

    /**
     * 头节点的类型,添加了int cnt成员变量,记录链表中节点的个数
     * @param <T>
     */
    static class HeadEntry<T> extends Entry<T>{
        int cnt; // 用来记录节点的个数

        public HeadEntry(int cnt, T data, Entry<T> next) {
            super(data, next);
            this.cnt = cnt;
        }
    }
}

/**
 * 描述: 单链表测试
 * @Author administrator
 * @Date 5/11
 */
public class LinkTestUnit {

    @Test
    public void test01(){
        Random rd = new Random();
        Link<Integer> link1 = new Link<>();

        for (int i = 0; i < 10; i++) {
            link1.insertHead(rd.nextInt(20)+1); // 随机[1,20]间的元素值
        }
        for (int i = 0; i < 10; i++) {
            link1.insertTail(rd.nextInt(20)+1); // 随机[1,20]间的元素值
        }

        link1.show();
        System.out.println(link1.size());
        link1.remove(15);
        link1.show();
        System.out.println(link1.size());
    }
}

注意:上面链表尾插法insertTail,每次插入元素都要先从头节点开始,一个个遍历到末尾节点进行添加元素,时间复杂度是 O ( n ) O(n) O(n),解决办法是可以给链表添加一个成员变量tail,让tail永远指向末尾节点,然后尾插法把新节点直接插入到tail后面,再让tail指向新的末尾节点就可以了。

链表逆置

/**
 * 逆置单链表,思想是从链表第二个节点开始采用头插法重新链接节点
 */
public void reverse(){
    if(this.head.next == null){
        return;
    }

    // 从链表第二个节点开始逆置
    Entry<T> cur = this.head.next.next;
    this.head.next.next = null;
    Entry<T> post = null;

    while(cur != null){
        post = cur.next;
        cur.next = head.next;
        head.next = cur;
        cur = post;
    }
}

寻找链表倒数第K个节点

/**
 * 获取倒数第K个单链表节点的值
 * @param k
 * @return
 */
public T getLastK(int k){
    Entry<T> cur1 = this.head.next;
    Entry<T> cur2 = this.head;

    // cur1指向第一个节点,cur2指向正数第k个节点
    for (int i = 0; i < k; i++) {
        cur2 = cur2.next;
        if(cur2 == null){
            return null;
        }
    }

    // 当cur2到达末尾节点时,cur1指向的就是倒数第k个节点
    while(cur2.next != null){
        cur1 = cur1.next;
        cur2 = cur2.next;
    }

    return cur1.data;
}

判断链表是否有环,并且找出入环节点

/**
 * 判断链表是否有环,如果有,返回入环节点的值,没有环,返回null
 * @return
 */
public T getLinkCircleVal(){
    Entry<T> slow = this.head.next;
    Entry<T> fast = this.head.next;

    // 使用快慢指针解决该问题
    while(fast != null && fast.next != null){
        slow = slow.next;
        fast = fast.next.next;
        if(slow == fast){
            break;
        }
    }

    if(fast == null){
        return null;
    } else {
        /**
         * fast从第一个节点开始走,slow从快慢指针相交的地方开始走,
         * 它们相遇的时候,就是环的入口节点
         */
        fast = this.head.next;
        while(fast != slow){
            fast = fast.next;
            slow = slow.next;
        }
        return slow.data;
    }
}

判断两个单链表是否相交,并返回相交节点的值

/**
 * 判断两个单链表是否相交,思路就是先获取两个链表的长度,得到长度的差size,
 * 然后长链表先从头节点走size个,然后两个链表开始同时遍历,遇到相同的节点,说明
 * 链表相交了,如果遍历到null,说明链表没有相交
 * @param link
 * @return
 */
public T isLinkIntersect(Link<T> link){
    Entry<T> cur1 = this.head;
    Entry<T> cur2 = link.head;

    // 求两个链表的长度
    int len1 = 0;
    int len2 = 0;
    while(cur1 != null) {
        cur1 = cur1.next;
        len1++;
    }

    while(cur2 != null) {
        cur2 = cur2.next;
        len2++;
    }

    // 重置指针,找是否存在相交节点
    cur1 = this.head;
    cur2 = link.head;

    if(len1 > len2){ // 链表1比较长
        int size = len1 - len2;
        for(int i=0; i<size; ++i){
            cur1 = cur1.next;
        }
    } else if(len1 < len2){ // 链表2比较长
        int size = len2 - len1;
        for(int i=0; i<size; ++i){
            cur2 = cur2.next;
        }
    }

    while(cur1 != null && cur2 != null){
        if(cur1 == cur2){ // 两个指针指向同一个节点,链表相交了
            return cur1.data;
        }
        cur1 = cur1.next;
        cur2 = cur2.next;
    }

    return null;
}

合并两个有序单链表

/**
 * 合并两个有序的单链表
 * @param link
 */
public void merge(Link<T> link){
    Entry<T> p = this.head;
    Entry<T> p1 = this.head.next;
    Entry<T> p2 = link.head.next;

    // 比较p1和p2节点的值,把值小的节点挂在p的后面
    while(p1 != null && p2 != null){
        if(p1.data.compareTo(p2.data) >= 0){
            p.next = p2;
            p2 = p2.next;
        } else {
            p.next = p1;
            p1 = p1.next;
        }
        p = p.next;
    }

    if(p1 != null){ // 链表1还有剩余节点
        p.next = p1;
    }

    if(p2 != null){ // 链表2还有剩余节点
        p.next = p2;
    }
}

双向链表代码实现

/**
 * 双向链表的实现
 * @param <T>
 */
class Link<T extends Comparable<T>>{
    /**
     * 指向双向链表的头节点,其地址域中记录了链表第一个节点的地址
     */
    private Entry<T> head;

    /**
     * 构造函数,生成head指向的头节点,头节点不存数据
     */
    public Link(){
        head = new Entry<>(null, null, null);
    }

    /**
     * 双向链表的头插法
     * @param val
     */
    public void insertHead(T val){
        Entry<T> node = new Entry<>(val, this.head.next, this.head);
        this.head.next = node;
        if(node.next != null){
            node.next.pre = node;
        }
    }

    /**
     * 双链表的尾插法
     * @param val
     */
    public void insertTail(T val){
        Entry<T> cur = this.head;
        while(cur.next != null){
            cur = cur.next;
        }
        cur.next = new Entry<>(val, null, cur);
    }

    /**
     * 双向链表删除所有值为val的节点
     * @param val
     */
    public void remove(T val){
        Entry<T> cur = this.head.next;
        while(cur != null){
            if(cur.data.compareTo(val) == 0){
                cur.pre.next = cur.next;
                if(cur.next != null){
                    cur.next.pre = cur.pre;
                }
            }
            cur = cur.next;
        }
    }

    /**
     * 打印双向链表所有节点元素的值
     */
    public void show(){
        Entry<T> cur = this.head.next;
        while(cur != null){
            System.out.print(cur.data + " ");
            cur = cur.next;
        }
        System.out.println();
    }

    /**
     * 链表节点类型定义
     * @param <T>
     */
    static class Entry<T>{
        T data;
        Entry<T> next; // 存储后一个节点的地址
        Entry<T> pre; // 存储前一个节点的地址

        public Entry(T data, Entry<T> next, Entry<T> pre) {
            this.data = data;
            this.next = next;
            this.pre = pre;
        }
    }
}

/**
 * 描述:
 *
 * @Author administrator
 * @Date 5/11
 */
public class DoubleLinkTestUnit {
    public static void main(String[] args) {
        Random rand = new Random();
        Link<Integer> link = new Link<>();
        for (int i = 0; i < 10; i++) {
            link.insertHead(rand.nextInt(20) + 1);
        }
        for (int i = 0; i < 10; i++) {
            link.insertTail(rand.nextInt(20) + 1);
        }
        link.show();
        link.remove(8);
        link.show();
    }
}

栈介绍

栈是一种先进后出,后进先出的线性表数据结构,实现虽然简单,但是其用途非常的广泛,很多问题的求解都需要依赖一个栈结构,比如递归转非递归代码实现,一般都会依赖栈,比如二叉树的前中后序遍历的非递归实现;还有逆波兰表达式的求解也需要依赖栈,等等。下面总结一下Java实现的顺序栈和链栈代码。

顺序栈代码实现

/**
 * 顺序栈实现
 * @param <T>
 */
class SeqStack<T>{
    // 存储栈的元素的数组
    private T[] stack;
    // top表示栈顶的位置
    private int top;

    public SeqStack(){
        this(10);
    }

    public SeqStack(int size){
        this.stack = (T[])new Object[size];
        this.top = 0;
    }

    /**
     * 入栈操作
     * @param val
     */
    public void push(T val){
        if(full()){
            // 栈如果满了,要进行内存2倍扩容
            this.stack = Arrays.copyOf(this.stack,
                    this.stack.length*2);
        }
        this.stack[this.top] = val;
        this.top++;
    }

    /**
     * 出栈操作
     */
    public void pop(){
        if(empty())
            return;
        this.top--;
        this.stack[this.top] = null;
    }

    /**
     * 返回栈顶元素
     * @return
     */
    public T top(){
        return this.stack[this.top - 1];
    }

    /**
     * 判断栈满
     * @return
     */
    public boolean full(){
        return this.top == this.stack.length;
    }

    /**
     * 判断栈空
     * @return
     */
    public boolean empty(){
        return this.top == 0;
    }
}

链式栈代码实现

/**
 * 描述:链式栈结构
 */
public class LinkStack<T> {
    // top指向头节点,头节点的后面就是栈顶节点
    private Entry<T> top;

    public LinkStack(){
        this.top = new Entry<>(null, null);
    }

    /**
     * 入栈操作
     * @param val
     */
    public void push(T val){
        Entry<T> node = new Entry<>(val, this.top.next);
        this.top.next = node;
    }

    /**
     * 出栈操作
     * @return
     */
    public T pop(){
        T val = null;
        if(this.top.next != null){
            val = this.top.next.data;
            this.top.next = this.top.next.next;
        }
        return val;
    }

    /**
     * 查看栈顶元素
     * @return
     */
    public T peek(){
        T val = null;
        if(this.top.next != null){
            val = this.top.next.data;
        }
        return val;
    }

    /**
     * 判断栈空
     * @return
     */
    public boolean isEmpty(){
        return this.top.next == null;
    }

    /**
     * 节点类型定义
     * @param <T>
     */
    static class Entry<T>{
        T data;
        Entry<T> next;

        public Entry(T data, Entry<T> next) {
            this.data = data;
            this.next = next;
        }
    }
}

队列介绍

队列是一种先进先出,后进后出的线性表数据结构,其用途也十分广泛,比如二叉树层序遍历非递归实现、树或者图的广度优先遍历寻找最优路径信息,都需要用到队列这种数据结构。下面总结一下Java实现的循环队列和链式队列代码。

循环队列代码实现

/**
 * 循环队列
 */
class Queue<E>{
    // 存储队列元素的数组
    private E[] que;
    // 表示队头的位置
    private int front;
    // 表示队尾的位置
    private int rear;

    /**
     * 默认构造队列,初始大小是10
     */
    public Queue(){
        this(10);
    }

    /**
     * 用户可以指定队列的大小size
     * @param size
     */
    public Queue(int size){
        this.que = (E[])new Object[size];
        this.front = this.rear = 0;
    }

    /**
     * 入队操作
     * @param val
     */
    public void offer(E val){
        if(full()){
            // 扩容
            E[] newQue = Arrays.copyOf(this.que,
                    this.que.length*2);
            int index = 0;
            for(int i=this.front;
                i != this.rear;
                i=(i+1)%this.que.length){
                newQue[index++] = this.que[i];
            }
            this.front = 0;
            this.rear = index;
            this.que = newQue;
        }
        this.que[this.rear] = val;
        this.rear = (this.rear+1)%this.que.length;
    }

    /**
     * 出队操作,并把出队的元素的值返回
     */
    public E poll(){
        if(empty()){
            return null;
        }
        E front = this.que[this.front];
        this.que[this.front] = null;
        this.front = (this.front+1)%this.que.length;
        return front;
    }

    /**
     * 查看队头元素
     * @return
     */
    public E peek(){
        if(empty()){
            return null;
        }
        return this.que[this.front];
    }

    /**
     * 判断队满
     * @return
     */
    public boolean full(){
        return (this.rear+1)%this.que.length == this.front;
    }

    /**
     * 判断队空
     * @return
     */
    public boolean empty(){
        return this.rear == this.front;
    }
}

链式队列代码实现

/**
 * 链式队列
 * front:指向的是链表的头节点
 * rear: 永远指向的是末尾节点
 * @param <T>
 */
public class LinkQueue<T>{
    // 指向头节点(队头)
    private Entry<T> front;
    // 指向尾节点(队尾)
    private Entry<T> rear;
    // 记录队列节点的个数
    private int count;

    /**
     * 初始化,front和rear都指向头节点
     */
    public LinkQueue(){
        this.front = this.rear = new Entry<>(null, null);
    }

    /**
     * 入队操作
     * @param val
     */
    public void offer(T val){
        Entry<T> node = new Entry<>(val, null);
        this.rear.next = node;
        this.rear = node;
        this.count++;
    }

    /**
     * 出队操作
     * @return
     */
    public T poll(){
        T val = null;
        if(this.front.next != null){
            val = this.front.next.data;
            this.front.next = this.front.next.next;
            // 删除队列最后一个元素,要把rear指向front,队列才能判空
            if(this.front.next == null){
                this.rear = this.front;
            }
            this.count--;
        }
        return val;
    }

    public T peek(){
        T val = null;
        if(this.front.next != null){
            val = this.front.next.data;
        }
        return val;
    }

    /**
     * 判断队列空
     * @return
     */
    public boolean isEmpty(){
        return this.front == this.rear;
    }

    /**
     * 返回队列元素的个数
     * @return
     */
    public int size(){
        return this.count;
    }

    /**
     * 节点类型定义
     * @param <T>
     */
    static class Entry<T>{
        T data;
        Entry<T> next;

        public Entry(T data, Entry<T> next) {
            this.data = data;
            this.next = next;
        }
    }
}
计算机考研复试面试题整理 考研复试面试题整理 文章目录前言数据结构部分操作系统部分计算机网络部分C++JAVA编译原理软件工程排序算法专题 前言 笔者刚刚参加完2022年考研复试,现将复试过程中自己整理的部分面试题整理出来,仅供参考。 数据结构部分 1.数据结构按逻辑结构可以分为哪两类? 可以分为线性结构(线性表、栈、队列)和非线性结构(树、图、集合) 2.数据结构按存储结构可以分为哪两类? 顺序存储、链式存储、索引存储、散列存储。 3.顺序结构和链式结构的区别? 顺序结构是指内存连续的存储单元进行存储,而链式结构是指内存不连 阅读详情

相关推荐

顺序栈 链栈 顺序队列 链式队列 循环队列的常用算法.zip

主要包含顺序栈 链栈 顺序队列 链式队列 循环队列的入队出队 入栈出栈等常用算法操作

JAVA实现最简单的双向链表、队列与栈(内部使用链表形式存储)

队列和栈可以用链表的形式和数组的形式实现,两者的区别在于前者的存储空间是分散的,后者是连续并且固定的。 一、实现链式队列 public class Queue { /**  * 内部类,定义结点结构。  * @author clx44551  * @param  */ class Node { U val; Node next; Node() { this.val = n

clx44551的博客 1373

【GESP】C++四级考试大纲知识点梳理, (10) 文件读写和重定向

其实,由于本人也是边学、边实验、边总结,且对考纲深度和广度的把握属于个人理解。因此本文更多的不是一个教程,而是个人知识梳理,如有遗漏、疏忽,欢迎指正、交流。孩子放假,出游一周,没有更新。刚刚归来,继续学习。GESP C++四级官方考试大纲中,共有11条考点,本文针对第10条考点进行分析介绍。(10)掌握文件操作中的重定向,实现文件读写操作,了解文本文件的分类,掌握写操作、读操作、读写操作。GESP C++四级官方考试大纲中,共有11条考点,本文针对第10条考点进行分析介绍。孩子放假,出游一周,没有更新。

CoderCoding的博客 529

用不带头结点的链表存储链栈,设计初始化链栈、判断栈是否为空、进栈和出栈等相应的算法

#include <stdio.h> #include <malloc.h> typedef int elem; typedef struct LNode { elem data; struct LNode* next; }LNode; void initialStack(LNode*& L) { L = NULL; } int isEmpty(LNod...

weixin_42864185的博客 1478

RK3568平台 麦克风PDM接口录音_rk pdm配置

在RK平台,Android的Audio HAL层中一般会都会有导出录音播放数据的功能。如播放的,是会直接送到声卡中的,对于播放出现问题的情况,可以从分析导出的音频数据是否正常,可以基本知道,是在应用、解码出现的问题,还是送到声卡过程中出现问题。当点开app进行录音的时候会调用到static int start_input_stream(struct stream_in *in)。音频在PDM接口输入,不经过编解码芯片直接到RK主芯片,RK主芯片自带PCM编解码功能。以下软件能播放保存下来的pdm文件。

2401_83817122的博客 2345

DSPACE仿真平台的使用

DSPACE仿真平台的使用 文章目录DSPACE仿真平台的使用1.ModelDesk新建项目2.MotionDesk引入项目3.ControlDesk引入项目4.项目整合运行 我们使用DSPACE仿真平台软件来模拟小汽车的自动驾驶。 总共需要用到DSPACE大类下的三个软件:ModelDesk、ControlDesk、MotionDesk。 1.ModelDesk新建项目 在桌面上点击ModelDesk图标,打开DSPACE—ModelDesk 选择 File 标签,侧边栏选择 New,点击 New A

qq_42582489的博客 7538

链表栈的入栈和出栈操作

链表栈的入栈和出栈操作 #include #include typedef int ElemType; typedef struct  linknode {        ElemType data;  //数据域        struct linknode *next;  //指针域 }ListStack; //入栈 /*   已知变量:初始化的栈,存了数据的数组,

雨季的博客 5289

最新CobaltStrike4.8/CobaltStrike4.9、CS4.9/CS4.8、 Windows/Linux/Mac版下载

Cobalt Strike是一款基于java的渗透测试神器,常被业界人称为CS神器。自3.0以后已经不在使用Metasploit框架而作为一个独立的平台使用,分为客户端与服务端,服务端是一个,客户端可以有多个,非常适合团队协同作战,多个攻击者可以同时连接到一个团队服务器上,共享攻击资源与目标信息和sessions,可模拟APT做模拟对抗,进行内网渗透。 Cobalt Strike集成了端口转发、服务扫描,自动化溢出,多模式端口监听,win exe木马生成,win dll木马生成,java木马生成,

weixin_43167326的博客 7985

数据结构与算法第一期:栈,链表,队列

编程学习第一次作业 本周主要学习的数据结构有栈、队列和链表。需要实现一些基本的数据结构,和完成相应的LeetCode算法题。本作业都是通过Java编写的。 1.栈 1.1 编程实现特定需求 用数组实现一个顺序栈 public class ArrayStack { private String[] items; private int count; private int n; ...

dsyblog 385

Creo报错代码-9?手把手教你重新生成许可证文件(基于Creo 10.0)

本文详细解析Creo报错代码-9的成因及解决方案,重点介绍如何重新生成许可证文件以应对网络环境变化导致的验证失败。通过分步指南和高级技巧,帮助用户有效管理多网络环境下的Creo许可证问题,提升工作效率。

weixin_30839881的博客 569

SHP转TXT、TXT转SHP工具(附工具下载链接)

关于TXT,可以选择整个图层生成一个TXT。也可以勾选“每个地块单独存TXT”,然后选择一个字段,根据字段值,给每个地块生成一个TXT文件。支持选择和数据框一样的坐标系,也可以选择一个图层,工具会采用和这个图层一样的坐标系。1、TXT数据支持输入单个或者多个TXT文件,也可以直接选择TXT所在的文件夹。所有的TXT数据都生成到一个矢量数据图层。关于这一行的内容,可以在地块坐标行设置中进行设置。其他:①面节点闭合:勾选,则回到起点。属性描述:可以直接复制粘贴进来,也可以直接修改。也可以改为任意字母。

坐听风雨 4328

数据结构——栈和队列

栈:一种特殊的线性表,其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶,另一端称为栈底。栈中的数据元素遵守后进先出LIFO(Last In First Out)的原则。压栈:栈的插入操作叫做进栈/压栈/入栈,入数据在栈顶。出栈:栈的删除操作叫做出栈。出数据在栈顶。队列:只允许在一端进行插入数据操作,在另一端进行删除数据操作的特殊线性表,队列具有先进先出FIFO(First In First Out)。入队列:进行插入操作的一端称为队尾(Tail/Rear)。出队列。

薯条和番茄酱的博客 532

AI智算-K8s+vLLM & Ray:DeepSeek-r1 671B 满血版分布式推理部署实践

自从上次发布 【AI-智算】K8s+SGLang实战:DeepSeek-r1:671b满血版多机多卡私有化部署全攻略] 文章后,本次将演示另一个主流推理引擎工具——vLLM,结合K8s、LWS、Ray、Volcano等技术栈,部署DeepSeek-r1 671b 满血版分布式推理集群,并对比其与SGLang推理引擎的性能表现。

Kason_iWiki 1834

数据结构与算法必备的 50 个代码实现。

数据结构和算法是程序员的内功心法和基本功。无论是人工智能还是其它计算机科学领域,掌握扎实的数据结构和算法知识,往往会助力不少!今天给大家推荐一份不错的数据结构与算法资源。特点是:全代码实现!这份资源的作者王争老师是前 Google 工程师,5 万+人跟着学的《数据结构和算法之美》专栏作者。他总结了程序员必备的 50 个数据结构与算法,以及相应的代码实现。开源地址为:https...

weixin_33859504的博客 5805

Codex,Copilot 是什么

GitHub Copilot是什么 **GitHub Copilot** 是一款由 **GitHub** 和 **OpenAI** 合作开发的 **AI 代码辅助工具**,它基于 **OpenAI Codex 技术**,能够根据上下文自动生成代码建议,大幅提升编程效率

ZhangJiqun&191cm&85kg 6926

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

数据结构与算法 Java 版

我最早是在大一的时候,就接触了`数据结构与算法`。说实话,算是一场噩梦吧!非常难学,当时学得很懵逼,当然现在也是如此。竟然这么痛苦,那为啥我还要继续学呢?还专门写了篇文章?还弄了个开源项目 DataStructureAndAlgorithm?具体的缘由请听我慢慢道来。

Fantasy 1026

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

数据结构与算法必备的 50 个代码实现

点击上方“AI有道”,选择“置顶”公众号重磅干货,第一时间送达数据结构和算法是程序员的内功心法和基本功。无论是人工智能还是其它计算机科学领域,掌握扎实的数据结构和算法知识...

红色石头的专栏 1999

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

IDEA的使用指南

IDEA基于java的使用手册,可以最快速的上手,在使用中不断的丰富自己的使用技巧.

数据结构与算法之三(基础篇)

数组 数组是一种线性表数据结构,他是用一组连续内存空间,来存储相同类型的数据。 线性表就是数据排成像一条线一样的结构,比如数组、队列、栈。非线性表数据之间并不是前后关系,比如树、堆、图等。 因为数据是相同类型的,内存空间是连续的,使得数组可以随机访问,但也使数组不易插入和删除。 数组越界,假如你定义了一个数组长度为3,下标从0开始到下标为2,但你的条件语句写成了i<=3,说明数组到a[3]超...

小龙博客 215

11 数据结构、算法、设计模式

文章目录11-1 算法性能评估1)时间复杂度1.大O表示法只关注循环次数多的代码选大量级 11-1 算法性能评估 帖子:https://ceshiren.com/t/topic/10867 1)时间复杂度 规模:规模大小对算法至关重要 测试环境:运行环境:环境的快慢对算法至关重要 1.大O表示法 def tmp(n): add = 0 for i in range(n): add += 1 return add 运行 T(n) = (2n+1) * unit 算法的运行时间与数据规模成正比

weixin_50050403的博客 1210

《图解Java数据结构与算法:微课视频版》简介

本书系统、全面地介绍数据结构的基础理论与算法设计,精选数据结构考研习题和各类典型例题进行讲解,案例和课后习题丰富,突出对数据结构算法实践能力的培养。本书适合Java数据结构初学者,可作为高等院校计算机、软件工程等相关专业数据结构课程的教材,也可作为计算机软件开发、准备计算机专业研究生考试、参加各类算法竞赛、准备计算机软件资格考试的人员的参考用书。本书共分11章,内容包括数据结构与算法概述,线性表,栈和队列,串、数组和广义表,树,图,查找算法,排序算法,分治算法,贪心算法,回溯算法。

夏天又到了的专栏 427

分享一个开源的项目,数据结构和算法必知必会的50个代码实现

数据结构和算法必知必会的50个代码实现 这个开源项目是有前Google工程师打造出来的,使用了c,go,java,python,php等很多中语言实现了一些数据结构和算法,对于喜欢算法的来说可谓是一个福利,目前在github上面已经获得了4700+的star。 github地址 这个项目主要包含以下内容 数组 实现一个支持动态扩容的数组 实现一个大小固定的有序数组,支...

weixin_30415801的博客 213

Android面试——数据结构&算法

由(element)组成,并且是使用一块来存储。我们直接可以利用元素的索引(index)可以计算出该元素对应的存储地址。并且容量有限。

m0_37869471的博客 1201

浅谈常见数据结构和算法的应用系列(一)

近来有小伙伴问我:刷leetcode真的有用吗,觉得收益很小,越刷越迷茫了... 诚然每个人刷题的目的不一样,233酱还不是为了能水几篇文章... 当然不止。我觉得刷题是一件有意思的事,就像小猫小狗咬自己尾巴,玩弄的不亦乐乎。比喻可能不太恰当,是有种沉迷小游戏的感觉。可是在艰难打野的过程中,我们不要忘了,最重要的是:了解每种技能包的特点,适合解决的问题和场景。在特定实战场景下能够使用特定的技能包,自创技能包。这才是武功的至高境界。 装X结束,浅谈开始。。 数据结构是指:一种数据组织、管理和存储的格式,它.

Monica2333的博客 1271
上一篇: Java版高级数据结构算法 - Dijkstra迪杰斯特拉算法
下一篇: C++继承与多态 - 继承多态原理01
大秦坑王
博客等级 码龄17年 2677粉丝 31原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值
⌂ 换网址