数据结构(二)

数据结构模拟题[二] 4. 设一棵树 T 中边的集合为 {(A ,B) ,(A,C),(A ,D),(B,E), (C,F),(C,G)} ,要求用孩子兄弟表。7. 设一组初始记录关键字序列为 (55 ,63, 44, 38,75, 80,31, 56) ,则利用筛选法建立的初始堆为。3. 设一组有序的记录关键字序列为 (13 ,18,24,35, 47,50,62, 83,90) ,查找方法用二分查找,要。6. 设有一组初始记录关键字为 (45 ,80, 48,40,22, 78),要求构造一棵二叉排序树并给出构造过程。 阅读详情

双向链表

双向链表应用实例
.1双向链表的操作分析和实现使用带head头的双向链表实现–水浒英雄排行榜管理单向链表的缺点分析:1)单向链表,查找的方向只能是一个方向,而双向链表可以向前或者向后查找。
2)单向链表不能自我删除,需要靠辅助节点,而双向链表,则可以自我删除,所以前面我们单链表删除时节点,总是找到temp,temp是待删除节点的前一个节点(认真体会)
.3)分析了双向链表如何完成遍历,添加,修改和删除的思路
在这里插入图片描述

代码实现
1)遍历方和单链表一样,只是可以向前,也可以向后查找
2)添加(默认添加到双向链表的最
(1)先找到双向链表的最后这个节点
(2)temp.next=newHeroNode
(3)newHeroNode.pre=temp;
3)修改思路和原来的单向链表一样.
4)删除(1)因为是双向链表,因此,我们可以实现自我删除某个节点
(2)直接找到要删除的这个节点,比如temp
(3)temp.pre.next=temp.next
(4)temp.next.pre=temp.pre;

package com.zy.LinkedList;


/**
 * @ClassName: DoubleLinkedListDemo
 * @Author: Tigger
 * @Title: 双向链表测试
 * @Datetime: 2020/8/15   20:05
 * @Package: com.zy.LinkedList
 */
public class DoubleLinkedListDemo {

    public static void main(String[] args) {

        System.out.println("双向链表测试");
        HeroNode2 node2 = new HeroNode2(1, "宋江", "及时雨");
        HeroNode2 heroNode2 = new HeroNode2(2, "卢俊义", "玉麒麟");
        HeroNode2 node21 = new HeroNode2(3, "吴用", "智多星");
        HeroNode2 node22 = new HeroNode2(4, "林冲", "豹子头");


        DoubleLinkedList list = new DoubleLinkedList();
        list.add(node2);
        list.add(heroNode2);
        list.add(node21);
        list.add(node22);

        list.list();

        //修改
        HeroNode2 newNode = new HeroNode2(4, "公孙胜", "入云龙");
        list.update(newNode);
        System.out.println("修改后的英雄信息");
        list.list();
        //删除
        list.delete(3);
        System.out.println("删除后的结果是");
        list.list();

    }
}

class DoubleLinkedList {

    // 先初始化一个头节点, 头节点不要动, 不存放具体的数据
    private HeroNode2 head = new HeroNode2(0, "", "");

    // 返回头节点
    public HeroNode2 getHead() {
        return head;
    }

    //遍历方法  双向链表遍历
    public void list() {
        if (head.next == null) {
            System.out.println("双向链表为空无法遍历");
            return;
        }
        //因为头节点,不能动,因此我们需要辅助变量来遍历
        HeroNode2 temp = head.next;
        while (true) {
            //判断是否到了链表的尾部
            if (temp == null) {
                break;
            }
            //输出节点信息
            System.out.println(temp);
            //将temp后移
            temp = temp.next;
        }
    }

    //添加节点到双向链表
    //思路当不考虑编号顺序时,
    //1.找到当前链路的节点,
    //将最后节点的next指向新的节点
    public void add(HeroNode2 hereNode) {

        //因为头节点不能动,所以我们需要一个临时temp去协助遍历
        HeroNode2 temp = head;
        //遍历链表找到最后
        while (true) {
            if (temp.next == null) {
                break;
            }
            //如果没有找到,就将temp后移到下一个节点
            temp = temp.next;
        }
        //当退出while循环时就表示,temp指向了链表的尾部
        //将最后节点的next指向新的节点
        temp.next = hereNode;
        hereNode.pre = temp;
    }

