算法复习~

1.单链表反转

private Node reverseNode2(Node node) {

        if(node.next==null){
            return node;
        }

        Node preNode= reverseNode2(node.next);
        node.next.next=node;
        node.setNext(null);


        return preNode;
    }

//1->2->3
    private Node reverseNode(Node node){
        Node head=null;
        if(node==null ||node.getNext()==null) return node;
        Node pre= null;
        Node next=node.getNext();
        Node current=node;

        while (current.getNext()!=null){
            //next=current.getNext();
           // pre=current;
            current.setNext(pre);
            pre=current;
            current=next;
            next=next.next;
        }
        current.setNext(pre);
        head=current;

        return head;
    }

2.快速排序

 static void quickSortInfo(int[] arr,int left,int right){
       int index= getSortIndex(arr,left,right);
if(left<index-1&&index+1<right) {
    quickSortInfo(arr, left, index - 1);
    quickSortInfo(arr, index + 1, right);
}
    }
    static int getSortIndex(int[] arr,int left,int right){

        int i=left;
        int j=right;
        int temp= arr[i];
        while (i<j){
            while (i<j && temp<arr[j])
                j--;
            if(i<j) {
                arr[i] = arr[j];
i++;
            }
            while (i<j&&temp>arr[i])
                i++;
            if(i<j) {
                arr[j] = arr[i];
j--;
            }
        }
arr[i]=temp;
        return i;
    }
}

3.冒泡排序

public static void bubbleSort(int[] numbers) {   
    int temp; // 记录临时中间值   
    int size = numbers.length; // 数组大小   
    for (int i = 0; i < size - 1; i++) {   
        for (int j = i + 1; j < size; j++) {   
            if (numbers[i] > numbers[j]) { // 交换两数的位置   
                temp = numbers[i];   
                numbers[i] = numbers[j];   
                numbers[j] = temp;   
            }   
        }   
    }   
} 

4.选择排序

/**  
 * 选择排序<br/>  
 * <li>在未排序序列中找到最小元素，存放到排序序列的起始位置</li>  
 * <li>再从剩余未排序元素中继续寻找最小元素，然后放到排序序列末尾。</li>  
 * <li>以此类推，直到所有元素均排序完毕。</li>  

 *   
 * @param numbers  
 */  
public static void selectSort(int[] numbers) {   
    int size = numbers.length, temp;   
    for (int i = 0; i < size-1; i++) {   
        int k = i;   
        for (int j = size - 1; j >i; j--)  {   
            if (numbers[j] < numbers[k])  k = j;   
        }   
        temp = numbers[i];   
        numbers[i] = numbers[k];   
        numbers[k] = temp;   
    }   
}  

5.插入排序

public static void insertSort(int[] numbers) {
    for (int i = 1; i < numbers.length; i++) {

        for (int j = i; j > 0; j--) {
            if (numbers[j - 1] > numbers[j]) {
                int t = numbers[j - 1];
                numbers[j - 1] = numbers[j];
                numbers[j] = t;
            } else break;
        }
    }
}

6.全排列

public static void perm(char[] buf, int start, int end) {
        if (start == end) {//这个判断用于递归到最后的时候输出相应的字符串

//            for(int i=0;i<=end;i++){
//
//                System.out.print(buf[i]);
//
//            }
            String s = new String(buf, 0, end+1);
            System.out.println(s);

        }else{
        for (int i = start; i <= end; i++) {
            char temp = buf[start];
            buf[start] = buf[i]; 
            buf[i] = temp;  
            perm(buf, start + 1, end);
            temp = buf[start];
            buf[start] = buf[i];  
            buf[i] = temp;
        }

}
    }