数据结构与算法

已于 2024-08-13 11:22:51 修改
阅读量1.2k 收藏 29
点赞数 41
文章标签： java 开发语言 算法 数据结构
于 2024-08-01 12:07:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_15557237/article/details/140844187
版权

数据结构与算法

诺塔游戏：

请完成汉诺塔游戏的代码: 要求：1) 将 A 塔的所有圆盘移动到 C 塔。并且规定，在 2) 小圆盘上不能放大圆盘， 3)在三根柱子之间一次只能移动一个圆盘

八皇后问题

八皇后问题，是一个古老而著名的问题，是回溯算法的典型案例。该问题是国际西洋棋棋手马克斯·贝瑟尔于 1848 年提出：在 8×8 格的国际象棋上摆放八个皇后，使其不能互相攻击，即：任意两个皇后都不能处于同一行、 同一列或同一斜线上，问有多少种摆法。【92】=> 分治算法

马踏棋盘算法

介绍和游戏演示 1) 马踏棋盘算法也被称为骑士周游问题 2) 将马随机放在国际象棋的 8×8 棋盘 [0～7][0～7]的某个方格中，马按走棋规则(马走日字)进行移动。要求 每个方格只进入一次，走遍棋盘上全部 64 个方格

线性结构

  1. 线性结构作为最常用的数据结构，其特点是数据元素之间存在一对一的线性关系

  2. 线性结构有两种不同的存储结构，即顺序存储结构(数组)和链式存储结构(链表)。顺序存储的线性表称为顺序 表，顺序表中的存储元素是连续的

  3. 链式存储的线性表称为链表，链表中的存储元素不一定是连续的，元素节点中存放数据元素以及相邻元素的地 址信息

非线性结构

非线性结构包括：二维数组，多维数组，广义表，树结构，图结构

稀疏数组

稀疏数组的处理方法是:

  1. 记录数组一共有几行几列，有多少个不同的值 。把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模
二维数组转稀疏数组：
1 遍历原始的二维数组，得到有效数据的个数sum 
2.根据sum创建稀疏数组sparseArr int[sum+1][3]
3.将二维数组的有效数据存入稀疏数组。
稀疏数组转原始二维数组：
1.读取稀疏数组第一行，根据数据创建二维数组。
2.读取稀疏数组后几行的数据，还原二维数组。

public static void main(String[] args) throws IOException {
        //创建二维数组11*11 0表示无棋子，1黑子 2蓝子
        int chessArr1[][]=new int[11][11];
        chessArr1[1][2]=1;
        chessArr1[2][3]=2;
        //输出原始二维数组
        for (int[] row:chessArr1){
            for (int data:row){
                System.out.print(data+"\t");
            }
            System.out.println();
        }

        //将二维数组转为稀疏数组，遍历二维数组，获得非0的个数
        int sum=0;
        for (int i=0;i<11;i++){
            for (int j=0;j<11;j++){
                if (chessArr1[i][j]!=0){
                    sum++;
                }
            }
        }
        int sparseArr[][]=new int[sum+1][3];
        //给稀疏数组赋值 第一行输入
        sparseArr[0][0]=11;
        sparseArr[0][1]=11;
        sparseArr[0][2]=sum;

        //遍历二维数组，将非0的储存放到sparseArr中
        int count=0;//用于记录是第几个非0数据
        for (int i=0;i<11;i++){
            for (int j=0;j<11;j++){
                if (chessArr1[i][j]!=0){
                    count++;
                    sparseArr[count][0]=i;
                    sparseArr[count][1]=j;
                    sparseArr[count][2]=chessArr1[i][j];
                }
            }
        }
        //输出稀疏数组的形式
        System.out.println("稀疏数组");
        for (int i=0;i<sparseArr.length;i++){
            System.out.println(sparseArr[i][0]+"\t"+sparseArr[i][1]+"\t"+sparseArr[i][2]);
        }
        System.out.println();

        //将稀疏数组保存到文件中
        try (BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("src\\txtwj\\java.txt")))) {
            for (int[] row : sparseArr) {
                for (int data : row) {
                    bw.write(data);
                    bw.newLine();
                    bw.flush();
                }
            }
        }

        //读取稀疏数组，组成二维数组  长度为稀疏数组的00 01 读取稀疏数组从第二行开始
        int chessArr2[][] =new int[sparseArr[0][0]][sparseArr[0][1]];
        for (int i=1;i<sparseArr.length;i++){
            chessArr2[sparseArr[i][0]][sparseArr[i][1]]=sparseArr[i][2];
        }
        for (int i=0;i<chessArr2.length;i++){
            for (int j=0;j<chessArr2[i].length;j++){
                System.out.print(chessArr2[i][j]+"\t");
            }
            System.out.println();
        }
    }
