几种常见的【排序】与【数据结构】

（一）常见排序

import java.util.Arrays;

public class Sort {
//快速排序
	private static int partition(int[] arr, int low, int hight) {
		int pivotkey = arr[low];
		while (low < hight) {
			while (low < hight && pivotkey <= arr[hight])
				--hight;
			int temp1 = arr[low];
			arr[low]=arr[hight];
			arr[hight]=temp1;
			//arr[low] = arr[hight];
			while (low < hight && pivotkey >= arr[low])
				++low;
			int temp2 = arr[low];
			arr[low]=arr[hight];
			arr[hight]=temp2;
			//arr[hight] = arr[low];
		}
		return low;
	}
//快速排序
	public static void qSort(int[] arr, int low, int hight) {
		if (low < hight) {
			int pivotkey = partition(arr, low, hight);
			qSort(arr, low, pivotkey - 1);
			qSort(arr, pivotkey + 1, hight);
		}
	}
//插入排序
	public static int[] insertOrder(int a[]){
		for (int i = 1; i < a.length; i++) {
			int k = a[i];
			int j;
			for (j = i - 1; j >= 0 && k < a[j]; j--) {
				a[j + 1] = a[j];
			}
			a[j + 1] = k;
			//System.out.println(Arrays.toString(a));
		}
		return a;
	}
	//冒泡排序
	public static int[] maopao(int[] a){
		
		for(int i=0;i<a.length-1;i++){//i 代表伦次
			for(int j=0;j<a.length-i-1;j++){//j和j+1代表相邻元素
				if(a[j]>a[j+1]){
					int temp = a[j];
					a[j]= a[j+1];
					a[j+1]=temp;
				}
			}
			//System.out.println(Arrays.toString(a));
			//Arrays.sort(a);
		}
		return a;
	}
	//选择排序
	public int[] selectOrder(int arr[] ) {
		for (int i = 0; i <arr.length; i++) {
			int max = arr[i];
			for (int j = i + 1; j < arr.length; j++) {
				if (arr[j] < max) {
					int temp = arr[j];
					arr[j] = max;
					max = temp;
					arr[i] = max;
				}
			}
		}
		return arr;
	}
	
	// 二分查找
		public void binarySearch() {
			int b[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
			int start = 0;
			int end = b.length - 1;
			int mid;
			int target = 1;
			while (true) {
				mid = ((end + start) / 2);
				if (b[mid] == target) {
					System.out.println(mid);
					break;
				}
				if (target < b[mid]) {
					end = mid;
				}
				if (target > b[mid]) {
					start = mid + 1;
				}

			}
		}
	
	public static void main(String args[]) {
		int Arr[] = { 10, 30, 20, 50, 90, 80, 60, 40, 70 };
		System.out.println(Arrays.toString(Arr));
		qSort(Arr, 0, Arr.length -1);
		System.out.println(Arrays.toString(Arr));
	}
}
希尔排序:
算法思想

它是对插入插入排序的改进

搜索维基百科可知 
希尔排序，也称递减增量排序算法
假设有这样一组数[ 13 14 94 33 82 25 59 94 65 23 45 27 73 25 39 10 ] 
，我们分别以步长为5，3，1进行排序（希尔排序最后的步长一定是1）

步长为5，我们可以得到如下数据， 
13 14 94 33 82 
25 59 94 65 23 
45 27 73 25 39 
10
然后 按照列排序 
10 14 73 25 23 
13 27 94 33 39 
25 59 94 65 82 
45

将上述四行数字，依序接在一起时我们得到：[ 10 14 73 25 23 13 27 94 33 39 25 59 94 65 82 45 ].这时10已经移至正确位置了，然后再以3为步长进行排序： 
10 14 13 
25 23 33 
27 25 59 
39 65 73 
45 94 82 
94 
-最后以1步长进行排序（此时就是简单的插入排序了）。

public static void shellPass(Integer[] array, int d) {
    for (int i = d; i < array.length; i++) {
        int temp = array[i];
        int j = i - d;
        while (j >= 0 && array[j] > temp) {
            array[j + d] = array[j];
            j -= d;
        }
        array[j + d] = temp;
    }
}

public static void shellSort(Integer[] data) {
    int increment = 12;
    do {
        increment = increment / 3 + 1;
        shellPass(data, increment);
    } while (increment > 1);

}

（二）常见数据结构
2.1 graph
2.1.1图节点

public class GraphNode {
	int val;
    GraphNode next;
    GraphNode[] neighbors;
    boolean visited;
 
    GraphNode(int x) {
        val = x;
    }
 
    GraphNode(int x, GraphNode[] n){
        val = x;
        neighbors = n;
    }
 
    public String toString(){
        return "value: "+ this.val; 
    }
}

2.1.2队列

public class Queue {
	 GraphNode first, last;
	 
	    public void enqueue(GraphNode n){
	        if(first == null){
	            first = n;
	            last = first;
	        }else{
	            last.next = n;
	            last = n;
	        }
	    }
	 
	    public GraphNode dequeue(){
	        if(first == null){
	            return null;
	        }else{
	            GraphNode temp = new GraphNode(first.val, first.neighbors);
	            first = first.next;
	            return temp;
	        }   
	    }
}

2.1.3测试类

public class GraphTest {
    public static void main(String[] args) {
        GraphNode n1 = new GraphNode(1); 
        GraphNode n2 = new GraphNode(2); 
        GraphNode n3 = new GraphNode(3); 
        GraphNode n4 = new GraphNode(4); 
        GraphNode n5 = new GraphNode(5); 
 
        n1.neighbors = new GraphNode[]{n2,n3,n5};
        n2.neighbors = new GraphNode[]{n1,n4};
        n3.neighbors = new GraphNode[]{n1,n4,n5};
        n4.neighbors = new GraphNode[]{n2,n3,n5};
        n5.neighbors = new GraphNode[]{n1,n3,n4};
 
        breathFirstSearch(n1, 5);
    }
 
    public static void breathFirstSearch(GraphNode root, int x){
        if(root.val == x)
            System.out.println("find in root");
 
        Queue queue = new Queue();
        root.visited = true;
        queue.enqueue(root);
 
        while(queue.first != null){
            GraphNode c = (GraphNode) queue.dequeue();
            for(GraphNode n: c.neighbors){
 
                if(!n.visited){
                    System.out.print(n + " ");
                    n.visited = true;
                    if(n.val == x)
                        System.out.println("Find "+n);
                    queue.enqueue(n);
                }
            }
        }
    }
}

2.2link
2.2.1链表实例节点

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

2.3Queue
2.3.1队列节点

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

2.3.2队列操作类

public class Queue {
	Node first, last;
	 
    public void enqueue(Node n){
        if(first == null){
            first = n;
            last = first;
        }else{
            last.next = n;
            last = n;
        }
    }
 
    public Node dequeue(){
        if(first == null){
            return null;
        }else{
            Node temp = new Node(first.val);
            first = first.next;
            return temp;
        }   
    }
}

2.4stack
2.4.1栈的节点

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

2.4.2栈的操作类

public class Stack {
	Node top; 
	 
    public Node peek(){
        if(top != null){
            return top;
        }
 
        return null;
    }
 
    public Node pop(){
        if(top == null){
            return null;
        }else{
            Node temp = new Node(top.val);
            top = top.next;
            return temp;    
        }
    }
 
    public void push(Node n){
        if(n != null){
            n.next = top;
            top = n;
        }
    }
}

2.5Tree
2.5.1数的节点

public class TreeNode {
    int value;
    TreeNode left;
    TreeNode right;
}