Sort Methods

heyheyhey ~~

It has been a long time since i come here again...whatever today i will summerize some methods of sort with java what are so important for coder. The codes below are all compiled successfully and have the right results

一. insert sort -- is divided into insert directly and Shell Sort.

 

1. insert directly -- the main idea is while obtaining a new value, to compare the new value with the number of sorted array, when get the position that the value is lager than the front number and smaller than the behind number,  insert the value.

public class InsertDirectly {

　　public static void insertDirectly(int[] a) {

　　　　for(int i = 1; i<a.length; ++i) {

　　　　　　// because maybe the insert value would be complicanted , so we should define a copy for it

　　　　　　int temp = a[i];

　　　　　　// then go through the every number of the sorted array to find out the right position.

　　　　　　// to make the j be the global variable.

　　　　　　int j = i-1

　　　　　　// because maybe the a[i] would be complicanted,  so a[j] shouled > temp,not a[i] 

　　　　　　for(; j >= 0 && a[j] > temp; --j) {

　　　　　　　　a[j+1] = a[j];　

　　　　　　}

　　　　　　a[j+1] = temp;

　　　　}

　　}

}

 

2. Shell Sort is the special sort of insert sort, just because it has the increment-'d' ,not one ny one any more.

    main idea is just according to the 'd' to carry out the method of directly insert sort

 

 

public class ShellSort{

　　public static void shellSort(int[] a) {

　　　　// firt step ：need to init the 'd'.

　　　　double d1 = a.length;

　　　　// the 'd' need to be changed, so make sure the loop

　　　　while(true) {

　　　　　　//ceil -- get the bigger one 

　　　　　　double d1 = Math.ceil(d1/2);

　　　　　　int d = (int) d1;

　　　　　　// for the outer loop

　　　　　　for(int i = 0; i<d; ++i) {

　　　　　　　　//for the increment loop

　　　　　　　　for(int j = i+d; j < a.length; i+=d) {

　　　　　　　　　　int temp = a[j];

　　　　　　　　　　// for the inner loop

　　　　　　　　　　int x = j-d;

　　　　　　　　　　for(; x >= 0 && a[x] > temp; x-=d) {

　　　　　　　　　　　　a[x+d] = a[x];

　　　　　　　　　　}

　　　　　　　　　　a[x+d] = temp;

　　　　　　　　}

　　　　　　}

　　　　　　if( d == 1) break;

　　　　}

　　}

} 

 

 

二. select sort -- is divided into easy select sort and heap sort.

 

1. easy select sort is the most easy sort --  main idea is make sure the loop of find out the lagest one or the smallest one ,and put it to the rear or head of the array

 

public class EasySort {

　　public static void swap(int[] a ,int x, int y) {

　　　　int temp = a[x];

　　　　a[x] = a[y];

　　　　a[y] = temp;

　　}

　　public static void easySort(int[] a) {

　　　　for(int i = 0; i<a.length; ++i) {

　　　　　　int max = a[i];

　　　　　　int flag = i;

　　　　　　for(int j = i+1; j < a.length;++j) {

　　　　　　　　if(max < a[j]) {

　　　　　　　　　　max = a[j];

　　　　　　　　　　flag = j;

　　　　　　　　}

　　　　　　}

　　　　　　swap(a, a.length-1-i, flag);

　　　　}

　　} 

}

 

2.Heap Sort is actually the selected sort based on heap -- main idea is that build max or min heap and then change the position bettween the max or min and the last position. 

 

public class HeapSort {

　　// this methid is mainly to change the max value which is in the top of heap(in other word which is always the first position of the array) 

     // with the last number of this array.

　　public static void swap(int[] a, int i, int j) {

　　　　int temp = a[i];

　　　　a[i] = a[j];

　　　　a[j] = temp;

　　}

　　public static void heapSort(int[] a) {

　　　　// from the last value of the array in order to buildMaxHeap circularly.

　　　　for(int i = a.length-1; i > 0; --i) {

　　　　　　buildMaxHeap(a, i);

　　　　　　swap(a, 0, i);

　　　　}

　　}

　　// next is the highlight of the heap sort ,and in this method we would to let u know how to bulid the max heap and how to reform the heap a