队列

  1. 队列是一个有序列表，可以用数组或是链表来实现。

  2. 遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入的要后取出

1.目前数组使用一次就不能用， 没有达到复用的效果

  1. 将这个数组使用算法，改进成一个环形的队列 取模：%
public static void main(String[] args) {
    ArrayQueue array=new ArrayQueue(3);
    char key=' ';//接受用户输入
    Scanner sc=new Scanner(System.in);
    boolean loop =true;
    //输出一个菜单
    while (loop){
        System.out.println("s:显示队列");
        System.out.println("e:退出程序");
        System.out.println("a:添加数据");
        System.out.println("g:取出数据");
        System.out.println("h:查看队列头数据");
        key=sc.next().charAt(0);//接受一个字符
        switch (key){
            case 's':
                array.showQueue();  break;
            case 'a':
                System.out.println("输入一个数据");
                int number = sc.nextInt();
                array.addQueue(number);
                break;
            case 'g':
                try{
                    int res= array.getQueue();
                    System.out.println("取出的数据是："+res);
                }catch (Exception e){
                    System.out.println(e.getMessage());
                }
                break;
            case 'h':
                try{
                    int res=array.headQueue();
                    System.out.println("数据头是："+res);
                }catch (Exception e){
                    System.out.println(e.getMessage());
                }
                break;
            case 'e':sc.close();  //关闭Scanner
            loop=false;
        }
    }
}

static class ArrayQueue{
    private final int maxSize;//队列的最大容量
    private int front;//队列头
    private int rear;//队列尾
    private final int[] arr;//存放数据，模拟队列

    //创建队列构造器
    public ArrayQueue(int arrMaxsize){
        maxSize=arrMaxsize;
        arr=new int[maxSize];
        front=-1;//指向队列头部，分析出front是指向队列头的前一个位置。
        rear=-1;//指向队列尾，指向队尾的数据（队尾的最后一个数据）。
    }
    //判断队列是否满
    public boolean isfull(){
        return rear==maxSize-1;
    }
    //判断队列是否为空
    public boolean isempty(){
        return rear==front;
    }
    //添加数据到队列
    public void addQueue(int n){
        //添加之前判断队列是否满
        if (isfull()){
            System.out.println("队列已满，不能加入数据!");
            return;
        }
        rear++;//让rear后移
        arr[rear]=n;
    }
    //获取队列的数据，从队列中取出数据
    public int getQueue(){
        //取出队列之前先判断队列是否为空
        if (isempty()){
            throw new RuntimeException("队列为空，无法取出数据!");
        }
        front++;//让front后移
        return arr[front];
    }
    //显示队列数据
    public void showQueue(){
        if (isempty()){
            System.out.println("队列为空，没有数据!");
            return;
        }
        for (int i=0;i<arr.length;i++){
            System.out.printf("arr[%d]=%d\n",i,arr[i]);
        }
    }
    //显示队列头数据
    public int headQueue(){
        //判断 为空则无数据
        if (isempty()){
            throw new RuntimeException("队列为空，无数据!");
        }
        return arr[front+1];
    }
}
数组模拟环形数组

Java Queue常用方法

（1）获取头元素的方法

①poll()获取并移出队列的头，如果次队列为空，则返回null。

②remove()获取并移出此队列的头，如果此队列为空则抛出NoSuchElementException异常

（2）获取但是不移除

①peek()获取队列的头，但是不移除队列的头，如果次队列为空，则返回null。

②element()获取队列的头，但是不移除队列的头，如果队列为空，则将跑出NoSuchElementException异常。

（3）添加元素的方法

offer()将指定的元素插入此队列（如果立即可行且不会违反容量限制），插入成功返回true，否则返回false。当使用有容量限制的队列时offer()方法通常优于add()方法------add()方法可能无法插入元素，而是抛出一个IllegalStateException异常。

add()将制定的元素插入此队列。

