java算法篇总结

2019独角兽企业重金招聘Python工程师标准>>>

1. 冒泡排序

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

   int[] array = {10,13,12,8,11,6};
   
   public static void bubblingSort(int[] arry) { // 冒泡排序
           int k = 15;
           for (int i = 0; i < arry.length; i++) {
               for (int j = i + 1; j < arry.length; j++) {
                   if (arry[j] < arry[i]) {
                       k = arry[j];
                       arry[j] = arry[i];
                       arry[i] = k;
                   }
               }
           }
   }

2. 选择排序
   寻找最小值所在索引位置，于i当前起始点进行对调位置

   public static void selectSort(int[] args) {// 选择排序算法
       for (int i = 0; i < args.length - 1; i++) {
           int min = i;
           for (int j = i + 1; j < args.length; j++) {
               if (args[min] > args[j]) {
                   min = j;
               }
           }
           if (min != i) {
               int temp = args[i];
               args[i] = args[min];
               args[min] = temp;
           }
       }
   }

3. 插入排序
   两两比较，小于前一个元素，则调换位置后在于前面元素进行比较，知道遇到比之大的元素跳出，进行下一轮

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

4. 递归

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

   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))

5. 二分查找

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

   //查询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;
       }
   }

6. 链表

   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;
   		}
   	}
   }

 

转载于:https://my.oschina.net/haochenhh/blog/502406