数据结构与算法（2）

最新推荐文章于 2022-06-04 14:20:00 发布
最新推荐文章于 2022-06-04 14:20:00 发布
阅读量88 收藏
点赞数 1
文章标签： 数据结构 算法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Sakurs/article/details/120776106
版权

数组：

数组的基本操作：

public class partList {
    public static void main(String[] args) {

        //定义一个新的列表
        int [] array = new int[3];

        //数组的长度
        int arrayLength = array.length ;

        //给数组中的元素赋值
        for(int i = 0; i<arrayLength;i++){
            array[i] = i;
        }

        //遍历数组中的每个元素
        for(int i =0; i<arrayLength; i++){
            System.out.println("数组中的第"+i+"个元素为"+array[i]);
        }

    }
}

数组的添加：

package dataStructure;

import java.lang.reflect.Array;
import java.util.Arrays;

public class shuzu {
    public static void main(String[] args) {
        // 创建一个新的数组
        int [] array = new int [] {2,3,4};
        //快速查看数组中的元素
        System.out.println(Arrays.toString(array));
        //要加入数组的目标元素
        int des = 5;
        //数组长度
        int length = array.length;
        System.out.println(length);

        //添加一个新的元素在数组中
        //创建新的数组

        int [] array2 = new int[4];
        //将原来数组的每个元素添加到新的数组中去
        for(int i = 0;i<=length ;i++){
            if(i<length){
                array2[i] = array[i];
            }else {
                array2[length] = des;
            }
        }
        array = array2;
        System.out.println(Arrays.toString(array));
        
    }
}

数组的删除：

package dataStructure;

import java.util.Arrays;

public class shuzu2 {
    public static void main(String[] args) {
        // 创建一个新的数组
        int [] array = new int [] {2,3,4,5,6,7};
        //快速查看数组中的元素
        System.out.println(Arrays.toString(array));
        //要删除的数组中的目标元素的下标 / 数值为6
        int des =  4;

        //闯将一个新的数组，把删除前的赋值再新的数组，之后的赋值给新的数组
        int [] array2 = new int[array.length-1];

        for(int i =0; i<array.length-1 ;i++) {
            if (i < des) {
                array2[i] = array[i];
            } else {
                array2[i] = array[i + 1];
            }
        }

        array = array2 ;

        System.out.println(Arrays.toString(array));

    }
}

面向对象数组： 

package dataStructure;

import java.util.Arrays;

public class MyArray {
    private int [] elements ;

    public MyArray(){
        elements = new int [0];
    }

    ///获取数组对象的方法：
    public int size(){
        return elements.length;
    }
    ///展现数组中的元素
    public void show(){
        System.out.println(Arrays.toString(elements));
    }

    ///在数组中添加一个元素：
    public void add(int element){

        int [] element2 = new int[elements.length+1];

        for(int i = 0;i<elements.length ;i++){
            element2[i] = elements[i];
        }
        element2[elements.length] = element;

        elements = element2 ;
    }
    ///在数组中删除一个元素
    public void delete(int element_index){
        int [] element2 = new int[elements.length-1];

        if(element_index>elements.length-1){
            System.out.println("Error ; length is too long");
        }else {
            for(int i =0; i<elements.length-1 ;i++) {
                if (i < element_index) {
                    element2[i] = elements[i];
                } else {
                    element2[i] = elements[i + 1];
                }
            }
        }
        elements = element2;
    }
    ///取出指定位置的元素
    public int get(int index) {
        return elements[index];
    }

    ///插入一个元素到指定的
    public void insert(int index , int value){
        int [] element2 = new int [elements.length+1];
        for(int i =0; i<= elements.length; i++){
            if(i<index){
                element2[i] = elements[i];
            }else if(i == index){
                element2[index] = value;
            }else{
                element2[i] = elements[i-1];
            }
        }
        elements = element2;
    }
    ///替换一个位置的指定元素
    public void set(int index, int new_value){
        elements[index] = new_value;
    }
}

查找算法：

查找算法在数组中分为两类：线性查找和二分法查找

线性查找方法（check）：

    public void check(int value){

        int index = -1 ;

        for(int i =0; i<elements.length; i++){
            if(elements[i] == value){
                index = i;
            }else {
                continue;
            }
        }
        if(index == -1){
            System.out.println("您搜索的元素不存在");
        }else{
            System.out.println(index);
        }
    }

二分法查找：

package dataStructure;

/// binary search

