JAVA数据结构与算法基础学习笔记(一)

数据结构
数据结构 算法
发布日期:   2020-05-25
文章字数:   2.9k
阅读时长:   12 分
阅读次数:  

一、概述

数据结构概述

  1. 数据结构的定义：数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。
  2. 数据存储结构：
    顺序存储
    链式存储
  3. 数据的逻辑结构：
    集合结构：其中的元素属于一个集合，它们是并列关系，没其它关系
    线性结构：元素之间一对一的关系
    树形结构：元素之间一对多的关系，比如文件跟文件夹的关系
    图形结构：元素多对多的关系，呈网状

    算法概述

  4. 算法的定义：是指解题方案的准确而完整的描述，是一系列解决问题的清晰指令，算法代表着用系统的方法描述结局问题的策略机制。
  5. 算法的特性：输入，输出，有穷性，无穷性，确定性，可行性
  6. 算法的基本要求：正确性，可读性，健壮性，时间复杂度，空间复杂度

    二、线性结构

    数组

    数组的基本使用：

  7. 创建数组，赋值，取值：
//一维数组
int arr1[] = new int[]{1,2,3,4,5};
int arr2[] = {1,2,3,4};
//二维数组
int myarr[][] = {{1,2,3},{3,4,5,6}};   //为每一维分配内存的数组
  1. 处理数组：
public class TestArray {
   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};

      // 打印所有数组元素
      for (int i = 0; i < myList.length; i++) {
         System.out.println(myList[i] + " ");
      }
      // 计算所有元素的总和
      double total = 0;
      for (int i = 0; i < myList.length; i++) {
         total += myList[i];
      }
      System.out.println("Total is " + total);
      // 查找最大元素
      double max = myList[0];
      for (int i = 1; i < myList.length; i++) {
         if (myList[i] > max) max = myList[i];
      }
      System.out.println("Max is " + max);
   }
}
  1. 解决向数组添加元素，但因为数组的长度不可变，不能直接添加的问题
package domo;
import java.util.Arrays;
public class TestArray1{
  //创建数组并初始化
  int[] arr = new int[] {4,5,6};
  //快速查看数组中的元素
  System.out.println(Arrays.toString(arr));
  //要加入数组的目标元素
  int dst = 6;

  //创建一个新数组，长度是原数组+1
  int[] newArr = new int[arr.length+1];
  //把原数组中的数据全部复制到新的数组中
  for(int i=0;i<arr.length;i++>){
    newArr[i] = arr[i]
  }
  //把目标元素放入新数组的最后
  newArr[arr.length] = dst;
  //新数组替换原数组
  arr = newArr;
  System.out.println(Arrays.toString(arr));
}
  1. 解决删除数组中的某个元素的问题
package domo;
import java.util.Arrays;
public class TestArray2{
  //创建数组并初始化
  int[] arr = new int[] {4,5,6,7,8,9};
  //快速查看数组中的元素
  System.out.println(Arrays.toString(arr));
  //要删除的元素的下标
  int dst = 3;

  //创建一个新数组，长度是原数组-1
  int[] newArr = new int[arr.length-1];
  //复制原数组中除了要删除的那个元素以外的其它元素
  for(int i=0;i<newArr.length;i++>){
    //要删除的元素之前的元素
    if(i<dst>){
      newArr[i] = arr[i];
    }else{
      newArr[i] = arr[i+1];
    }
  }

  //新数组替换原数组
  arr = newArr;
  System.out.println(Arrays.toString(arr));
}

面向对象的数组

数组对象类
1.数组的元素插入
2.数组的元素的删除
3.数组元素的修改
4.数组元素的查看
5.数组元素的遍历
6.数组元素的长度

package array;

public class ArrayUtil {

    //用于存储整形数据的数组
    private int[] elements;

    //重写构造方法
    public ArrayUtil(){
        //初始化数组
        elements=new int[0];
    }

/********         数组插入元素       **************/

    /**
     * 向数组任意位置插入元素
     * @param number
     * @param element
     * @return
     */
    public int[] add(int number,int element){
        //判断插入位置的合理性
        if(number < 0  || number >elements.length){
            throw new RuntimeException("下标越界");
        }
        //创建一个新的数组，数组长度是原数组的长度+1
                int [] arr=new int[elements.length+1];
                //遍历原数组
                for(int i=0;i<elements.length;i++){
                    //判断插入位置，留出插入位置
                    if(i<number){
                        arr[i]=elements[i];
                    }else {
                        arr[i+1]=elements[i];
                    }
                }
                //插入位置添加元素
                arr[number]=element;
                //新数组赋值给原数组
                elements=arr;
                //返回原数组，数组插入元素完成
                return elements;
    }

    /**
     * 向数组头部添加一个元素
     * @param element
     * @return
     */
    public int[] addHead(int element){
                //创建一个新的数组，数组长度是原数组的长度+1
                int [] arr=new int[elements.length+1];
                //遍历原数组，将元素组的值通过下标一一赋值给新数组，新数组下标总是大于原数组下标1
                for(int i=0;i<elements.length;i++){
                    arr[i+1]=elements[i];
                }
                //为新数组的第一个索引赋值需要添加的元素
                arr[0]=element;
                //新数组赋值给原数组
                elements=arr;
                //返回原数组，数组头部添加元素完成
                return elements;
    }