对前面的数组模拟队列的优化，充分利用数组. 因此将数组看做是一个环形的。(通过取模的方式来实现即可)

  1. 尾索引的下一个为头索引时表示队列满，即将队列容量空出一个作为约定,

这个在做判断队列满的 时候需要注意 (rear + 1) % maxSize == front [满]

  1. rear == front [空]

取模

public static void main(String[] args) {
    ArrayQueue array=new ArrayQueue(4);
    char key=' ';//接受用户输入
    Scanner sc=new Scanner(System.in);
    boolean loop =true;
    //输出一个菜单
    while (loop){
        System.out.println("s:显示队列");
        System.out.println("e:退出程序");
        System.out.println("a:添加数据");
        System.out.println("g:取出数据");
        System.out.println("h:查看队列头数据");
        key=sc.next().charAt(0);//接受一个字符
        switch (key){
            case 's':
                array.showQueue();  break;
            case 'a':
                System.out.println("输入一个数据");
                int number = sc.nextInt();
                array.addQueue(number);
                break;
            case 'g':
                try{
                    int res= array.getQueue();
                    System.out.println("取出的数据是："+res);
                }catch (Exception e){
                    System.out.println(e.getMessage());
                }
                break;
            case 'h':
                try{
                    int res=array.headQueue();
                    System.out.println("数据头是："+res);
                }catch (Exception e){
                    System.out.println(e.getMessage());
                }
                break;
            case 'e':sc.close();  //关闭Scanner
                loop=false;
        }
    }
}

static class ArrayQueue {
    private final int Maxsize;
    private int front;
    private int rear;
    private final int[] arr;

    ArrayQueue(int size) {
        Maxsize = size;
        arr = new int[Maxsize];
        front = 0;
        rear = 0;
    }

    public boolean isfull() {
        return (rear + 1) % Maxsize == front;
    }

    public boolean isempty() {
        return rear == front;
    }
    public void addQueue(int n){
        if (isfull()){
            System.out.println("队列已满，无法添加数据！");
            return;
        }
        arr[rear]=n;
        //rear++;
        //取模
        rear=(rear+1)%Maxsize;
        //当rear达到最后一个时，即rear变成0，组成一个循环
    }
    public int getQueue(){
        if (isempty()){
            throw new RuntimeException("队列为空，无法取出数据！");
        }
        int temp=arr[front];
        //取模
        front=(front+1)%Maxsize;
        return temp;
    }
    public void showQueue(){
        if (isempty()){
            System.out.println("队列为空，没有数据！");
            return;
        }
        //遍历应该从front开始，遍历队列中的有效数据
        for (int i=front;i<front+size();i++){
            System.out.printf("arr[%d]=%d\n",i%Maxsize,arr[i%Maxsize]);
        }
    }
    public int headQueue(){
        //判断 为空则无数据
        if (isempty()){
            throw new RuntimeException("队列为空，无数据!");
        }
        return arr[front];
    }
    //队列中的有效数据
    public int size(){
        return (rear+Maxsize-front)%Maxsize;
    }
}
链表

  1. 链表是以节点的方式来存储,是链式存储

  2. 每个节点包含 data 域，next 域：指向下一个节点.

  3. 如图：发现链表的各个节点不一定是连续存储.

  4. 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定

单向链表

每个节点Node的next指向下一个节点。当next为null，则为链表的最后一个。

public static void main(String[] args) {
    //创建节点
    HeroNode hero1=new HeroNode(1,"宋江","及时雨");
    HeroNode hero2=new HeroNode(2,"卢俊义","玉麒麟");
    HeroNode hero3=new HeroNode(3,"吴用","智多星");
    HeroNode hero4=new HeroNode(4,"林冲","豹子头");

    //创建链表 添加节点
    SingleLinkedList hero=new SingleLinkedList();
    hero.add(hero1);
    hero.add(hero2);
    hero.add(hero3);
    hero.add(hero4);
    hero.show();

}
//定义个一个SingleLinkedList，管理链表
static class SingleLinkedList{
    //初始化头节点  头节点不做改变
    private final HeroNode head = new HeroNode(0," "," ");