    //修改节点信息,根据编号修改,不能修改编号只能修改节点的数据

    public void update(HeroNode2 newHereNode) {
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        HeroNode2 temp = head.next;
        boolean flag = false;//表示是否找到
        while (true) {
            if (temp == null) {
                //表示已经遍历完了链表
                break;
            }
            if (temp.no == newHereNode.no) {
                //找到了
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            temp.name = newHereNode.name;
            temp.nickName = newHereNode.nickName;
        } else {
            System.out.println("没有找到角色");
        }
    }

    //删除节点信息 ,双向链表会删除指定的节点,不需要指定前一个辅助节点来帮助删除
    public void delete(int no) {
        //首先判断链表是否为空
        if (head.next == null) {
            System.out.println("不好意思,链表为空无法删除");
            return;
        }
        HeroNode2 temp = head;//temp是待删除节点的上一个节点
        Boolean flag = false;//判断待删除节点是否存在
        while (true) {

            if (temp.next == null) {//已经到了链表的最后
                break;
            }
            if (temp.next.no == no) {
                flag = true;
                break;
            }
            temp = temp.next;//temp后移,这样我们才能完成循环遍历


        }
        if (flag) {
            temp.pre.next = temp.next;//让被删除的节点的下一个节点的上一个节点指向被删除节点的上一个节点
            //如果想要删除的节点是最后一个节点时,最后节点下一节点是空,空的前一个节点也是空,这个时候执行了下面一行代码就会导致
            //空指针异常,因此我们需要进行if判断
            if (head.next != null) {
                temp.next.pre = temp.pre;//让被删除节点的下一个节点的前一位pre指向被删除节点的前一位
            }
        } else {
            System.out.println("不好意思,没有找到想过要被删除的节点");
        }
    }

}

class HeroNode2 {
    public int no;
    public String name;
    public String nickName;
    public HeroNode2 next;//定义指向下一个节点
    public HeroNode2 pre;//指向了上一个节点,从而形成双向链表

    public HeroNode2() {
    }

    public HeroNode2(int no, String name, String nickName) {
        this.no = no;
        this.name = name;
        this.nickName = nickName;

    }

    @Override
    public String toString() {
        return "HeroNode2{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickName='" + nickName + '\'' +
                '}';
    }
}

在这里插入图片描述

单向环形链表应用场景

约瑟夫环问题

Josephu(约瑟夫、约瑟夫环)问题Josephu问题为:设编号为1,2,…n的n个人围坐一圈,约定编号为k(1<=k<=n)的人从1开始报数,数到m的那个人出列,它的下一位又从1开始报数,数到m的那个人又出列,依次类推,直到所有人出列为止,由此产生一个出队编号的序列。
在这里插入图片描述

提示:用一个不带头结点的循环链表来处理Josephu问题:先构成一个有n个结点的单循环链表,然后由k结点起从1开始计数,计到m时,对应结点从链表中删除,然后再从被删除结点的下一个结点又从1开始计数,直到最后一个结点从链表中删除算法结束。

单向循环链表

在这里插入图片描述

约瑟夫问题的流程

在这里插入图片描述Josephu问题Josephu问题为:
设编号为1,2,…n的n个人围坐一圈,约定编号为k(1<=k<=n)的人从1开始报数,数到m的那个人出列,它的下一位又从1开始报数,数到m的那个人又出列,依次类推,直到所有人出列为止,由此产生一个出队编号的序列。
提示
用一个不带头结点的循环链表来处理Josephu问题:先构成一个有n个结点的单循环链表,然后由k结点起从1开始计数,计到m时,对应结点从链表中删除,然后再从被删除结点的下一个结点又从1开始计数,直到最后一个

创建环形链表的思路图解

在这里插入图片描述小孩出圈的顺序思路分析图
在这里插入图片描述代码:

package com.zy.LinkedList;


/**
 * @ClassName: Josepfu
 * @Author: Tigger
 * @Title: 约瑟夫问题(通过循环链表解决,也可以定义数组取模实现)
 * @Datetime: 2020/8/15   21:51
 * @Package: com.zy.LinkedList
 */
public class Joseph {
    public static void main(String[] args) {

        CircleSingleLinkedList linkedList = new CircleSingleLinkedList();
        linkedList.addBoys(125);
     //   linkedList.showBoy();

        linkedList.boyGouOut(1,2,125);
    }

}

//创建一个环形的单向链表
class CircleSingleLinkedList {
    //创建一个first节点
    private Boy first = null;

