数据结构-数组

一、数据结构
1、是一门基础学科
2、研究的是数据如何在计算机中进行组织和存储，使得我们可以高效的获取数据和修改数据

3、数据结构可以分为三类：
线性结构：数组、队列、栈、链表、哈希表…
树形结构：二叉树、二分搜索树、AVL树、红黑树、堆、Trie、线段树、并查集…
图结构：邻接矩阵、邻接表

数据结构 + 算法 = 程序

二、数组
1.数组的概念：用来存储一组相同数据类型的数
2、java中数组的定义 数据类型[] 数组名
3.初始化 数据类型[] 数组名 =new int[6];
数据类型[] 数组名 ={1,2,3,4};
4.数组在内存中分配的是连续的空间

package com.company.supplment;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

public class AddClass {
    public static void main(String[] args) {
        int[] arr = {1, 3, 2, 4, 5};
        // Arrays.stream(arr).forEach(item-> System.out.println(item));  //遍历

        //每个元素加10，过滤奇数
       // Arrays.stream(arr).map(item -> +10).filter(item -> item % 2 > 0).forEach(System.out::println);

  /*      String[] fruits = {"apple", "watrmelon", "orange"};
        Arrays.stream(fruits).forEach(item -> System.out.println(item));*/


      /*  int[] nums = new int[1000];
        Random random = new Random();
        for (int i = 0; i < 1000; i++) {
            nums[i] = random.nextInt(100000);
        }
        Arrays.stream(nums).map(item -> item + 10).filter(item -> item % 2 > 0).forEach(System.out::println);
*/

        String num = "asdcbfhasdsb";

        int [] counts= new int[26];
        for (int i = 0; i <num.length() ; i++) {
            char ss=num.charAt(i);
            counts[ss-'a']++;
            System.out.println(ss);
        }


    /*    Map<Character, Integer> map = new HashMap<>();
        for (int i = 0; i < num.length(); i++) {
            char s = num.charAt(i);
            if (!map.containsKey(s)) {
                map.put(s, 1);

            } else {
                map.put(s, map.get(s) + 1);
            }

        }
        System.out.println(map);*/
    }
}

package com.company.project;

public class MyselfArray<T>{
    private  int size;
    private T[] data;

    //容量 capcity
    MyselfArray(){
        this(20);
    }
    MyselfArray(int capcity){
        this.size=0;
        data= (T[]) new Object[capcity];
    }
        //数组长度
    public int datacapcity(int capcity){
        return data.length;
    }

    /**
     * 判断数组是否为空
     * @return
     */
    public boolean isEmpty(){
        return this.size==0;
    }

    /**
     * 向数组的尾添加元素
     * @return ele元素内容
     * @param ele
     */

    public void addTail(T ele){
        if (this.size > data.length) {
            throw  new IllegalArgumentException("index out of arrayRange");
        }
        data[this.size] = ele;
            size++;
    }
    public void addHead(T ele) {
      add(0,ele);
    }
    /**
     * 在指定位置添加元素    扩容
     *      index 索引
     * @param ele   元素内容
     *IllegalArgumentException  //非法数据异常
     *              //size-1 索引 相当于插入排序   从后往前遍历
     *              i>=index  i遍历的位置要大于所插入位置的索引，前面就不需要遍历了
     */

        public  void add(int index,T ele){
            //判断数组是否已满
        if (this.size==data.length) {
            throw new IllegalArgumentException("this array is full");

        }
        if(index<0||index>this.size){
            throw  new IllegalArgumentException("index is error");
        }
            for (int i = size-1; i >=index; i--) {
                data[i+1]=data[i];
            }
            data[index]=ele;
            this.size++;
    }

    /**
     * 扩容
     * @param copacity
     */
    public  void resize(int copacity){
        T[] newData = (T[]) new Object[2*data.length];
        for (int i = 0; i <this.size ; i++) {
            newData[i]=data[i];
        }
        this.data=newData;
    }

    /**
     *   获取指定位置的元素
     * @param index 索引
     * @return int
     */
    public  T getbyIndex(int index){
        if(index<0||index>this.size){
            throw  new IllegalArgumentException("index is error");
        }
        return data[index];
    }

