java算法篇总结

1. 冒泡排序

   比较相邻元素，如果第一个比第二个大，那么交换他们的位置；每对相邻元素进行依次比较，最后的元素应该是最大的。

   int[] array = {10,13,12,8,11,6};
   
   //数组从小到大排序
   for (int i = 0; i < array.length - 1; i++) {
       for(int j = 0; j < array.length - i - 1;j ++){
           if (array[j] > array[j + 1]) {
               a = array[j];
               array[j] = array[j + 1];
               array[j + 1] = a;
           }
       }
   }
   System.out.println(Arrays.toString(array));//[6, 8, 10, 11, 12, 13]

2. 比较排序
   

   依次取数组中元素，跟之后元素进行比较，如果大于之后的元素，那么交换他们的位置，通过这种方式进行比较过后的数组就是一个从小到大排序的数组。

   //数组从小到大排序
   for (int i = 0; i < array.length; i++) {
       for(int j = i + 1; j < array.length;j ++){
           if(array[i] > array[j]){
               a = array[i];
               array[i] = array[j];
               array[j] = a;
           }
       }
   }
   System.out.println(Arrays.toString(array));//[6, 8, 10, 11, 12, 13]

3. 递归

   函数自身调用自身的方式称之为递归。

   public int[] sortArray(int[] array,int index){
       int a = 0;
       if(index <= array.length - 1){
           for(int i = index + 1; i < array.length;i ++){
               if(array[index] > array[i]){
                   a = array[index];
                   array[index] = array[i];
                   array[i] = a;
               }
           }
           sortArray(array,index + 1);
       }
       return array;
   }
   System.out.println(sortArray(array,0))

4. 二分查找

   二分查找速度快，数据源需要有序排列

   //查询11在数组中的下标
   int queryParam = 11;
   Arrays.sort(array);//排序
   int i = 0;
   int start = 0;
   int end = array.length - 1;
   while (start <= end) {
       i = (start + end) / 2;
       if (queryParam == array[i]) {
           System.out.println(i);
           break;
       } else if (queryParam < array[i]){
           end = i;
       } else if (queryParam > array[i]){
           start = i;
       }
   }

5. 链表

   public class NodeManager {
   	
   	public static void main(String[] args) {
   		NodeManager node = new NodeManager();
   		node.add("1");
   		node.add("2");
   		node.add("3");
   		node.add("4");
   		node.add("5");
   		
   		node.del("3");
   		
   		node.print();
   	}
   	
   	private Node root;
   	
   	public void add(String name){
   		if (root == null) {
   			root = new Node(name);
   		} else {
   			root.add(name);
   		}
   	}
   	
   	public void del(String name){
   		if (root.getName().equals(name)) {
   			root = root.getNext();
   		} else {
   			root.del(name);
   		}
   	}
   	
   	public void print(){
   		System.out.print(root.getName());
   		if (root.getNext() != null) {
   			root.getNext().print();
   		}
   	}
   	
   	class Node{
   		private String name;
   		private Node next;
   		
   		public Node(String name){
   			this.name = name;
   		}
   		
   		private void add(String name){
   			if(next == null){
   				next = new Node(name);
   			} else {
   				next.add(name);
   			}
   		}
   		
   		private void del(String name){
   			if(next.getName().equals(name)){
   				next = next.getNext();
   			} else {
   				next.del(name);
   			}
   		}
   		
   		private void print(){
   			System.out.print("->" + name);
   			if (next != null) {
   				next.print();
   			}
   		}
   		
   		public String getName(){
   			return name;
   		}
   		
   		public Node getNext(){
   			return next;
   		}
   	}
   }