    //添加小孩节点构成一个环形链表
    public void addBoys(int nums) {
        // nums 做一个数据校验
        if (nums < 1) {
            System.out.println("nums的值不正确");
            return;
        }
        Boy curBoy = null; // 辅助指针,帮助构建环形链表
        // 使用for来创建我们的环形链表
        for (int i = 1; i <= nums; i++) {
            // 根据编号,创建小孩节点
            Boy boy = new Boy(i);
            // 如果是第一个小孩
            if (i == 1) {
                first = boy;
                first.setNext(first); // 构成环  即使是只有一个节点,也让他的下一个指向自己然后形成环形链表
                curBoy = first; // 让curBoy指向第一个小孩
            } else {
                curBoy.setNext(boy);//插入前的最后一个节点的下一位指向插入节点,
                boy.setNext(first);//插入节点的下一位指向first从而形成环形单向链表
                curBoy = boy;//让辅助指针右移从而实现不停的插入

            }
        }

    }
    //循环遍历出所有的节点

    /**
     * 功能描述:
     *
     * @Date: 2020/8/17
     * @Param: []
     * @Return: void
     * @Author: Tiger
     */
    public void showBoy() {
        if (first == null) {
            System.out.println("循环单向链表为空,无法遍历");
            return;
        }
        //因为first不能动,因此需要辅助指针帮助循环遍历
        Boy curBoy = first;
        while (true) {
            System.out.println("小孩的编号是" + curBoy.getNo());
            if (curBoy.getNext() == first) {
                //  System.out.println("说明已经遍历完毕");
                break;
            } else {
                curBoy = curBoy.getNext();//让curboy右移从而实现循环遍历节点
            }

        }
    }

    /**
     * 功能描述:
     *
     * @Date: 这个方法模拟小孩退出环形单向链表的一个方法
     * @Param: startNo:表示从第几个小孩开始数数
     * @Param: countNum: 表示数数几次
     * @Param: nums: 表示最开始有多少个小孩在这个圈中
     * @Return: void
     * @Author: Tiger
     */
    public void boyGouOut(int startNo, int countNum, int nums) {
        //先对数据进行校验
        if (first == null || startNo < 1 || startNo > nums) {
            System.out.println("参数输入有误,请重新输入");
            return;
        }
        //创建要给的辅助指针,帮助完成小孩出圈
        Boy helper = first;
        //需求创建一个辅助指针(变量)helper,实现让中国辅助指针指向环形链表所定义的头节点
        while (true) {
            if (helper.getNext() == first) {//说明helper已经指向了最后一个
                break;
            }
            helper = helper.getNext();
        }
        //报数之前有一个操作,先让first和helper移动k-1次
        for (int j = 0; j < startNo - 1; j++) {
            first = first.getNext();
            helper = helper.getNext();
        }
        //当小孩报数的时候,让first 和helper指针同时移动m -1 次,然后出圈
        //这里是循环操作,直到圈中只剩下一个节点
        while (true) {
            if (helper == first) {//说明圈中只有一个节点
                break;
            }
            //让first和helper同时移动countNum—1
            for (int i = 0; i < countNum - 1; i++) {
                first = first.getNext();
                helper = helper.getNext();
            }
            //这个时候first指向的节点,就是要出圈的小孩的节点
            System.out.println("小孩出圈的id是" + first.getNo());

            //这时将first指向的小孩节点出圈
            first = first.getNext();
            helper.setNext(first);
        }
        System.out.println("最后留在圈中小孩的id"+ first.getNo());


    }
}
//定义boy类  表示一个节点

class Boy {
    private int no;//编号
    private Boy next;//指向下一个节点,默认为空