    //添加节点到链表中 ：找到当前链表的最后一个节点，将最后节点的next，指向新的节点
    public void add(HeroNode heroNode){
        //需要一个辅助变量 temp 用于遍历链表，找节点的next
        HeroNode temp=head;
        //遍历链表，找到最后
        while (true){
            //找链表的最后一个节点的next,当temp为最后一个节点时，退出循环。
            if (temp.next==null){
                break;
            }
            //如果不是最后一个节点,就让temp指向下一个节点
            temp=temp.next;
        }

        //当temp为最后一个节点时，让temp指向新的节点
        temp.next=heroNode;
    }
    //显示链表，通过遍历
    public void show(){
        //头节点的next为空，则链表为空
        if (head.next==null){
            System.out.println("链表为空");
            return;
        }
        //遍历需要一个辅助变量来遍历
        HeroNode temp=head.next;
        for (;;){
            //判断是否到链表最后
            if (temp.next==null){
                break;
            }
            //不到最后则输出节点
            System.out.println(temp);
            //将temp后移，变量下一个
            temp=temp.next;
        }
    }
}
//定义HeroNode，每个HeroNode对象就是一个节点。
static class HeroNode{
    public int no;
    public String name;
    public String nickname;
    public HeroNode next;//指向下一个节点

    //构造器
    public HeroNode(int no,String name,String nickname){
        this.name=name;
        this.no=no;
        this.nickname=nickname;
    }

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

将no作为排名顺序：

第二种方式在添加英雄时，根据排名将英雄插入到指定位置 //(如果有这个排名，则添加失败，并给出提示。

public static void main(String[] args) {
        //创建节点
        HeroNode hero1=new HeroNode(1,"宋江","及时雨");
        HeroNode hero2=new HeroNode(2,"卢俊义","玉麒麟");
        HeroNode hero3=new HeroNode(3,"吴用","智多星");
        HeroNode hero4=new HeroNode(4,"林冲","豹子头");

        //创建链表 添加节点
        SingleLinkedList hero=new SingleLinkedList();
        hero.twoadd(hero1);
        hero.twoadd(hero4);
        hero.twoadd(hero3);
        hero.twoadd(hero2);
        hero.show();

    }
    //定义个一个SingleLinkedList，管理链表
    static class SingleLinkedList{
        //初始化头节点  头节点不做改变
        private final HeroNode head = new HeroNode(0," "," ");

        //添加节点到链表中 ：找到当前链表的最后一个节点，将最后节点的next，指向新的节点
        public void add(HeroNode heroNode){
            //需要一个辅助变量 temp 用于遍历链表，找节点的next
            HeroNode temp=head;
            //遍历链表，找到最后
            while (true){
                //找链表的最后一个节点的next,当temp为最后一个节点时，退出循环。
                if (temp.next==null){
                    break;
                }
                //如果不是最后一个节点,就让temp指向下一个节点
                temp=temp.next;
            }

            //当temp为最后一个节点时，让temp指向新的节点
            temp.next=heroNode;
        }

        //第二种添加方式：根据no的排名，将节点插入指定位置，如果已经存在这个no，则添加失败，给出提示
        public  void twoadd(HeroNode heroNode){
             //因为头节点不能动，因此我们仍然通过一个辅助指针来帮助找到添加的位置
            //因为为单链表，所有我们找到的temp是位于添加位置的前一个节点，否则无法插入
            HeroNode temp=head;
            boolean flag=false;// flag标识添加的编号是否存在
            while (true){
                if (temp.next==null){
                    break;
                }
                if (temp.next.no> heroNode.no){  //位置找到，就在temp后面插入
                    break;
                }else if (temp.next.no==heroNode.no){ //说明希望添加的heroNode的编号已经存在
                    flag=true;
                    break;
                }
                temp=temp.next;
            }
            //判断flag的值
            if (flag){  //true 节点已经存在，不能添加
                System.out.println("编号已经存在，不能添加");
            }else {
                //插入到temp后面
                heroNode.next=temp.next;
                temp.next=heroNode;
            }
        }
        //显示链表，通过遍历
        public void show(){
            //头节点的next为空，则链表为空
            if (head.next==null){
                System.out.println("链表为空");
                return;
            }
            //遍历需要一个辅助变量来遍历
            HeroNode temp=head.next;
            for (;;){
                //不到最后则输出节点
                System.out.println(temp);
                //判断是否到链表最后
                if (temp.next==null){
                    break;
                }
                //将temp后移，变量下一个
                temp=temp.next;
            }
        }
    }
    //定义HeroNode，每个HeroNode对象就是一个节点。
    static class HeroNode{
        public int no;
        public String name;
        public String nickname;
        public HeroNode next;//指向下一个节点