     // again and again.

　  public static void buildMaxHeap(int[] a,int lastIndex) {

　　　　// step 1 : get the last father node of this heap

　　　　int lastFather = (lastIndex-1)/2;

　　　　// step 2 : we need to find out the max value among the father node and the subnodes 

　　　　for(int i = lastFather; i >= 0; --i) {

　　　　　　// step 2.1 : first we need to find out the max value bettween the subnodes

　　　　　　int biggerIndex = lastFather*2+1; //  make the left node be the max first and then judge if the right node exists

　　　　　　if(biggerIndex < lastIndex) // make sure the right node exists {

　　　　　　　　if(a[biggerIndex] < a[lastIndex]) {

　　　　　　　　　　biggerIndex ++;

　　　　　　　　}

　　　　　　}

　　　　　　// step 2.2 :  second we need to compare the biggerOne and the father node

　　　　　　if(a[lastFather] < a[biggerIndex]) {

　　　　　　　　// let the larger value go to the top

　　　　　　　　swap(a, lastFather, biggerIndex);

　　　　　　}

　　　　}

　　}

}

 

-----------------------------------------------------------------------------------------------------------------------------------------------------------------

哎，原本說上學期堅持的，結果拖到了這學期了，可是確實是最近事情比較多，接的項目也比較繁瑣，不過，什麼都不會抵擋我繼續學習的心情,廢話很少說，繼續吧

-----------------------------------------------------------------------------------------------------------------------------------------------------------------

 

Quick sort -- 快排是如今比較廣泛和使用的排序工具，主要是由於它是跳躍性的交換數據的，而不是像簡單排序和冒泡那樣得相鄰的兩個數據進行交換，固然快排仍是增強版的冒泡

 

思想只要就是，定好一個基數後，而後從這個基數後面的開始，設下標爲i，和從最後一個開始，設下標爲j，遍歷，在i<j的時候，找到，a[i] > 基數,和a[j]<基數的，進行交換，直到i>j，以後就交換基數和a[j]，這樣就能夠作到，一次性將大於基數的移到基數的右邊，小於基數的移到基數的左邊，而後這裏再返回一個j，來做爲下一次進行這樣一個過程的分界點.固然這裏也會用到遞歸

package Sort;

import java.util.Scanner;

/*
 * 簡單介紹一下快排的思想  : 
 * */ 

public class QuickSort {
    // 交換數組中的兩個數字
    public static void swap(int[] a, int i, int j){
        int temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
    
    public static void quicky_sort(int[] a, int start, int end){
        // 這一步必需要,不然會出現outofbounds的狀況，由於會出現p前面或者後面只有一個數字的狀況
        if(start >= end || a == null) return; 
        
        int p = partition(a, start, end);
        quicky_sort(a, start, p-1);
        quicky_sort(a, p+1, end);
        
    }
    // partition ： 主要是在一個基數的循環下返回下一個批次要進行的 
    public static int partition(int[] arr, int start, int end){
        int parti = 0;
        int i = start;
        int j = end;
        
        while(i<j){
            while(arr[i] <= arr[start] && i<end){ // 後面的條件必需要，不然會出現outofbounds的錯誤，由於這是第一個循環，想一想要是是一個一直從大到小的數組，若是沒有後面的&&就會訪問越界
                i++;
            }
            while(arr[j] > arr[start] && j >= start){
                j--;
            }
            if(i < j){ //這個也是必須的，由於會出現最後一種當i>j的狀況，這個時候就沒有必要交換了
                swap(arr, i, j);
            }
        }
        
        swap(arr, start, j);
        parti = j;
        
        return parti;
    }
    public static void main(String[] args) {
        //int[] a = new int[10];
//        Scanner in = new Scanner(System.in);
//        for(int i=0;i<a.length; ++i){
//            a[i] = in.nextInt();
//        }
        int[] a = {57, 68, 59, 52, 72, 28, 96, 52, 24, 19};
        quicky_sort(a, 0, a.length-1);
        for(int i=0;i<a.length; ++i){
            System.out.print(" "+a[i]);
        }
    }
}

 

上面也有一些要注意的地方，都是我debug時候血的教訓啊，沒考慮到的細節有不少，好比在你進行i和j的循環的時候，由於i是第一個指標，若是你讓他<end的話，那若是分出來的新的數組就是從大到小的，那麼就會出現數組越界的狀況了，由於，知足的話，i就會++嘛，而後後面那個if裏面的看起來和在外層的條件是同樣的，但毫不是多餘的，由於必定要考慮到臨界的狀況，當i>j的時候，這個時候就不須要進行交換了，因此必然要加上的

 

還有一個就是，在quicky_sort()裏面要考慮到start >= end 的時候，就不須要後面的步驟了。