    /**
     * 向数组末尾添加一个元素
     * @param element
     * @return
     */
    public int[] addEnd(int element){
        //创建一个新的数组，数组长度是原数组的长度+1
        int [] arr=new int[elements.length+1];
        //遍历原数组，将元素组的值通过下标一一赋值给新数组
        for(int i=0;i<elements.length;i++){
            arr[i]=elements[i];
        }
        //为新数组的最后一个索引赋值需要添加的元素
        arr[elements.length]=element;
        //新数组赋值给原数组
        elements=arr;
        //返回原数组，数组末尾添加元素完成
        return elements;
    }



    /********         数组插入元素END       **************/







    /********         数组删除元素       **************/

    /**
     * 删除任意位置的一个元素
     * @param number
     * @return
     */

    public int[] delete(int number){
                //判断删除的元素是否为空数组
                if(elements.length<=0){
                    throw new RuntimeException("这是一个空数组");
                }
                //判断删除下标位置的合理性
                if(number <0 || number >=elements.length){
                    throw new RuntimeException("下标越界");
                }
                //创建一个新的数组，数组长度是原数组的长度+1
                int [] arr=new int[elements.length-1];
                if(elements.length == 1){
                    //新数组赋值给原数组
                    elements=arr;
                //返回原数组，数组末尾添加元素完成
                }else{
                    //遍历数组
                    for(int i=0;i<arr.length;i++){
                        if(i<number){
                            arr[i]=elements[i];
                        }else{
                            arr[i]=elements[i+1];
                        }
                    }
                }
            //新数组赋值给原数组
            elements=arr;
            //返回原数组，数组末尾添加元素完成
            return elements;
    }



    /**
     * 删除头部第一个元素
     * @return
     */
    public int[] deleteHead(){
        //判断删除的元素是否为空数组
        if(elements.length<=0){
            throw new RuntimeException("这是一个空数组");
        }
        //创建一个新的数组，数组长度是原数组的长度+1
        int [] arr=new int[elements.length-1];

        if(elements.length == 1){
            //新数组赋值给原数组
            elements=arr;
        //返回原数组，数组末尾添加元素完成
        return elements;
        }else{
            //遍历新数组，将原数组的值通过下标一一赋值给新数组，
        for(int i=0;i<arr.length;i++){
            arr[i]=elements[i+1];
        }
        //新数组赋值给原数组
            elements=arr;
        //返回原数组，数组末尾添加元素完成
        return elements;
        }
    }




    /**
     * 删除末尾的一个元素
     * @return
     */
    public int[] deleteEnd(){
        //判断删除的元素是否为空数组
        if(elements.length<=0){
            throw new RuntimeException("这是一个空数组");
        }
        //创建一个新的数组，数组长度是原数组的长度+1
        int [] arr=new int[elements.length-1];
        if(elements.length == 1){
            //新数组赋值给原数组
            elements=arr;
        //返回原数组，数组末尾添加元素完成
        return elements;}else{
        //遍历新数组，将原数组的值通过下标一一赋值给新数组，
        for(int i=0;i<arr.length;i++){
            arr[i]=elements[i];
        }
        //新数组赋值给原数组
            elements=arr;
        //返回原数组，数组末尾添加元素完成
        return elements;
    }
    }

    /********         数组删除元素END       **************/





    /********         数组修改元素       **************/

    /**
     * 修改数组任意位置元素
     * @param element
     * @return
     */
    public int[] alter(int number,int element){
        //判断删除的元素是否为空数组
        if(elements.length<=0){
                    throw new RuntimeException("这是一个空数组");
        }
        if(number <0 || number >=elements.length){
            throw new RuntimeException("下标越界");
        }

        elements[number]=element;
        //返回原数组，数组末尾添加元素完成
        return elements;
    }



    /**
     * 修改头部第一个元素
     * @param element
     * @return
     */
    public int[] alterHead(int element){
        //判断删除的元素是否为空数组
        if(elements.length<=0){
                    throw new RuntimeException("这是一个空数组");
        }
        elements[0]=element;
        //返回原数组，数组末尾添加元素完成
        return elements;
    }


    /**
     * 修改尾部最后一个元素
     * @param element
     * @return
     */
    public int[] alterEnd(int element){
        //判断删除的元素是否为空数组
        if(elements.length<=0){
                    throw new RuntimeException("这是一个空数组");
        }
        elements[elements.length-1]=element;
        //返回原数组，数组末尾添加元素完成
        return elements;
    }

/********         数组修改元素END       **************/




    /********         数组查询元素     **************/
    /**
     * 查询数组头部第一个元素
     * @return
     */
    public int  inquireHead(){
        //判断删除的元素是否为空数组
        if(elements.length<=0){
                    throw new RuntimeException("这是一个空数组");
        }
        return elements[0];
    }