        //构造器
        public HeroNode(int no,String name,String nickname){
            this.name=name;
            this.no=no;
            this.nickname=nickname;
        }

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

更改与删除

public static void main(String[] args) {
    //创建节点
    HeroNode hero1=new HeroNode(1,"宋江","及时雨");
    HeroNode hero2=new HeroNode(2,"卢俊义","玉麒麟");
    HeroNode hero3=new HeroNode(3,"吴用","智多星");
    HeroNode hero4=new HeroNode(4,"林冲","豹子头");

    //创建链表 添加节点
    SingleLinkedList hero=new SingleLinkedList();
    hero.twoadd(hero1);
    hero.twoadd(hero4);
    hero.twoadd(hero3);
    hero.twoadd(hero2);
    hero.show();

    System.out.println();
    HeroNode hero5=new HeroNode(2,"卢姥爷","伞兵一号");
    hero.update(hero5);
    hero.show();

    System.out.println();
    hero.delete(hero1.no);
    hero.show();

}
//定义个一个SingleLinkedList，管理链表
//temp=temp.next 相当于i++
static class SingleLinkedList{
    //初始化头节点  头节点不做改变
    private final HeroNode head = new HeroNode(0," "," ");

    //添加节点到链表中 ：找到当前链表的最后一个节点，将最后节点的next，指向新的节点
    public void add(HeroNode heroNode){
        //需要一个辅助变量 temp 用于遍历链表，找节点的next
        HeroNode temp=head;
        //遍历链表，找到最后
        while (true){
            //找链表的最后一个节点的next,当temp为最后一个节点时，退出循环。
            if (temp.next==null){
                break;
            }
            //如果不是最后一个节点,就让temp指向下一个节点
            temp=temp.next;
        }

        //当temp为最后一个节点时，让temp指向新的节点
        temp.next=heroNode;
    }

    //第二种添加方式：根据no的排名，将节点插入指定位置，如果已经存在这个no，则添加失败，给出提示
    public  void twoadd(HeroNode heroNode){
         //因为头节点不能动，因此我们仍然通过一个辅助指针来帮助找到添加的位置
        //因为为单链表，所有我们找到的temp是位于添加位置的前一个节点，否则无法插入
        HeroNode temp=head;
        boolean flag=false;// flag标识添加的编号是否存在
        while (true){
            if (temp.next==null){
                break;
            }
            if (temp.next.no> heroNode.no){  //位置找到，就在temp后面插入
                break;
            }else if (temp.next.no==heroNode.no){ //说明希望添加的heroNode的编号已经存在
                flag=true;
                break;
            }
            temp=temp.next;  //相当于temp++;
        }
        //判断flag的值
        if (flag){  //true 节点已经存在，不能添加
            System.out.println("编号已经存在，不能添加");
        }else {
            //插入到temp后面
            heroNode.next=temp.next;
            temp.next=heroNode;
        }
    }
    //根据no编号来修改
    public void update(HeroNode newHeroNode){
        //判断是否为空
        if (head.next==null){
            System.out.println("链表为空");
            return;
        }
        //找到需要修改的节点，根据no编号
        //定义一个辅助变量
        HeroNode temp=head.next;
        boolean flag=false;  //表示是否找到节点
        while (true){
            if (temp==null){
                break;
            }
            if (temp.no== newHeroNode.no){
                flag=true;
                break;
            }
            temp=temp.next;
        }
        if (flag){  //如果flag为true，就把新的HeroNode赋值给temp，temp在赋值给原来的HeroNode
            temp.name= newHeroNode.name;
            temp.nickname= newHeroNode.nickname;;
        }else {
            System.out.println("没有找到这编号的节点");
        }

    }
    //head不动，找一个temp的辅助节点去指向被删除节点的前一个节点，并让前一个节点指向被删除的后一个节点
    public void delete(int no){
        HeroNode temp=head;
        boolean flag=false;  //标志是否找到待删除的节点

        while (true){
            if (temp.next==null){
                break;
            }
            if (temp.next.no==no){ //输入的编号 为temp的下一个编号编号相同，则为待删除编号
                flag=true;
                break;
            }
            temp=temp.next;
        }
        if (flag){  //flag为true则为找到待删除节点
            temp.next=temp.next.next;
        }else {
            System.out.println("没有找到要删除的节点");
        }
    }
    //显示链表，通过遍历
    public void show(){
        //头节点的next为空，则链表为空
        if (head.next==null){
            System.out.println("链表为空");
            return;
        }
        //遍历需要一个辅助变量来遍历
        HeroNode temp=head.next;
        for (;;){
            //不到最后则输出节点
            System.out.println(temp);
            //判断是否到链表最后
            if (temp.next==null){
                break;
            }
            //将temp后移，变量下一个
            temp=temp.next;
        }
    }
}
//定义HeroNode，每个HeroNode对象就是一个节点。
static class HeroNode{
    public int no;
    public String name;
    public String nickname;
    public HeroNode next;//指向下一个节点