    public Boy() {
    }

    public Boy(int no) {
        this.no = no;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public Boy getNext() {
        return next;
    }

    public void setNext(Boy next) {
        this.next = next;
    }
}

在这里插入图片描述

栈

栈的介绍:

1) 栈的英文叫(strack)
2)栈是一个先入后出的有序列表(FIFO)
3)栈(stack)是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端,为变化的一端,称为栈顶(Top),另一端为固定的一端,称为栈底(Bottom)
4)根据栈的定义可知,最先放入栈中元素在栈底,最后放入的元素在栈顶,而删除元素刚好相反,最后放入的元
素最先删除,最先放入的元素最后删除
5)图解方式说明出栈(pop)和入栈(push)的概念
在这里插入图片描述

应用场景

(1)子程序的调用,在跳往子程序之前,会先将下个指令的地址存到堆栈中去,直到子程序执行完毕之后再将其取出,以回到原来的程序中去。
(2)处理递归调用,和子程序的调用类似,只是除了存储下一个指令的地址之外, 也将参数,区域变量等数据都存入到栈中去,表达式的转换{中缀表达式转换成后缀表达式}与求值(实际解决)
(3)二叉树的遍历
(4)图形的深度优先(depth-first)搜索法

入门

(1)用数组模拟栈的使用,由于栈是一种有序列表,当然可以使用数组的的结构存储栈的数据内容,
(2)思路分析:
在这里插入图片描述代码:

package com.zy.strack;
import java.util.Scanner;

public class ArrayStackDemo {

    public static void main(String[] args) {
        //测试一下这个arrayStck是否正确
        ArrayStack stack = new ArrayStack(4);
        String key = "";
        boolean flag = true;//控制是否跳出菜单
        Scanner scanner = new Scanner(System.in);
        while (flag) {
            System.out.println("show :   表示显示栈");
            System.out.println("exit :   表示推出栈");
            System.out.println("push :   表示向栈中加数据");
            System.out.println("pop  :   表示移除栈中元素");
            System.out.println("请输入你的选择");
            key = scanner.next();
            switch (key) {
                case "show":
                    stack.list();
                    break;
                case "exit":
                    flag = false;
                    System.out.println("程序退出");
                    break;
                case "push":
                    System.out.println("请输入数字");
                    int i = scanner.nextInt();
                    stack.push(i);
                    break;
                case "pop":

                    try {
                        int pop = stack.pop();
                        System.out.println("出栈的数字是:" + pop);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    break;
            }
        }
    }

}

//定义一个数组模拟栈的类
class ArrayStack {
    private int maxsize;//栈的大小
    private int[] stack;//数组   数组模拟栈,数据就会存放在该数组种
    private int top = -1;//top表示栈顶,初始化值为-1

    //构造器
    public ArrayStack(int maxsize) {
        this.maxsize = maxsize;
        stack = new int[this.maxsize];
    }
    //栈满
    public boolean isFull() {
        return top == maxsize - 1;
    }

    //栈空
    public boolean isEmpty() {
        return top == -1;

    }

    //入栈
    public void push(int value) {
        //首先判断栈是否满了
        if (isFull()) {
            System.out.println("栈满");
            return;
        }
        top++;
        stack[top] = value;

    }

    //出栈
    public int pop() {
        if (isEmpty()) {
//            System.out.println("栈空无法删除");
            throw new RuntimeException("Stack is null ,you can't delete any data!!");
        }
        int value = stack[top];
        top--;
        return value;
    }

    //遍历的时候   遍历的时候需要从栈顶开始遍历
    public void list() {
        if (isEmpty()) {
            System.out.println("抱歉,该栈中没有数据");
            return;
        }
        for (int i = top; i >= 0; i--) {

            System.out.println(i + ":" + stack[i]);
        }
    }
}

栈实现简单的综合计算器(中缀表达式)

在这里插入图片描述思路分析:
在这里插入图片描述代码实现:

public class Calculator {

