1.冒泡排序

    public static int[] bubbleSort(int[] arr1){
        for (int i = 0; i < arr1.length - 1; i++) {
            for (int j = 0; j < arr1.length - 1 - i; j++) {
                if(arr1[j]>arr1[j+1]){
                    int temp = arr1[j];
                    arr1[j] = arr1[j + 1];
                    arr1[j + 1] = temp;
                }
            }
        }
        return arr1;
    }

2.二分查找

    //二分查找，查找的集合必须是有序的
    public static int binarySearch(int[] arr2,int ta){
        int first =0;
        int last=arr2.length-1;
        while (first <= last) {
            int m = (first + last)/2;
            if (ta == arr2[m]) {
                return m;
            } else if (ta > arr2[m]) {
                first=m+1;
            }else {
                last=m-1;
            }
        }
        return -1;
    }

3.递归

    //递归，方法直接或者间接的调用自己本身则称为递归，要有终止条件
    public static int recursion(int[] arr2,int ta,int frist,int last){
        int m=(frist+last)/2;
        if (ta < arr2[frist] || ta > arr2[last] || frist > last) {
            return -1;
        }
        if (arr2[m] == ta) {
            return m;
        } else if (ta > arr2[m]) {
            return recursion(arr2, ta, m+1, last);
        }else{
            return recursion(arr2, ta, frist, m - 1);
        }
    }

4.单链表反转-迭代解法

1. 单链表结构

   public class Node {
       private Object data;
       private Node next;
   
       public Node(Object data) {
           this.data = data;
       }
   
       public Node(Object data, Node next) {
           this.data = data;
           this.next = next;
       }
   
       public Object getData() {
           return data;
       }
   
       public void setData(Object data) {
           this.data = data;
       }
   
       public Node getNext() {
           return next;
       }
   
       public void setNext(Node next) {
           this.next = next;
       }
   }
   

2. 单链表创建

   public class algorithm {
       public static void main(String[] args) {
           //【单链表反转】：
           //自己写一个Node类
           //1.创建一个单链表,原链表11,22,33,44
           Node lastNode=new Node(44);
           Node node3=new Node(33,lastNode);
           Node node2=new Node(22,node3);
           Node headNode=new Node(11,node2);
           System.out.print("反转之前的链表：");
           print(headNode);
           System.out.print("反转之后的链表：");
           Node reverse = reverseLinkedList(headNode);
           print(reverse);
       }
   }

3. 单链表遍历

       //单链表，遍历
       public static void print(Node headNode){
           while (headNode != null) {
               System.out.print(headNode.getData()+",");
               headNode=headNode.getNext();
           }
           System.out.println();
       }

4. 单链表反转

       //单链表，反转
       public static Node reverseLinkedList(Node headNode){
           if (headNode == null || headNode.getNext() == null) {
               return headNode;
           }
           Node prev=null;
           while (headNode != null) {
               Node nextNode=headNode.getNext();
               headNode.setNext(prev);
               prev=headNode;
               headNode=nextNode;
           }
           return prev;
       }

5.插入排序

    public static int[] insertSort(int[] arr1){
        int temp;
        for (int i = 1; i < arr1.length; i++) {
            for (int j = i; j > 0; j--) {
                if (arr1[j - 1] > arr1[j]) {
                    temp = arr1[j-1];
                    arr1[j - 1] = arr1[j];
                    arr1[j]=temp;
                }
            }
        }
        return arr1;
    }

6.选择排序

    public static int[] selectSort(int[] arr1){
        for (int i = 0; i < arr1.length; i++) {
            int min=i;
            for (int j = i+1; j < arr1.length; j++) {
                if(arr1[j]<arr1[min]){
                    min=j;
                }
            }
            if (i != min) {
                int temp = arr1[min];
                arr1[min]=arr1[i];
                arr1[i]=temp;
            }
        }
        return arr1;
    }