public class check {
    public static void main(String[] args) {
        //目标数组
        int [] array = new int[]{0,1,2,3,4,5,6,7};
        //目标元素
        int target = 3;
        int index = -1;

        int begin = 0;
        int end = array.length;
        int middle = (begin+end)/ 2;
        System.out.println(middle);

        while (true){
            if(array[middle] == target){
                index = middle;
                break;
            }else {
                if(target>array[middle]){
                    begin = begin+1;
                }else {
                    end = end -1;
                }

                middle = (begin+end)/2;
            }
        }
        System.out.println("this is target index"+index);



    }
}

栈

 

package dataStructure;

public class MyStack {

    int [] elements ;

    public MyStack(){
        elements = new int[0] ;
    }

    //压入元素
    public void push(int element){
        int [] element2 = new int[elements.length+1];

        for(int i = 0;i<elements.length ;i++){
            element2[i] = elements[i];
        }
        element2[elements.length] = element;

        elements = element2 ;
    }

    //取出栈的元素
    public int pop(){

        if(elements.length==0){
            throw new RuntimeException("stack is empty");
        }

        int element = elements[elements.length-1];

        //创建新的数组，重新装入剩余的元素
        int [] element2 = new int[elements.length-1];
        for(int i =0; i<elements.length-1; i++){
            element2[i] = elements[i];
        }
        elements = element2;

        return element ;
    }
    
    //查看栈顶元素
    public int peek(){
        return elements[elements.length-1];
    }
    
    //判断栈是否为空
    public boolean isEmpty(){
        return elements.length == 0;
    }


}

队列：

 

package dataStructure;

import java.util.Arrays;

public class MyQueue {

    int [] elements;

    public MyQueue(){
        elements = new int [0];
    }
    //入队
    public void add(int element){
        int [] element2 = new int[elements.length+1];

        for(int i = 0;i<elements.length ;i++){
            element2[i] = elements[i];
        }
        element2[elements.length] = element;

        elements = element2 ;
    }

    //出队
    public int poll(){

        int poll_target = elements[0];

        int [] element2 = new int[elements.length-1];

        for(int i  =1 ;i<elements.length;i++){
            element2[i-1] = elements[i];
        }
        elements  = element2;

        return poll_target;

    }

    ///展现数组中的元素
    public void show(){
        System.out.println(Arrays.toString(elements));
    }

}

单链表

单链表的基本操作： 

package dataStructure;

public class Node {

    //节点内容
    int data ;
    //下一个节点
    Node next;

    public Node(int data){
        this.data = data;
    }
//
//    //为节点追加节点
//    public void append(Node n){
//        this.next = n;
//    }
    public Node append(Node n){
        //当前节点
        Node CurrentNode = this;
        while (true){
            Node NextNode = CurrentNode.next;
            if(CurrentNode.next == null){
                break;
            }
            CurrentNode = NextNode;
        }
        CurrentNode.next = n;

        return this;
    }

    //获取下一个节点
    public Node next(){
        return this.next;
    }

    public int getData(){
        return this.data;
    }

    //当前节点是否为最后一个节点
    public boolean isLast(){
        Node CurrentNode = this;
        if(this.next==null){
            return true;
        }else{
            return false;
        }
    }
}

单链表的增加与删除：

package dataStructure;

public class Node {

    //节点内容
    int data ;
    //下一个节点
    Node next;

    //有参数的构造方法
    public Node(int data){
        this.data = data;
    }

    //在节点之后添加一个节点
    public Node append(Node n){
        //当前节点
        Node CurrentNode = this;
        while (true){
            Node NextNode = CurrentNode.next;
            if(CurrentNode.next == null){
                break;
            }
            CurrentNode = NextNode;
        }
        CurrentNode.next = n;
        return this;
    }



    //获取下一个节点
    public Node next(){
        return this.next;
    }
    //获取节点的数据
    public int getData(){
        return this.data;
    }

    //当前节点是否为最后一个节点
    public boolean isLast(){
        Node CurrentNode = this;
        if(CurrentNode.next==null){
            return true;
        }else{
            return false;
        }
    }


    //显示节点中的所有信息：
    public void show(){
        Node CurrentNode = this;
        while (true){
            System.out.println("this is data"+CurrentNode.data );
            CurrentNode = CurrentNode.next;
            if(CurrentNode.next == null){
                System.out.println("this is data"+CurrentNode.data);
                break;
            }
        }
    }


