数组，链表，队列，栈的基本使用

一.数组

1.数组的定义

在连续的内存空间中，存储一组相同类型的元素。

1.1区分元素和索引

1.2区分数组访问和数组搜索

• 数组的访问是通过索引取得某一个元素的，而数组的搜索是直接去找这个元素，跟索引没有关系。

2.数组的基本使用

使用	复杂度
访问(access)	O(1)
搜索(search)	O(N)
插入(insert)	O(N)
删除(delete)	O(N)

3.数组的常用操作

3.1创建数组(4种方式)

        //方式1
        int[] a = {1, 2, 3};
        System.out.println("a:"+ Arrays.toString(a));
        //方式2
        int[] b = new int[]{1, 2, 3};
        System.out.println("b:"+ Arrays.toString(b));
        //方式3
        int[] c = new int[3];
        for (int i = 0; i <c.length ; i++) {
            c[i] = i + 1;
        }
        System.out.println("c:"+ Arrays.toString(c));
        //方式4
        ArrayList<Integer> arr = new ArrayList<Integer>();
        for (int i = 0; i < 3; i++) {
            arr.add(i+1);
        }
        System.out.println("arr:"+ arr.toString());

3.2添加数组

• 复杂度最多是O(n),最少是O(1)

		arr.add(99);
        System.out.println("arr:"+ arr.toString());
        arr.add(3,88);
        System.out.println("arr:"+ arr.toString());

3.3访问元素

• 通过下标(索引)访问,复杂度是O(1)

		int c1 = c[1];
        int arr1 = arr.get(1);
        System.out.println("c1:"+ c1);
        System.out.println("arr1:"+ arr1);

3.4更新元素

• 复杂度O(1)

		c[1] = 11;
        arr.set(1, 11);//第一个是索引位置，第二个是要改变的的值
        System.out.println("c1:"+ c1);
        System.out.println("arr1:"+ arr1);

3.5删除元素

• 复杂度O(n)

		arr.remove(3);
        System.out.println("arr1:"+ arr.get(1));

3.6获取数组长度

• 复杂度O(n)

		int cSize = c.length;
        int arrSize = arr.size();
        System.out.println("c length:"+ cSize);
        System.out.println("arr length:"+ arrSize);

3.7遍历数组

• 复杂度O(n)

		for (int i = 0; i < c.length; i++) {
            int current = c[i];
            System.out.println("下标为" + i + "的元素为" + "current");
        }
        for (int i = 0; i < arr.size(); i++) {
            int current = arr.get(i);
            System.out.println("下标为" + i + "的元素为" + "current");
        }

3.8查找某个元素

• 复杂度O(n)

		 for (int i = 0; i < c.length; i++) {
            if(c[i] == 99){
                System.out.println("元素99的下标为" + i);
            }
        }
        boolean find= arr.contains(99);
        System.out.println("元素99是否存在：" + find);

3.9数组排序

        c = new int[]{2, 3, 1};
        arr = new ArrayList<>();
        arr.add(2);
        arr.add(3);
        arr.add(1);
        System.out.println("c:"+ Arrays.toString(c));
        System.out.println("arr:"+ arr.toString());
        Arrays.sort(c);
        System.out.println("c:"+ Arrays.toString(c));
        Collections.sort(arr);
        System.out.println("arr:" + arr);
        Collections.sort(arr, Collections.reverseOrder());
        System.out.println("arr:" + arr);

二.链表

1.链表的定义

• 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。
• 

2.链表的常用操作

2.1创建链表

    LinkedList<Integer> list = new LinkedList<>();

2.2添加元素

		//添加元素
        //复杂度O(1)
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        System.out.println(list.toString());
        //复杂度O(n)
        list.add(2, 99);
        System.out.println(list.toString());

2.3访问元素

        //访问元素,复杂度O(n)
        int element = list.get(2);
        System.out.println(element);

2.4搜索元素

        //搜索元素,复杂度O(n)
        int index = list.indexOf(99);
        System.out.println(index);

2.5更新元素

        //更新元素,复杂度O(n)
        list.set(2, 88);
        System.out.println(list.toString());

2.6删除元素

 		//删除元素,复杂度O(n)
        list.remove(2);
        System.out.println(list.toString());

2.7链表的长度

        //长度,复杂度O(1)
        int length = list.size();
        System.out.println(length);

三.队列(queue)

• 队列的特点是先进先出
  单端队列：只有一个口可以进，一个口可以出双向队列：两个口都可以进，两个口可以出

1.队列的常用操作

1.1创建队列

		//创建队列
        Queue<Integer> queue = new LinkedList<>();

1.2添加元素

• Q.add():增加一个元素
• Q.offer():添加一个元素并返回true,如果队列已满，则返回false
• Q.put():添加加一个元素
• Q.element():返回队列头部的元素

        //添加队列,复杂度O(1)
        queue.add(1);
        queue.add(2);
        queue.add(3);
        queue.add(4);
        System.out.println(queue.toString());

1.3获取即将出队的元素

• Q.peek():返回队列头部的元素;如果队列为空,则返回null

        //获取即将出队的元素,复杂度O(1)
        int temp = queue.peek();
        System.out.println(temp);

1.4删除即将出队的元素

• Q.poll():移除并返问队列头部的元素
• Q.remove():移除并返回队列头部的元素
• Q.take():移除并返回队列头部的元素

		//删除即将出队的元素,复杂度O(1)
        int temp01 = queue.poll();
        System.out.println(temp01);
        System.out.println(queue.toString());

1.5判断队列是否为空

        //判断队列是否为空,复杂度O(1)
        System.out.println(queue.isEmpty());

1.6队列长度

		//队列长度,复杂度O(1)
        System.out.println(queue.size());      

1.7遍历队列(边删除边遍历队列操作)

		//遍历队列,复杂度O(n)
		 while (!queue.isEmpty()){
            int temp03 = queue.poll();
            System.out.println(temp03);
        }

四.栈(stack)

• 栈的特点：先进后出

1.栈的定义

• 栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。
  

2.数组的基本使用

使用	复杂度
访问(access)	O(1)栈顶元素
搜索(search)	O(N)
插入(insert)	O(1)
删除(delete)	O(1)栈顶元素

3.栈的常用操作

3.1创建栈

		//创建栈
        Stack<Integer> stack = new Stack<>();

3.2添加元素

        //添加元素,复杂度O(1)
        stack.push(1);
        stack.push(2);
        stack.push(3);
        stack.push(4);
        System.out.println(stack.toString());

3.3查看栈顶元素–即将删除的元素

        //获取栈顶元素,复杂度O(1)
        stack.peek();

3.4删除栈顶元素–即将删除的元素

        //删除栈顶元素,复杂度O(1)
        int temp1 = stack.pop();
        System.out.println(temp1);

3.5栈的长度

        //栈的大小,复杂度O(1)
        stack.size();

3.6栈是否为空

        //栈是否为空,复杂度O(1)
        stack.isEmpty();

3.7遍历栈

        //栈的遍历,复杂度O(n)
        while(!stack.isEmpty()){
            int num = stack.pop();
            System.out.println(num);
        }