1.氣泡排序

(1)氣泡排序的思想

      兩兩比較,大的往後放,第一次比較完畢之後,最大值就出現在了最大索引處!然後依次這樣比較,就可以得到一個排好序的陣列.

(2)氣泡排序的規律

 1)一定是兩兩比較,大的往後放,第一次比較完畢,最大值在最大索引處

 2)第一次全部都比較,確定陣列的最大值

  第一次比較,有0個元素不比

  第二次比較,有1個元素不比

  第三次比較,有2個元素不比

   ......

元素比較的次數:(陣列長度-1)次

(3)氣泡排序演算法

public static void BubbleSort(int[] arr) {
		for (int x = 0; x < arr.length - 1; x++) {
			for (int y = 0; y < arr.length - 1 - x; y++) {
				if (arr[y] > arr[y + 1]) {
					int temp = arr[y];
					arr[y] = arr[y + 1];
					arr[y + 1] = temp;
				}
			}
		}
	}
 

2.選擇排序

(1)選擇排序的思想

從0索引對應的元素依次和後面索引對應的元素進行比較,小的往前放,第一次比較完畢之後,最小值就出現在最小索引處,然後依次這樣比較,就可以得到一個排好序的陣列.

(2)選擇排序的規律

 1)從0索引開始依次和後面索引對應的元素進行比較,小的資料往前放,最小值在最小索引處.

 2)用0索引對應的值依次和後面索引對應的值比較

用1索引對應的值依次和後面索引對應的值比較

......

arr.length-2索引對應的元素和arr.length-1索引對應的值比較

(3)選擇排序演算法

// 選擇排序的功能
	public static void selectSort(int[] arr) {
		for (int x = 0; x < arr.length - 1; x++) {
			for (int y = x + 1; y < arr.length; y++) {
				if (arr[x] > arr[y]) {
					int temp = arr[x];
					arr[x] = arr[y];
					arr[y] = temp;
				}
			}
		}
	}
 

3.直接插入排序

(1)直接插入排序的思想

直接插入排序,是一種最簡單的排序方法.他的基本操作是將一個記錄插入到一個長度為m 的有序表中,使之仍保持有序,從而得到一個新的長度為m+1的有序列表.假設有一組元素{k1,k2...,kn},排序開始就認為k1是一個有序序列,讓k2插入上述表長為1的有序序列,使之成為一個表長為2的有序序列,然後讓k3插入上述表長為2的有序序列,使之成為一個表長為3的有序序列,以此類推,最後讓kn插入表長為n-1的有序序列,得到一個表長為n的有序序列.

(2)舉例

•49,38,65,97,76,13,27  原始資料

[49],38,65,97,76,13,27

[38,49], ,65,97,76,13,27

[38,49,65] 97,76,13,27

[38,49,65,97] 76,13,27

[38,49,65,76,97]13,27

[13,27,38,49,65,76,97],27

[13,27,38,49,65,76,97]

(3)直接插入排序演算法

private static void insertSort(int[] arr) {
        //外層迴圈 是迴圈的輪次
        for (int i = 1; i <= arr.length - 1; i++) {
            //當前元素,如果小於我前面的元素,交換位置
            int j = i;
            while (j > 0 && arr[j] < arr[j - 1]) {
                int t = arr[j];
                arr[j] = arr[j - 1];
                arr[j - 1] = t;
                j--;
            }
        }
    }

4.快速排序

(1)快速排序的基本思想

•分治法：比大小，再分割槽

1.從陣列中取出一個數，作為基準數。

2.分區：將比這個數大或等於的數全放到他的右邊，小於他的數 全放到他的左邊。

3.再對左右區間重複第二步，直到各區間只有一個數。

(2)實現思路

•挖坑填數

1.將基準數挖出形成第一個坑。

2.由後向前找比他小的數，找到後挖出此數填到前一個坑中。

3.由前向後找比他大或等於的數，找到後也挖出此數填到前一個坑中。

4.再重複執行2，3兩步驟。

例如對 5391672408 進行排序

(3)快速排序演算法

public class QuickSort {
    //start 預設是0
    //end 是陣列長度-1
    public void quickSort(int[] arr, int start, int end) {
        if (start < end) {
            //獲取分割槽索引
            int index = getIndex(arr, start, end);
            //對左右兩個分割槽 再進行同樣的步驟 ，即是遞迴呼叫
            quickSort(arr, start, index - 1);//左半部分
            quickSort(arr, index + 1, end);//右半部分
        }
    }

    private int getIndex(int[] arr, int start, int end) {
        int i = start;
        int j = end;
        //定義基準數
        int x = arr[i];
        //迴圈
        while (i < j) {
            //從右往左比較
            while (i < j && arr[j] >= x) {
                j--;
            }
            //從右往左找到比基準數小的數了後，填坑
            if (i < j) {
                //把這個數填到上一個坑位
                arr[i] = arr[j];
                //讓 i++;
                i++;

            }

            //從左往右找
            while (i < j && arr[i] < x) {
                i++;
            }
            // 找比基準數大的數，找到後填坑
            if (i < j) {
                arr[j] = arr[i];
                j--;
            }
        }
        //當上面的迴圈結束後把基準數填到最後一個坑位，也就一基準數為界，分成了左右兩部分
        arr[i] = x; //把基準數填進去
        return i; //返回基準數所在位置的索引
    }

}

5.折半查詢

(1)前提:一定是陣列中的元素有序的!

(2)折半查詢的中心思想:

直接將陣列元素減半,方便開發者使用,計算出中心索引,大了左邊找,小了右邊找.

(3)核心思想:

   A:定義最小索引和最大索引
   B:計算中間索引
   C:中間索引對應的元素和需要查詢的元素比較
       相等,直接返回中間索引
       不相等:
              大了,左邊找  max = mid -1 ;
              小了,右邊找  min = mid + 1 ;
   D:重新計算中間索引 ,回到B繼續查詢

(4)折半查詢演算法

public static int search(int[] arr,int value) {
		//1)定義陣列中的最小索引和最大索引
		int min = 0 ;
		int max = arr.length -1 ;
		
		//2) 計算出中間索引
		int mid = (max+min)/2 ;
		
		//3)拿中間索引對應的元素和需要查詢的元素進行比較
		//如果相等,返回
		while(arr[mid]!=value) {
			//不相等
			if(arr[mid] >value) {
				 max = mid -1 ;
			}else {
				 min = mid + 1 ;
			}
			
			//如果這value在陣列中找不到,找不到返回-1
			if(min>max) {
				return -1 ;
			}
			
			//重新計算出中間索引
			mid = (max+min)/2 ;
		}
		return mid ;
	}