    //删除下一个节点
    public void removeNext(){
        Node CurrentNode = this;
        Node NextNode = CurrentNode.next;
        CurrentNode.next = NextNode.next;
    }

    // 在节点之后添加一个新的节点
    public void addNext(Node n){
        //取出当前节点
        Node CurrentNote = this;
        //取出下一个节点
        Node NextNote = CurrentNote.next;
        //将新节点作为下一个节点
        this.next = n;
        //把下一个节点设置为新节点的下一个节点
        n.next = NextNote ;
    }
}

循环链表：

package dataStructure;

public class NoteLoop {
    //节点内容
    int data ;
    //如果只有一个节点，下一个节点就是自己
    NoteLoop next = this;  循环链表就是自己循环自己

    //有参数的构造方法
    public NoteLoop(int data){
        this.data = data;
    }


    //获取下一个节点
    public NoteLoop next(){
        return this.next;
    }

    //获取节点的数据
    public int getData(){
        return this.data;
    }

    //删除下一个节点
    public void removeNext(){
        NoteLoop CurrentNoteLoop = this;
        NoteLoop NextNoteloop = CurrentNoteLoop.next;
        CurrentNoteLoop.next = NextNoteloop.next;
    }

    // 在节点之后添加一个新的节点
    public void addNext(NoteLoop noteLoop){
        //取出当前节点
        NoteLoop CurrentNoteLoop = this;
        //取出下一个节点
        NoteLoop NextNoteLoop  = CurrentNoteLoop.next;
        //将新节点作为下一个节点
        this.next = noteLoop;
        //把下一个节点设置为新节点的下一个节点
        noteLoop.next = NextNoteLoop ;
    }
}