    //构造器
    public HeroNode(int no,String name,String nickname){
        this.name=name;
        this.no=no;
        this.nickname=nickname;
    }

    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickname='" + nickname + '\'' +
最低0.47元/天 解锁文章
Ares陌
关注
  • 41
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构与算法必知基础知识
bigsai
01-06 1万+
原创公众号：bigsai 文章已收录在 全网都在关注的数据结构与算法学习仓库 欢迎star 前言 数据结构与算法是程序员内功体现的重要标准之一，且数据结构也应用在各个方面，业界更有程序=数据结构+算法这个等式存在。各个中间件开发者，架构师他们都在努力的优化中间件、项目结构以及算法提高运行效率和降低内存占用，在这里数据结构起到相当重要的作用。此外数据结构也蕴含一些面向对象的思想，故学好掌握数据结构对逻辑思维处理抽象能力有很大提升。 为什么学习数据结构与算法？如果你还是学生，那么这门课程是必修的，考研基本也.
数据结构与算法java_数据结构与算法(Java语言版).pdf
weixin_33968957的博客
02-12 1713
数据结构与算法( 语言版)Java周 鹏 雷国洪 谢从满 邓小炼 编著湖北科学技术出版社内 容 提 要, 、本书根据抽象数据类型的实现方法与Java语言的面向对象特性 抽象 封装了线性、 、 、 、 , 。表 堆栈 队列 二叉树 图等基本数据结构 较好地体现了面向对象的思想 在算法部,...
数据结构与算法——栈和队列
小田是个程序员的博客欢迎你的到来呀~
06-25 2万+
栈和队列是两种重要的线性结构，本篇文章详细总结了数据结构与算法中栈和队列的终点知识，并且结合代码片段实现其基本操作，干货满满，每一句话都是重点，希望能给更多的小伙伴在学习数据结构与算法时带来一定帮助...
学习JavaScript 数据结构与算法
我是一只蘑菇17的博客
11-10 2407
学习链接：https://github.com/XPoet/js-data-structures-and-algorithms JavaScript 数据结构与算法 1.数据结构(data structure) 数据结构是数据对象，以及存在于该对象的实例和组成实例的数据元素之间的各种联系 ​ 是计算机中存储、组织数据的方式。通常情况下，精心选择的数据结构可以带来最优效率的算法 2.解决问题方法的效率，根据数据的组织方式有关 3.常见的数据结构：数组，栈，链表，图，散列表，队
数据结构与算法知识点总结
OceanKeeper1215的博客
08-31 2276
存储结构： 逻辑结构： 集合：元素之间没有任何逻辑关系 线性结构： 线性表： 功能受限的表： 非线性的结构： 树： 二叉树的性质： 性质1：二叉树的第i层上至多有2^(i-1)（i≥1）个节点。 满二叉树：每层的节点数都是2^(i-1) 完全二叉树： 1、深度为k，有n个节点的二叉树当且仅当齐每一个节点都与深度为k的满二叉树编号从1到n的节点一一对应时。 2、除了最后一层外，其余每一层...
我是如何学习数据结构与算法的？
帅地
10-24 7980
数据结构与算法的地位对于一个程序员来说不言而喻。今天这篇文章不是来劝你们学习数据结构与算法的，也不是来和你们说数据结构与算法有多重要。 主要是最近几天后台有读者问我是如何学习数据结构与算法的，有没有什么捷径，是要看视频还是看书，去哪刷题等…而且有些还是大三大四的，搞的我都替你们着急、担心… 所以我今天就分享下自己平时都是怎么学习的。 学习算法的捷径就是多刷题 说实话，要说捷径，我觉得就是脚踏实地着...
数据结构与算法 — 贪心算法
人生只有一次，不妨大胆一点～～
04-10 2105
贪心算法
《数据结构与算法之美》学习汇总
热门推荐
Michael是个半路程序员
04-22 2万+
此篇文章是对自己学习这门课程的一个总结和课后的一些练习，做一个汇总，希望对大家有帮助。本人是半路程序员，2018年2月开始学习C++的，下面的代码基本都是C++11版本的，代码有错误的地方请不吝留言赐教。附有部分练习LeetCode、POJ的题目。
数据结构与算法01：绪论【LEARN FROM 李春葆《数据结构教程》】
是谢添啊
09-11 3000
数据：所有能够输入到计算机中，且能被计算机处理的符号的集合。数据结构中主要讨论结构化数据。数据元素：是数据（集合）中的一个“个体”，它是数据的基本单位。数据项：数据项是用来描述数据元素的，它是数据的最小单位。数据对象：具有相同性质的若干个数据元素的集合，如整数数据对象是所有整数的集合。默认情况下，数据结构中讨论的数据都是数据对象。数据结构。
数据结构与算法分析--C语言描述_数据结构与算法_
10-01
数据结构与算法是计算机科学的基础，对于理解和设计高效的软件至关重要。C语言因其高效、底层特性，常被用于实现数据结构和算法，使得程序更接近硬件，性能更优。本资源"数据结构与算法分析--C语言描述"是针对数据...
韩顺平老师尚硅谷Java数据结构与算法194集笔记
10-12
这是我从B站上看韩老师讲的数据结构与算法后整理的笔记 代码经过运行，欢迎批评指正 有些地方我感觉还是挺难的 大都经过我自己的语言进行描述，韩老师中期的表达可能或多或少也影响可阅读性，望先生们见谅
Python数据结构与算法分析（第2版）1
08-03
【Python数据结构与算法分析（第2版）】是一本专为Python程序员设计的书籍，旨在帮助读者深入了解数据结构和算法在Python环境中的应用。作者布拉德利·米勒和戴维·拉努姆以其丰富的实战经验，清晰地阐述了如何高效...
C++数据结构与算法 （第4版）
01-06
- 算法与数据结构的关系。 - **线性表**： - 顺序表与链表的概念及其优缺点。 - 链表操作（如插入、删除等）的具体实现。 - 循环链表和双向链表的特点及应用场景。 - **栈与队列**： - 栈的基本操作（如入栈、...
数据结构与算法分析 C语言描述（原书第2版）课后习题参考答案
01-02
数据结构与算法分析是计算机科学中的核心课程，它主要研究如何高效地组织和管理数据，以便于进行快速的检索、插入、删除等操作。C语言因其底层特性，常被用于实现这些复杂的数据结构和算法，使得理解更加直观，性能...
okhttp，retrofit,rxjava 是如何配合工作的 作用分别是什么
追梦的鱼儿
09-04 569
OkHttp、Retrofit 和 RxJava 是 Android 开发中常用的三种库，它们各自有不同的作用，并且可以很好地配合工作来实现网络请求和响应的处理。
JAVA基础：数据类型、命名规范
最新发布
weixin_53755148的博客
09-05 1281
变量类型就是用来指定变量中存储数据的类型。也称为数据类型。
SpringBoot 项目集成 xxl-job
qq_58159506的博客
09-03 716
SpringBoot 项目集成 xxl-job
nmt---Docker-compose自动化部署
qq_69920145的博客
09-03 1027
static-rr 权重, leastconn 最少连接, source 请求IP, 轮询 roundrobin。# 这⾥是容器中的IP地址，由于配置的是轮询roundrobin，weight 权重其实没有⽣效。# 这⾥是容器中的IP地址，由于配置的是轮询roundrobin，weight 权重其实没有⽣效。# 在 mysql 创建⼀个没有权限的haproxy⽤户，密码为空。# 在 mysql 创建⼀个没有权限的haproxy⽤户，密码为空。10. docker-compose移除容器。
Java数据结构与算法深度解析
“数据结构与算法Java语言描述，全网最全的Java数据结构与算法详解，包括详细目录、书签和图像描述，适用于深入学习。” 本文主要探讨了数据结构与算法的重要性及其在Java编程中的应用。数据结构和算法是编程的基础...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值