    public static void main(String[] args) {
        //根据之前的思路,完成一串表达式的计算
        String expression = "30+22*6-14";//如何处理多位数的情况
        //创建两个栈。一个存放数字,一个专门存放运算符
        ArrayStack2 numStack = new ArrayStack2(10);
        ArrayStack2 operStack = new ArrayStack2(10);
        //定义需要的变量  代替索引相当于指针 帮助我们去取到表达是中的每一个
        int index = 0;
        int number1 ;
        int number2 ;
        int oper ;
        int result ;
        String keepNum ="";//用于拼接多位数
        char ch = ' ';//将每次扫描的char保存到ch中去;
        //开始while循环扫描表达式
        while (true){
           //依次得到表达式 的每一个字符
           ch = expression.substring(index,index+1).charAt(0);
           //判断ch是什么,然后就行相应的操作
            if(operStack.isOper(ch)){//如果是运算符
                //判断当前的符号栈是否为空
                if(!operStack.isEmpty()){
                    //不为空的操作,会判断操作符的优先级(如果当前运算符的优先级小于或等于栈中的操作符的优先级
                    // 就需要从数栈中pop两个数,在运算符栈中pop出一个符号进行运算,将得到的结果入数栈,然后将新添加的符号如符号栈)
                    if(operStack.priority(ch)<=operStack.priority(operStack.peek())){
                        //从数栈中弹出两个数字与符号栈弹出的符号进行运算,将结果返回数栈,新加的符号入符号栈
                        number1 = numStack.pop();
                        number2 = numStack.pop();
                        oper  = operStack.pop();
                        result = numStack.cal(number1,number2,oper);
                        //把运算结果入数栈
                        numStack.push(result);
                        //把新加入的运算符入符号栈
                        operStack.push(ch);
                    }else{
                        //如果当前符号的运算符大于栈中的操作符,就直接入栈
                        operStack.push(ch);
                    }
                }else{
                    //为空的时候会直接存入到符号栈中去
                    operStack.push(ch);
                }
            }else{//如果是数,就直接放入到数栈中去
                //这里不能发现它是数就直接入数栈,有可能是多位数
                //再处理数的时候要向expression的的index后再看一位,如果是数子就继续扫描,如果是符号才入栈
                //因此我们需要定义一个字符串变量,进行数字字符的拼接使用

                //处理多位数
                keepNum += ch;

                //如果ch是最后一个为,直接入栈
                if(index ==expression.length()-1){
                    numStack.push(Integer.parseInt(keepNum));
                }else{
                    //判断下一个字符是不是数字,如果是数字就继续扫描,如果是符号就入栈
                    if(operStack.isOper(expression.substring(index+1,index+2).charAt(0))){
                        //这里的keepnum是字符串,所以要转换一下再存进去
                        numStack.push(Integer.parseInt(keepNum));
                        //注意  keepnum要清空不然后续都会跟着继续拼接
                        keepNum = "";
                    }
                }

            }
            //让index+1,并判断是否扫描到expression的最后
            index++;
            if(index>=expression.length()){
                break;
            }
        }
    //当表达式扫描完毕,就顺序的从数栈,符号栈pop出相应的数和符号,并运行,
        while (true){
            //如果符号栈为空,则计算到最后的结果,数栈中只有一个最终的 结果说明运算结束
            if (operStack.isEmpty()){
                break;
            }
            number1 = numStack.pop();
            number2 = numStack.pop();
            oper  = operStack.pop();
            result = numStack.cal(number1,number2,oper);
            //把运算结果入数栈
            numStack.push(result);
        }
       // System.out.println("最终的计算结果是:"+numStack.pop());
        System.out.printf("表达式%s =%d",expression,numStack.pop());
    }
}

class ArrayStack2 {
    private int maxsize;//栈的大小
    private int[] stack;//数组   数组模拟栈,数据就会存放在该数组种
    private int top = -1;//top表示栈顶,初始化值为-1

    //构造器
    public ArrayStack2(int maxsize) {
        this.maxsize = maxsize;
        stack = new int[this.maxsize];
    }

    //栈满
    public boolean isFull() {
        return top == maxsize - 1;
    }

    //栈空
    public boolean isEmpty() {
        return top == -1;

    }

    //入栈
    public void push(int value) {
        //首先判断栈是否满了
        if (isFull()) {
            System.out.println("栈满");
            return;
        }
        top++;
        stack[top] = value;

    }