iCake丶
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构与算法ch2-综合文档
05-25
数据结构与算法ch2
java数据结构与算法.pdf
01-04
包含了各种数据结构和算法（java）的实现方式和详解（图解），包括单双链表、环形链表（约瑟夫问题）、栈、后缀表达式、中缀表达式转后缀表达式、迷宫问题、八大排序算法、多种查找算法、哈希表、二叉树实现以及操作...
【试题】排列组合
二斗墨汁
04-26 296
在写一个远程的代码，如果本地有M个显示器，远程有N个显示器（M<=N），依据分辨率、显示器刷新频率等要求，需要对远程的N个显示器进行最佳分辨率修改，之后，需要从N个远程显示器中选择M个，跟本地显示器进行一对一的匹配。 即从 A(N, M) = N! / (N-M)! 种组合选择1种最优匹配，这里用到了排列组合，而 std::next_permutation()用于全排列A(N, N) = ...
Java集合深入学习 - Vector源码解析
luo_mu_hpu的博客
06-01 112
Vector与ArrayList实现大致相同，只是Vector再操作数据的实话会加锁，所以是线程安全的，其次Vector扩容大小默认为当前大小的额2倍，且其扩容值是可以指定的。部分源码如下： public class Vector<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable { //存放数据的数组 prot
集合框架源码分析(jdK1.7)（七） Vector
吾生也有涯，而学也无涯，以有涯随无涯
07-02 202
目录 1.Vector的数据结构 2.主要参数 3.核心构造方法 4. add(E e)方法 5扩容方式 6get(int index)方法 7 remove(int index) 7.1 arraycopy（）方法 8.总结 1.Vector的数据结构 protected Object[] elementData; //可以看出来Vector的数据结构和Ar...
Java集合框架之九-------------Vector和Stack源码解析
huangwei18351的博客
08-31 156
1.Vector源码解析 1.1.简介 通过阅读源码发现Vector和ArrayList基本上是很相似的，只是Vector的增删改查方法上都加了synchronized关键字，所以是线程安全的，但是直接通过synchronized同步机制实现的线程安全会导致效率很低，所以基本上Vector很少被使用，下面就是Vector的增删改查方法和一起辅助方法的源码分析。 1.2.成员变量 底...
数据结构与算法学习笔记
热门推荐
ityqing的博客
09-25 33万+
本文是王争老师的《算法与数据结构之美》的学习笔记，详细内容请看王争的专栏。有不懂的地方指出来，我做修改。 数据结构与算法思维导图 数据结构指的是“一组数据的存储结构”，算法指的是“操作数据的一组方法”。 数据结构是为算法服务的，算法是要作用再特定的数据结构上的。 最常用的数据结构预算法: 数据结构：数组、链表、栈、队列、散列表、二叉树‘、堆、跳表、图、Tire树 算法： 递归...
数据结构与算法——算法
小田是个程序员的博客欢迎你的到来呀~
06-04 1万+
算法是对特定问题求解的步骤的一种具体描述，算法是指令的有有限序列，其中每一条指令表示一个或是多个操作，用于解决某个问题。本文主要讲解了数据结构与算法——算法的基本概念，知识点详细。...
数据结构与算法（总结）
weixin_45397053的博客
04-23 5万+
总结： 一、数据结构（Data Structure） 是数据的组织结构，用来组织、存储数据。算法（Algorithm） 就是解决问题的方法或者过程。 二、数据结构分为逻辑结构和物理结构。逻辑结构分为集合结构、线性结构、树形结构、图形结构；物理结构分为顺序存储结构、链式存储结构。 三、算法是一系列运算步骤。算法有5个基本特性，输入、输出、有穷性、确定性、可行性；算法最求5个目标，正确性、可读性、健壮性、运行时间少、内存空间小。 四、「数组」 是实现线性表的顺序结构存储的基础；「链表」 是实现线性表的链式存储结
数据结构与算法——知识点总结
记录知识，学习分享
06-02 2万+
本文包含数据结构与算法主要的基本知识点，便于知识的梳理和回顾。 如需详细了解具体知识点请自行结合课本或者网上查阅。 目录 1、概述 2、线性表 3、栈 4、队列 5、串 6、多维数组和广义表 7、树和二叉树 8、图 9、查找 10、排序 1、概述 从 2、线性表 3、栈 4、队列 5、串 6、多维数组和广义表 7、树和二叉树 8、图 9、查找 10、排序 ...
数据结构KMP算法配图详解（超详细）
weixin_46007276的博客
02-18 20万+
前言 KMP算法是我们数据结构串中最难也是最重要的算法。难是因为KMP算法的代码很优美简洁干练，但里面包含着非常深的思维。真正理解代码的人可以说对KMP算法的了解已经相当深入了。而且这个算法的不少东西的确不容易讲懂，很多正规的书本把概念一摆出直接劝退无数人。这篇文章将尽量以最简单的方式介绍KMP算法以及他的改进，文章的开始我先对kmp算法的三位创始人Knuth,Morris,Pratt致敬，懂得这...
数据结构（严蔚敏版）与算法的实现（含全部代码）
关注网络安全、云原生安全
09-13 13万+
目录 基础 c/c++ 代码优化及常见错误 c语言位运算的妙用-程序优化 c/c++进制转换方法汇总（含全部代码） 二进制数-北邮2012研究生复试 质因子分解 除树和图外的数据结构可以使用STL: C++ STL的使用 数据结构 线性表 顺序表 循环左移（2010联考真题） 单链表 单链表相邻结点逆置(2019北邮考研真...
恋上数据结构与算法课件.rar
11-23
主要针对复杂度、链表、栈、队列、二叉树、B树、红黑树、集合。课件包含图片展示，容易理解，爱，就码上行动。
数据结构与算法2
03-05
数据结构与算法
韩顺平老师尚硅谷Java数据结构与算法194集笔记
10-12
这是我从B站上看韩老师讲的数据结构与算法后整理的笔记 代码经过运行，欢迎批评指正 有些地方我感觉还是挺难的 大都经过我自己的语言进行描述，韩老师中期的表达可能或多或少也影响可阅读性，望先生们见谅
数据结构与算法 实战代码
最新发布
03-13
数据结构与算法 实战代码
数据结构与算法PPT
04-17
数据结构与算法，数据结构与算法课件，数据结构与算法PPT
数据结构和算法PDF文档
06-02
1000多页的算法题解，包含数据结构，排序，查找，递归，回溯算法，二叉树，动态规划，贪心算法，双指针，滑动窗口，前缀和等。
Java数据结构与算法源代码
02-04
数据结构与算法的定义 1.广义上理解数据结构与算法： 数据结构是指一组数据的存储结构。算法就是操作数据的一组方法。 ps:图书馆管理员将书籍分门别类“存储”，按照一定规律编号，就是书籍这种“数据的存储结构...
dsa 数据结构与算法
01-14
DSA是指数据结构与算法。数据结构是指数据的组织和存储方式，而算法是指解决问题的方法和步骤。数据结构与算法是计算机科学中非常重要的一个领域，它们是构建高效程序和解决复杂问题的基础。 数据结构包括数组、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值