标签：顺序存储   面向   log   存储   存储结构   条件   object   五个   print   

数据结构与算法(一)

1.1数据结构概述

什么是数据结构？

数据的存储结构

• 顺序存储结构，类似排队打饭

• 链式存储结构，类似取号打饭

• 两种方式的区别：顺序存储影响插入后的所有元素，而链式存储影响范围更小

• 数据的逻辑结构
  • 集合，维恩图
  • 线性，列表
  • 树形，一对多
  • 图形，多对多的关系

1.2算法概述

即解决问题的思路

特性

1. 输入
2. 输出
3. 有穷性
4. 确定性
5. 可行性

要求

• 正确性
• 可读性
• 健壮性
• 时间复杂度
• 空间复杂度

从1加到100

package demo1;

public class AddOneToHandred {

    public static void main(String[] args) {
        int total=0;
        int end=100;
        //使用for循环计算
        for(int i=1;i<=end;i++) {
            total+=i;
        }
        
        //直接计算
        total=(1+end)*end/2;
        //算法没有最好的，只有最适合的。
        
        //打印结果
        System.out.println(total);
    }
    
}

2.1数组的基本使用

package my;

public class UseArray {


    public static void main(String[] args) {
        //创建一个数组
        int[] array = new int[3];


        //获取数组长度
        System.out.println(array.length);
        System.out.println("---------------------------------------------------------------------");

        //访问数组中的元素：数组名[下标]
        System.out.println(array[0]);
        System.out.println("---------------------------------------------------------------------");

        //为数组的元素赋值
        array[0]=1;
        array[1]=14;
        array[2]=51;
        //遍历数组
        for (int i =0 ; i < array.length; i++) {
            System.out.println(array[i]);
        }
        System.out.println("---------------------------------------------------------------------");
        //创建数组的同时为数组中的元素赋值
        int[] int2 = {1, 3, 556, 77, 76, 45, 5, 6};
        for (int i =0 ; i < int2.length; i++) {
            System.out.println(int2[i]);
        }
    }
}

2.2数组元素的添加

package my;

import java.util.Arrays;
//为数组添加元素

public class InsertOpArray {
    public static void main(String[] args) {
        //解决数组的长度不可变
        int[] array = {1, 4, 7, 8};
        System.out.println("原数组为"+Arrays.toString(array));
        //往数组中插入一个数
        int num=99;
        //创建一个新的数组，长度为原来的数组的长度加一
        int[] newArray = new int[array.length + 1];
        //把原来的数组的元素全部的赋值到新数组中
        for (int i = 0; i <array.length; i++) {
            newArray[i]=array[i];
        }
        //将需要添加的元素加入新数组的最后
        newArray[array.length]=num;
        //原数组引用新数组
        array=newArray;
        System.out.println("新数组为"+Arrays.toString(array));


    }
}

2.3数组元素的删除

package my;

import java.util.Arrays;

public class DeleteArray {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        //int[] arr = {1, 2, 3, 4, 6, 7, 8, 9, 10};

        System.out.println("原数组为"+Arrays.toString(arr));
        //删除数组中的某一个元素：该元素前面的数不变，其余的数下标左移一位
        //首先创建一个长度-1的新数组
        int[] newArr = new int[arr.length - 1];
        //要删除的元素下标,这里删除第五个元素
        int index=4;
        for (int i = 0; i < index; i++) {
            newArr[i]=arr[i];
        }
        for (int i = index; i < newArr.length; i++) {
            newArr[i]=arr[i+1];
        }
        arr=newArr;
        System.out.println("新数组为"+Arrays.toString(arr));




    }
}

2.4面向对象的数组

package my;

import java.util.Arrays;

public class ObjectArray {
    private int[] elements;


    public ObjectArray() {
        this.elements = new int[0];
    }

    //获取数组长度的方法
    public int getSize(){
        return elements.length;
    }

    //往数组的末尾添加一个元素,参数为需要添加的数
    public void add(int element){
        //创建一个数组长度加一的新数组
        int[] newArr = new int[elements.length + 1];

        //赋值，并将最后的元素追加进数组里面
        for (int i=0;i<elements.length;i++){
            newArr[i]=elements[i];
        }
        newArr[elements.length]=element;
        //数组引用
        elements=newArr;
    }

    //在数组中删除某一个下标的元素
    public void delete(int index){
        //创建一个数组长度减一的新数组
        int[] newArr = new int[elements.length - 1];
        //根据下标判断，进行区别赋值
        for(int i=0;i<newArr.length;i++){
            if(i<index){
                newArr[i]=elements[i];
            }else{
                newArr[i]=elements[i+1];
            }
        }
        elements=newArr;

        //数组引用
    }

    //根据下标插入元素到数组里面
    public void insert(int index,int element){
        //创建一个新的数组，长度为原来的长度加一
        int[] newArr = new int[elements.length + 1];
        for(int i=0;i<elements.length;i++){//曾出错：条件写错成i<newArr.length导致数组越界
            if(i<index){
                newArr[i]=elements[i];
            }
            else{
                newArr[i+1]=elements[i];//这里出错：数组越界，错在上面
            }
        }
        newArr[index]=element;
        elements=newArr;
    }

//    替换指定位置上的元素
    public void set(int index,int element){
        elements[index] = element;
    }


    //打印数组元素到控制台
    public void show(){
        System.out.println("数组为"+Arrays.toString(elements));
    }

    public void line(){
        System.out.println("==========================================================================");
    }
}

package my;

import java.util.Arrays;

public class TestObjectArray {
    public static void main(String[] args) {
        //创建一个可变数组
        ObjectArray array = new ObjectArray();
        //获取长度
        int size = array.getSize();
        System.out.println("数组的长度为"+size);
        array.show();
        array.line();
        //往可变数组中添加一个元素
        array.add(99);
        System.out.println("添加一个元素后的数组长度为"+array.getSize());
        array.show();
        array.line();
        //添加元素
        array.add(1);
        array.add(21);
        array.add(31);
        array.add(51);
        array.add(61);
        array.add(71);
        array.show();
        array.line();
        System.out.println("删除下标为3的元素后");
        array.delete(3);
        array.show();
        array.line();
        //插入下标为3的值
        array.insert(3,100);
        array.show();
        array.line();
        //替换下标为2的元素
        array.set(2,998);
        array.show();


    }
}

数据结构与算法(一)

标签：顺序存储   面向   log   存储   存储结构   条件   object   五个   print   

原文地址：https://www.cnblogs.com/senup/p/12305920.html