    //出栈
    public int pop() {
        if (isEmpty()) {
//            System.out.println("栈空无法删除");
            throw new RuntimeException("Stack is null ,you can't delete any data!!");
        }
        int value = stack[top];
        top--;
        return value;
    }

    //遍历的时候   遍历的时候需要从栈顶开始遍历
    public void list() {
        if (isEmpty()) {
            System.out.println("抱歉,该栈中没有数据");
            return;
        }
        for (int i = top; i >= 0; i--) {

            System.out.println(i + ":" + stack[i]);
        }
    }

    //返回运算符的优先级   ,优先级由程序员选择,优先级使用数字表述,
    //返回的数字越大,优先级越高
    public int priority(int oper) {
        if (oper == '*' || oper == '/') {
            return 1;
        } else if (oper == '+' || oper == '-') {
            return 0;
        } else {
            return -1;//假定目前的操作符只有加减乘除,
        }

    }

    //判断是操作符还是数字
    public boolean isOper(char val) {
        return val == '+' || val == '-' || val == '*' || val == '/';

    }

    //计算方法
    public int cal(int number1, int number2, int oper) {
        int res = 0;//初始化结果,用来存放最终计算的结果

        switch (oper) {
            case '+':
                res = number1 + number2;
                break;
            case '-':
                res = number2 - number1;
                break;
            case '*':
                res = number2 * number1;
                break;
            case '/':
                res = number2 / number1;
                break;
        }
        return res;
    }
    //增加一个方法,可以返回当前栈顶的值,但不是真正的出栈pop
    public int peek(){

        return stack[top];
    }

}

《数据结构》实验二:线性表的实验 《数据结构》实验二:     线性表实验 一..实验目的      巩固线性表的数据结构,学会线性表的应用。 1.回顾线性表的逻辑结构,线性表的物理存储结构和常见操作。 2.学习运用线性表的知识来解决实际问题。 3.进一步巩固程序调试方法。 4.进一步巩固模板程序设计。 二.实验时间    准备时间为第2周到第4周,具体集中实验时间为第4周第2次课。 阅读详情

相关推荐

SCAU华南农业大学数据结构oj 实验二

创建一个空的顺序栈,并实现栈的入栈、出栈、返回栈的长度、返回栈顶元素、栈的遍历等基本算法。请将下面的程序补充完整。#define STACK_INIT_SIZE 100 // 存储空间初始分配量#define STACKINCREMENT 10 // 存储空间分配增量// 定义栈元素类型// Status是函数的类型,其值是函数结果状态代码,如OK等// 在栈构造之前和销毁之后,base的值为NULL// 栈顶指针// 当前已分配的存储空间,以元素为单位// 顺序栈。

Agt_von的博客 1998

数据结构 (二)

树及二叉树 首先我们先看树的概念 一棵树是由n(n>0)个元素组成的有限集合,其中: (1)每个元素称为结点(node); (2)有一个特定的结点,称为根结点或树根(root); (3)除根结点外,其余结点能分成m(m>=0)个互不相交的有限集合T0,T1,T2,……Tm-1。其中的每个子集又都是一棵树,这些集合称为这棵树的子树。 如下图是一棵典型的树: **1、**一个结点的子树个...

qq_43656233的博客 492

Apache-Plc4x-Modbus-Tcp学习记录(一)

Apache-Plc4x-Modbus-Tcp学习记录(一)

weixin_45325423的博客 6989

从零开始_学_数据结构(二)——树的基本概念

相比之前的帖子,对其进行了增添和完善。 ps:本颜色的字体是后续添加内容 —————————————————— 参考链接: 大话数据结构.pdf 图解数据结构(6)——树及树的遍历 http://www.cnblogs.com/yc_sunniwell/archive/2010/06/27/1766233.html 1.什么是树? 是一种数据结...

weixin_33712881的博客 394

小程序 video 控制器外观调整_Kessil 360X Tuna Sun无线控制器使用分享

之前分享了Kessil 360X Tuna Sun开箱记录,时间关系,没来得及使用WiFi Dongle无线控制器。昨晚抽空实操了一下,做个操作记录,希望对大家有参考Kessil无线模块操作指南官方视频英文教程配中文字幕,非常详尽语速较快,重点位置可以暂停操作点击边框调出视频工具条1、拆包取控制器,保存二维码Kessil WiFi Dongle包装打开包装就能看到Kessil无线控制模...

weixin_39759060的博客 4734

开源网格划分软件-Gmsh二次开发教程 (4)网格生成与控制​

​本章将深入讲解Gmsh的网格生成技术,包括全局/局部网格控制、边界层生成、自适应细化等,并提供完整的代码示例。

ZQGG的博客 1476

python数据结构(二)

栈的应用之进制转换:我们在大一的计算机基础甚至高中的课程都已经了解了进制,以及不同进制的转换方法。所谓进制,就是多少进制的几次幂,例如十进制下的233.就是2乘以10的平方加上3乘以十的一次方再加上3乘以10的0次方, 算法:十进制转换为二进制,采用的是除以二求余数的2算法,在除二的过程中,得到的余数是从低到高的次序,而输出是从高到低,所以需要一个站来反转次序 from pythonds.basi...

weixin_45635035的博客 173

从零构建:如何用MATLAB打造你的第一个Stewart平台运动学仿真器

本文详细介绍了如何使用MATLAB从零构建一个六自由度Stewart平台运动学仿真器,涵盖基础理论、环境配置、运动学建模、动态轨迹规划和实时可视化实现。通过MATLAB的Robotics System Toolbox和Simulink等工具,读者可以掌握六自由度Stewart平台的逆运动学求解、正运动学求解及仿真系统集成,适用于飞行模拟器和精密定位等应用场景。

peach的博客 867

《数据结构》实验二——二叉树的遍历

《数据结构》实验二报告 日期: 2020-11-23 程序名: shiyan2.c 实验内容: 二叉树的遍历 一、目的和要求(需求分析): 1、掌握二叉树的存储结构以及二叉树的建立和操作。 2、输入一串表达式后,建立二叉树,并对其进行先序、中序和后序的遍历。 (输入表达式如此形式:a+b*c-d-e/f….;以#号结束。) 3、递归实现表达式运算。 二、程序设计的基本思想,原理和算法描述: 程序的结构:首先定义二叉树,随后创建二叉树,此时利用flag判断记录表

123的博客 3117

手把手教你用高频注入法辨识永磁同步电机电感参数(附MATLAB仿真)

本文详细介绍了高频注入法在永磁同步电机电感参数辨识中的工程实践与MATLAB仿真指南。通过高频信号注入法,无需拆解电机即可在线精确测量Ld和Lq参数,适用于电动汽车驱动和工业伺服等高精度控制场景。文章包含信号设计、硬件实现、解调算法及完整MATLAB仿真模型构建,帮助工程师快速掌握这一关键技术。

orange的博客 292

已解决pywin32使用报错ImportError: DLL load failed while importing pywintypes: 找不到指定的模块。

已解决在安装pywin32库后import 引入win32com.client后,报错mod = importlib.util.module_from_spec(spec) ImportError: DLL load failed while importing pywintypes: 找不到指定的模块。

c1007857613的专栏 7046

二、数据结构

数组(线性,随机访问) 特点:编译时分配存储空间,存储空间连续,可快速查找、修改指定下标的数据,但是插入、删除时需要移动指定下标之后的数据 字符串和数组:字符串就是一维数组+结束标志(空字符) 链表(线性,顺序访问) 特点:包含数据域和指针域,程序执行时分配存储空间,存储空间不连续(数据和存储位置无关),数据可伸缩、定向,可快速插入、删除数据、修改数据,但是查找比较慢(需要从第一个数据开始遍历) ...

onj123的博客 213

SAP SD模块定价过程后台配置简介

只有手工输入定价时(例如,在定价中的定价浏览屏幕中),或者只有从外部处理转移这些定价时(例如,成本核算),才将这些定价包括在确定(价格确定、输出确定,批次确定)之中。定价过程的定义和分配是SD模块中最核心的配置,包含了条件表、条件类型、存取顺序、发票类型、客户定价过程等,确定了销售订单已什么价格销售、税率、附加折扣等多个条件行程有一个定价过程。12、小计:记录该条件类型在VBAP表中是否存储,以及其后续用途,如记入信贷,占用信贷额度,记入成本等,如果需要金额暂用信贷额度的话,在小计这里选择A即可。

我小时候很黑的博客 3784

关于数据结构(二)

  接着上文&lt;&lt;关于数据结构(一)&gt;&gt;,关于数据结构,在实际的开发中或多或少都有涉及到,只是看自己平时没有积累到。下面是我在项目中的几个实例: 一、UI返回功能 有六个大的UI部分,每一个大部分里面还有具体的条目,当然不管是大条目还是点击进去后的子条目在顶部都会有一个 Back(返回) 按钮,点击后可以返回上一次所在的UI 点击返回,回到上一次所在的UI 思路...

weixin_34342578的博客 76

K8S部署Java项目(Gitlab CI/CD自动化部署终极版)

每个人都有惰性,但不断学习是好好生活的根本,共勉!

感谢阅读 6955

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

不装第三方软件,用Windows自带三入口查显卡配置与驱动

在日常电脑使用与硬件维护中,查看显卡型号、显存容量和驱动版本是排查性能问题的常见需求。很多用户习惯下载鲁大师、GPU-Z等第三方工具,其实Windows系统自带了任务管理器、系统信息(msinfo32)和DirectX诊断工具(dxdiag)三套入口,无需安装即可获取关键硬件数据。任务管理器能实时显示GPU利用率与显存占用,适合快速判断游戏卡顿瓶颈;系统信息提供整机配置底单,可核对CPU、内存、BIOS及问题设备;dxdiag则针对图形驱动、当前显示模式及DirectX支持级别给出权威信息,并支持导出一份完

weixin_33888907的博客 280

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

二 数据结构

实现一个单链表,链表初始为空,支持三种操作:(1)向链表头插入一个数(2)删除第k个插入的数后面的数(3)在第k个插入的数后插入一个数现在要对该链表进行M次操作,进行完所有操作后,从头至尾输出整个链表:题目中第k个插入的数并不是指当前链表的第k个数。例如操作过程中一共插入n个数,按照插入时间顺序,这n个数依次为:第1个插入的数,第2个插入的数,…第n个插入的数。第一行M,代表操作次数6 4 6 5。

JaneHan_的博客 1118

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

【NEFU锐格】数据结构实验二

NEFU数据结构

qq_65022282的博客 643

HNU数据结构实验二报告

数据结构是HNU信科院大一下的一门课程,在我看来,这是学生第一次接触的更偏大学化的课程(后面这种课程就越来越多了),因为其任务相较大一上的衔接课程而言,更加繁琐且难度更高。这里上传自己当时的报告,以供后来的学弟学妹们参考交流,希望对大家的学习有所帮助。写的很一般,但也是当时花了不少时间写出来的qwq。

Wzasty的博客 314

数据结构实验二

【代码】数据结构实验二。

m0_73635984的博客 118

数据结构实验(二)

实验四 基于哈夫曼树的数据压缩算法 ,实验五 基于二叉树的表达式求值算法

2301_80167625的博客 881

数据结构二刷整理

数据结构 绪论: 框架梳理: 展开过大实在放不下TAT 1.什么是数据结构? 数据结构是一门研究非数值计算的程序设计问题的操作对象,以及他们之间的关系和操作等相关问题。 *程序设计=数据结构+算法 2.基本概念和术语 数据:是描述客观事物的符号,是计算机中可以操作的对象,是能被计算机识别,并输入给计算机处理的符号合集。 数据元素:是组成数据的有一定意义的基本单位,在计算机通常最为整体处理也被称作记录。(如mysql中的一行记录) 数据项:一个数据元素可以由若干个数据项组成,注意其是数据中不可分割的最小单

m0_49218627的博客 294
上一篇: spring(三)AOP、spring声明式事务、Webflux的执行流程和核心API
下一篇: SpringMVC处理Josn、文件上传下载、拦截器
·小脑斧·
博客等级 码龄7年 10粉丝 46原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值