    /**
     * 查询数组尾部最后一个元素
     * @return
     */
    public int  inquireEnd(){
        //判断删除的元素是否为空数组
        if(elements.length<=0){
                    throw new RuntimeException("这是一个空数组");
        }
        return elements[elements.length-1];
    }



    /**
     * 查询数组任意位置元素
     * @param number
     * @return
     */
    public int  inquire(int number){
        //判断删除的元素是否为空数组
        if(elements.length<=0){
                    throw new RuntimeException("这是一个空数组");
        }

        if(number <0 || number >=elements.length){
            throw new RuntimeException("下标越界");
        }

        return elements[number];
    }

/********         数组查询元素END       **************/




    /********         查寻数组    **************/

    public String arrayFor(){
        String str="[";
        if(elements.length ==0){
            str+="]";
            return str;
        }
        for(int i=0;i<elements.length;i++){
            str+=elements[i];
            if(i!=elements.length-1){
                str+=",";
            }
        }

        str+="]";
        return str;
    }

    /********         查询数组END       **************/

    /********         查询数组长度       **************/

    public int arrayLength(){
        int l=0;
        if(elements.length ==0){
            return l;
        }

        for(int i=0;i<elements.length;i++){
            l=i;
        }
        return l+1;
    }

    /********         查询数组长度       **************/
}

数组对象类之测试类

package array;

public class ArrayTest {
    public static void main(String[] args) {
        ArrayUtil au=new ArrayUtil();

    /************添加元素测试*****************/
        //任意位置添加数据（空数组，位置只能是0了）
        au.add(0, 1);
        //数组头部添加一个元素
        au.addHead(0);
        //数组尾部添加一个元素
        au.addEnd(2);

                //任意位置添加数据
                au.add(3, 3);
                //数组头部添加一个元素
                au.addHead(-1);
                //数组尾部添加一个元素
                au.addEnd(4);

        //查看添加元素后的数组
        System.out.println("查看添加元素后的数组"+au.arrayFor());
        //查看数组长度
        System.out.println("查看添加元素后的数组的长度"+au.arrayLength());

        System.out.println("----------------------------");

        /***********添加元素测试END***************/


        /***********删除元素测试***************/
        //删除任意位置的一个元素
            au.delete(3);
            System.out.println("查看删除任意位置元素后的数组"+au.arrayFor());
        //删除头部元素
            au.deleteHead();
            System.out.println("查看删除头部位置元素后的数组"+au.arrayFor());
        //删除尾部元素
            au.deleteEnd();
            System.out.println("查看删除尾部位置元素后的数组"+au.arrayFor());
            //查看数组长度
            System.out.println("查看添加元素后的数组的长度"+au.arrayLength());
            System.out.println("----------------------------");


        /***********删除元素测试END***************/



            /***********修改元素测试***************/
            //修改任意位置的一个元素
                au.alter(1, 200);
                System.out.println("查看修改任意位置元素后的数组"+au.arrayFor());
            //修改头部元素
                au.alterHead(100);
                System.out.println("查看修改头部位置元素后的数组"+au.arrayFor());
            //修改尾部元素
                au.alterEnd(300);
                System.out.println("查看修改尾部位置元素后的数组"+au.arrayFor());
                //查看数组长度
                System.out.println("查看修改元素后的数组的长度"+au.arrayLength());
                System.out.println("----------------------------");


            /***********修改元素测试END***************/


                /***********查询元素测试***************/

                //查询任意位置的一个元素
                    System.out.println("查看任意位置1的元素"+au.inquire(1));
                //查询头部元素
                    System.out.println("查看头部位置元素"+au.inquireHead());
                //查询尾部元素
                    System.out.println("查看尾部位置元素"+au.inquireEnd());
                    //查看数组长度
                    System.out.println("查看数组的长度"+au.arrayLength());
                    System.out.println("----------------------------");


                /***********查询元素测试END***************/
    }
}
文章作者: 小蜗龟
文章链接: https://xiaowogui.top/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E4%B8%8E%E7%AE%97%E6%B3%95%E7%AC%94%E8%AE%B0(%E4%B8%80)3667.html
版权声明: 本博客所有文章除特別声明外，均采用 CC BY 4.0 许可协议。转载请注明来源 小蜗龟 !
数据结构
赏
评论
 上一篇
JAVA数据结构与算法基础学习笔记(三) JAVA数据结构与算法基础学习笔记(三)
排序算法时间复杂度和空间复杂度概述时间复杂度：空间复杂度：八种常用排序算法交换排序 冒泡排序 package demo4; import java.util.Arrays; public class BubbleSort{ p
2020-05-25 数据结构 算法
排序算法
下一篇 
JAVA笔试面试-时间 JAVA笔试面试-时间
1.获取时间（JDK8）// 获取日期 LocalDate localDate = LocalDate.now(); System.out.println(localDate); // 获取时间 LocalTime localTime =
2020-05-25 JAVA 笔试面试
笔试面试 JAVA
  目录