使用Java函数实现数据结构的创建和操作

Java是一种面向对象编程语言，其具有简单、易学、安全、强大、高效等特点。Java语言中支持各种数据结构的创建和操作，如数组、链表、栈、队列、堆等。在Java中，数据结构可以通过类实现，类可以拥有属性和方法。本文将介绍如何使用Java函数实现数据结构的创建和操作。

1. 数组

数组是一种线性数据结构，它由一组相同类型的元素组成，并按照一定的顺序排列。Java中的数组可以通过以下方式创建：

int[] arr = new int[10]; // 创建长度为10的整型数组
double[] arr2 = {1.2, 2.5, 3.7, 4.1}; // 创建长度为4的双精度型数组，并初始化

对于数组的操作，包括访问、修改、遍历等。下面是一个使用Java函数实现对数组的操作的例子：

public class ArrayDemo{
  public static void main(String[] args){
    int[] arr = new int[5];
    for(int i=0;i<arr.length;i++){
        arr[i] = i+1;
    }
    System.out.println("数组元素为：");
    for(int i=0;i<arr.length;i++){
        System.out.print(arr[i]+" ");
    }
    System.out.println();
  }
}

2. 链表

链表是一种动态数据结构，它由节点组成，每个节点包含数据和指向下一个节点的指针。Java中的链表可以通过类实现。下面是一个简单的链表实现：

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

class LinkedList{
    Node head;
    
    public LinkedList(){
        this.head = null;
    }
    
    public void add(int val){
        Node node = new Node(val);
        if(head == null){
            head = node;
        }else{
            Node cur = head;
            while(cur.next != null){
                cur = cur.next;
            }
            cur.next = node;
        }
    }
    
    public void print(){
        Node cur = head;
        while(cur != null){
            System.out.print(cur.val+" ");
            cur = cur.next;
        }
        System.out.println();
    }
}

public class LinkedListDemo{
    public static void main(String[] args){
        LinkedList list = new LinkedList();
        list.add(2);
        list.add(1);
        list.add(4);
        list.add(3);
        list.print();
    }
}

3. 栈

栈是一种先进后出（Last in First Out, LIFO）的数据结构，它类似于一个箱子，只有最上面的物品可以取出来，后面的物品只能等最上面的物品被取完才能取出来。Java中的栈可以通过类实现。下面是一个简单的栈实现：

class Stack{
    int top;
    int[] arr;
    public Stack(int size){
        arr = new int[size];
        top = -1;
    }
    
    public void push(int val){
        if(top == arr.length-1){
            System.out.println("栈已满");
        }else{
            arr[++top] = val;
        }
    }
    
    public int pop(){
        if(top == -1){
            System.out.println("栈为空");
            return -1;
        }else{
            int val = arr[top--];
            return val;
        }
    }
    
    public void print(){
        System.out.println("栈元素为：");
        for(int i=top;i>=0;i--){
            System.out.print(arr[i]+" ");
        }
        System.out.println();
    }
}

public class StackDemo{
    public static void main(String[] args){
        Stack stack = new Stack(5);
        stack.push(1);
        stack.push(2);
        stack.push(3);
        stack.push(4);
        stack.push(5);
        stack.print();
        stack.pop();
        stack.print();
    }
}

4. 队列

队列是一种先进先出（First in First Out, FIFO）的数据结构，类似于一条队伍，新来的人排在队尾，先来的人排在队头。Java中的队列可以通过类实现。下面是一个简单的队列实现：

class Queue{
    int front, rear, size;
    int[] arr;
    public Queue(int size){
        this.front = 0;
        this.rear = -1;
        this.size = size;
        arr = new int[size];
    }
    
    public void enqueue(int val){
        if(rear == size-1){
            System.out.println("队列已满");
        }else{
            arr[++rear] = val;
        }
    }
    
    public int dequeue(){
        if(front > rear){
            System.out.println("队列为空");
            return -1;
        }else{
            int val = arr[front++];
            return val;
        }
    }
    
    public void print(){
        System.out.println("队列元素为：");
        for(int i=front;i<=rear;i++){
            System.out.print(arr[i]+" ");
        }
        System.out.println();
    }
}

public class QueueDemo{
    public static void main(String[] args){
        Queue queue = new Queue(5);
        queue.enqueue(1);
        queue.enqueue(2);
        queue.enqueue(3);
        queue.enqueue(4);
        queue.enqueue(5);
        queue.print();
        queue.dequeue();
        queue.print();
    }
}

5. 堆

堆是一种可以快速找到最大值或最小值的数据结构，常用于排序等算法。Java中的堆可以通过类实现。下面是一个简单的最小堆实现：

class Heap{
    int size;
    int[] arr;
    public Heap(int size){
        this.size = 0;
        this.arr = new int[size];
    }
    
    public void insert(int val){
        if(size == arr.length){
            System.out.println("堆已满");
        }else{
            arr[size++] = val;
            int current = size-1;
            int parent = (current-1)/2;
            while(current > 0 && arr[parent] > arr[current]){
                swap(current, parent);
                current = parent;
                parent = (current-1)/2;
            }
        }
    }
    
    public int delete(){
        if(size == 0){
            System.out.println("堆为空");
            return -1;
        }else{
            int val = arr[0];
            arr[0] = arr[--size];
            heapify(0);
            return val;
        }
    }
    
    public void heapify(int index){
        int left = 2*index+1;
        int right = 2*index+2;
        int smallest = index;
        if(left < size && arr[left] < arr[smallest]){
            smallest = left;
        }
        if(right < size && arr[right] < arr[smallest]){
            smallest = right;
        }
        if(smallest != index){
            swap(smallest, index);
            heapify(smallest);
        }
    }
    
    public void swap(int i, int j){
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
    
    public void print(){
        System.out.println("堆元素为：");
        for(int i=0;i<size;i++){
            System.out.print(arr[i]+" ");
        }
        System.out.println();
    }
}

public class HeapDemo{
    public static void main(String[] args){
        Heap heap = new Heap(5);
        heap.insert(4);
        heap.insert(1);
        heap.insert(3);
        heap.insert(2);
        heap.insert(5);
        heap.print();
        heap.delete();
        heap.print();
    }
}

总结

本文介绍了如何使用Java函数实现数组、链表、栈、队列、堆等数据结构的创建和操作。Java的面向对象特性可以使得数据结构的设计更加清晰、易于维护和扩展。通过不断学习和实践，我们可以更好地掌握Java的数据结构及其实现。