常见数据结构

38 阅读5分钟

1. 数组 (Array)

一组连续的内存空间,用于存储相同类型的数据。

1.创建数组

int[] myArray = new int[5];

2.Arrays.toString()

用于将数组转换为字符串,可以快速的输出数组的内容

int[] arr = {1, 2, 3};
System.out.println(Arrays.toString(arr)); 

3.Arrays.sort()

给数组排序,默认是升序的

int[] arr = {5, 2, 3, 1, 4};
Arrays.sort(arr); 

4.Arrays.equals()

比较数组内容是否相等,如果相等返回true,否则返回false

int[] arr1 = {1, 2, 3};
int[] arr2 = {1, 2, 3};
boolean isEqual = Arrays.equals(arr1, arr2);

5.Arrays.copyOf()

复制指定数组,当中的第一个参数是复制的原数组,第二个参数是复制的长度

int[] arr1 = {1, 2, 3};
int[] arr2 = Arrays.copyOf(arr1, 5);

6.Arrays.copyOfRange()

是上个方法的改进版,上面这个方法只能从下标为0的地方开始完成对数组的复制,但是这个方法里可以指定起始位置和结束位置

int[] arr1 = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int[] arr2 = new int[5];
arr2 = Arrays.copyOfRange(arr1,3,5);

2. 链表(Linked List)

由节点组成的数据结构,每个节点包含数据和指向下一个节点的指针

1.创建链表

public class Node {
    int data;
    Node next;
    
    public Node(int data) {
        this.data = data;
        this.next = null;
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建头节点
        Node head = new Node(0);
        
        // 创建其他节点
        Node node1 = new Node(10);
        head.next = node1;
        
        Node node2 = new Node(20);
        node1.next = node2;
        
        Node node3 = new Node(30);
        node2.next = node3;
        
        // 遍历链表并打印节点数据
        Node current = head.next;
        while (current != null) {
            System.out.print(current.data + " ");
            current = current.next;
        }
    }
}

2. addFirst

头插

    public void addFirst(int value) {
        Node node = new Node(value);
        node.next = head;
        head = node;
    }

3.addLast

尾插

public void addLast(int value) {
        Node node = new Node(value);
        // 链表为空的情况
        if (head == null) {
            head = node;
            return;
        }
        Node cur = head;
        // 找到最后一个结点的位置
        while (cur.next != null) {
            cur = cur.next;
        }
        cur.next = node;
    }

4.addIndex

在任意位置插入

   public void checkIndex(int index) {
        if (index < 0 || index > size()) {
        // size()方法获取链表长度,遍历链表即可,比较简单,不多赘述
            throw new LinkListIndexOutOfException("这个位置不合法");
            // 异常处理
        }
    }

5.contains

   public boolean contain(int key) {
        Node cur = head;
        while (cur != null) {
            if (cur.value == key) {
                return true;
            }
            cur = cur.next;
        }
        return false;
    }

6. remove

 public void remove(int key) {
        // 如果链表为空
        if (head == null) {
            return;
        }
        // 如果头结点就是key
        if (head.value == key) {
            head = head.next;
            return;
        }
        // 首先要找到key的前一个结点
        Node prevKey = findPrevKey(key);
        if (prevKey == null) {
            return;
        }
        // 重新链接
        Node del = prevKey.next;
        prevKey.next = del.next;
    }

删除第一次出现关键字为key的结点 判定是否包含某个元素

3. 栈(Stack)

一种后进先出(LIFO)的数据结构,只能在栈顶进行插入和删除操作。

1.创建栈

 Stack<Character> stack = new Stack<Character>();

2.push

是指将一个元素压入栈中。在栈数据结构中,新元素被压入栈的顶部,成为新的栈顶元素。 例如,如果要将整数 5 压入栈中,可以使用

stack.push(5)

3.pop

是指从栈中移除并返回栈顶元素,可以将栈顶元素移除,并返回该元素的值

stack.pop()

4.peek

是查看栈顶元素。在栈数据结构中,栈顶元素是最后一个被压入栈的元素,也是第一个被弹出栈的元素。可以获取栈顶元素的值,但不会将其从栈中弹出。

stack.peek()

4. 队列(Queue)

一种先进先出(FIFO)的数据结构,只能在队列的一端进行插入操作,另一端进行删除操作

1.创建队列

Queue<String> queue = new LinkedList<>()

2.方法

add(E element):将指定元素添加到队列末尾,如果队列满了则抛出异常。

offer(E element):将指定元素添加到队列末尾,如果队列满了则返回false

remove():移除并返回队列头部元素,如果队列为空则抛出异常。

po11():移除并返回队列头部元素,如果队列为空则返回 nu11。

element():返回队列头部元素,但不移除它,如果队列为空则抛出异常

peek():返回队列头部元素,但不移除它,如果队列为空则返回nul1。

5. 哈希表(HashMap)

利用哈希函数将键映射到值的数据结构,用于快速查找和插入数据。

1.创建哈希表

Map<Character, Character> hashmap = new HashMap<Character, Character>();

2.方法

添加键值对:使用put(key, value)方法将键值对添加到HashMap中。

获取值:使用get(key)方法获取指定键对应的值。

删除键值对:使用remove(key)方法从HashMap中删除指定的键值对。

判断键是否存在:使用containsKey(key)方法检查HashMap中是否包含指定的键。

判断值是否存在:使用containsValue(value)方法检查HashMap中是否包含指定的值。

获取键集合:使用keySet()方法获取HashMap中所有键的集合。

获取值集合:使用values()方法获取HashMap中所有值的集合。

获取键值对集合:使用entrySet()方法获取HashMap中所有键值对的集合。

获取HashMap大小:使用size()方法获取HashMap中键值对的数量

6. 列表(List)

List是集合体系中较为重要的接口,它具有单列存储的特点,即一次只能添加一个元素

1.创建列表

List<Integer> vals = new ArrayList<Integer>();

2.方法

添加元素:add()

获取元素:get()

删除元素:remove()

清空列表:clear()

判断列表是否为空:isEmpty()

获取列表大小:size()

替换元素:set()

查找元素位置:indexOf()

判断是否包含某元素:contains()

获取子列表:subList()

迭代列表元素:使用迭代器或for-each循环

7. Set

1.创建set

 Set<Integer> set=new HashSet<Integer>();

2.方法

添加元素: 使用add(element)方法将新元素添加到Set中。 删除元素: 使用remove(element)方法从Set中删除指定的元素。 使用clear()方法清空Set中的所有元素。 包含元素: 使用contains(element)方法检查Set中是否包含指定的元素。 遍历元素: 使用for-each循环或迭代器来遍历Set中的所有元素。 大小操作: 使用size()方法获取Set中元素的数量