    //获取最后一个位置的元素
    public  T getlastElement(){
        return getbyIndex(this.size-1);
    }

    //获取首位元素
    public  T getfirtElement(){
        return getbyIndex(0);
    }
    /**
     * 修改指定位置的元素
     * @param index
     * @param ele
     */
    public void updatebyIndex(int index,T ele){
        if(index<0||index>this.size){
            throw  new IllegalArgumentException("index is error");
        }
        data[index]=ele;
    }

    /**
     * 是否包含指定元素的内容
     * @param ele
     * @return
     */
    public int isContains(T ele){
        for (int i = 0; i < this.size; i++) {
            if(this.data[i].equals(ele)){
                return 1;
            }
        }
        return -1;
    }

    /**
     * 删除指定位置的元素    减少容量 缩容
     * @param index
     * @return
     */
    public  T  remveIndex(int index){
        if(index<0||index>this.size){
           throw  new IllegalArgumentException("index is error");

        }
        T result =data[index];
        for (int i = index+1 ;i <size ; i++) {
            data[i-1]=data[i];
        }
        this.size--;
        data[size]=null;

        //缩容
        if(this.size==data.length/2&&data.length>0){
            resize(data.length/2);
        }

        return result;

    }

    public  T removeHead(){
        return remveIndex(0);
    }

    public  T removeTail(){
        return remveIndex(this.size-1);
    }

    /**
     * 删除指定的元素
     * @param ele
     * @return
     */
    public int removeele(T ele){
        int index=isContains(ele);
    if(index==-1){
        return -1;
    }
    return index;
    }

    /**
     * 搜索元素
     * @return
     */
    @Override
    public String toString() {
        StringBuffer sb=new StringBuffer();
        sb.append("[");
        for (int i = 0; i < this.size; i++) {
            sb.append(data[i].toString());
            if(i!=this.size-1){
                sb.append(",");
            }
        }
        sb.append("]");
        return sb.toString();
    }


    public int getSize() {
        return size;
    }

    public void setSize(int size) {
        this.size = size;
    }

    public T[] getData() {
        return data;
    }

    public void setData(T[] data) {
        this.data = data;
    }

    public static void main(String[] args) {
    MyselfArray myArray=new MyselfArray(10);
    //进行添加元素
       // Random random =new Random();
        for (int i = 0; i <10 ; i++) {
        myArray.addTail(i);
        }
        System.out.println("数组："+myArray);

        System.out.println(myArray.remveIndex(2));
        System.out.println("数组："+myArray);

        //判断1是否在数组中
        System.out.println(myArray.isContains(1)==-1? false :true);

    }
}

二维数组转稀疏数组

package database;

import java.util.Arrays;

public class spararr {
    public static void main(String[] args) {
        //创建二维数组
        System.out.println("二维数组");
        int  [][]chessArr=new int[11][11];
        chessArr[1][2]=1;
        chessArr[2][3]=2;
        for (int[]row:chessArr){
            for (int data :row){
                System.out.print("\t"+data);
            }
            System.out.println();
        }
   
        //遍历二维数组，得到非0数据
        int sum=0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (chessArr[i][j]!= 0){
                    sum++;
                }
            }
        }
        System.out.println("sum="+sum);
        //创建稀疏数组
        int [][]sparseArr =new int[sum+1][3];
        sparseArr[0][0]=11;
        sparseArr[0][1]=11;
        sparseArr[0][2]=sum;
        //遍历二维数组，取出不为0的数
        int count=0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (chessArr[i][j]!=0){
                    count++;
                    sparseArr[count][0]=i;
                    sparseArr[count][1]=j;
                    sparseArr[count][2]=chessArr[i][j];
                    
                }
            }
        }

        System.out.println("稀疏数组");
        for (int i = 0; i <sparseArr.length ; i++) {
            System.out.printf("%d\t%d\t%d\t\n",sparseArr[i][0],sparseArr[i][1],sparseArr[i][2]);
        }
        System.out.println();
    }
}

稀疏数组转二维数组

    //1、读取稀疏数组第一行，创建原始二维数组
        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 []row:chessArr2){
            for (int data :row){
                System.out.print("\t"+data);
            }
            System.out.println();
        }