主頁 > 後端開發 > 排序演算法詳解（java代碼實作）

排序演算法詳解（java代碼實作）

2022-04-30 07:06:50 後端開發

? 排序演算法大致分為內部排序和外部排序兩種

內部排序：待排序的記錄全部放到記憶體中進行排序，時間復雜度也就等于比較的次數

外部排序：資料量很大，記憶體無法容納，需要對外存進行訪問再排序，把若干段資料一次讀入記憶體使用內部排序的方法進行排序后寫入外存，再將這若干個已經排序的資料進行歸并，時間復雜度等于IO(訪問外存)的次數

1、冒泡演算法

? 交換排序，屬于比較簡單直觀的排序演算法，以升序為例（從小到大），每次比較相鄰的兩個元素，如果左側元素比右側的大，則交換兩個元素的位置，每次把回圈中最大的元素放在回圈的最后，像冒泡一樣從小到最大，

1.1 演算法步驟

  1. 比較 a[j] 和 a[j+1]，如果 a[j] > a[j+1]，swap交換兩個元素在陣列中的位置
  2. 讓每一對相鄰元素進行以上的比較，直到把最大的值放到比較的陣列最后
  3. 重復以上步驟n-1次

1.2 時間復雜度

? 總共需要比較次數(n為陣列元素個數 n >= 1)：

\[O(n)=(n-1)+(n-2)+\cdots+1=\frac{(n-1)*n}{2}\\ 取最高次冪O(n)=n^2 \]

1.3 代碼實作

public int[] bubbleSort(int[] arr) {
    // 外層回圈，陣列長度為 n，回圈次數為 n-1
    for (int i = 0; i < arr.length - 1; i++) {
        // 內層回圈，回圈次數為 n-1-i，找到一個最大值放在，arr[n-1-i]的位置
        for (int j = 0; j < arr.length - 1 - i; j++) {
            // 比較相鄰的兩個值，把相對大的值放在陣列下標大的地方
            if (arr[j] > arr[j + 1]) {
                // swap交換
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
    return arr;
}

1.4 圖示

? 如圖，即使第二次回圈已經排好序，但是程式不曉得，仍會繼續回圈進行排序，最后一次，只有兩個元素進行排序比較，直接排序完成，排序次數 n-1，

2、快速排序

? 交換排序，選擇一個基準值，將陣列劃分兩個區域，左側的值全部比右側的值小，然后分別對兩個區域繼續進行區域的劃分與排序，直到排序完成，

2.1 演算法步驟

  1. 從陣列中按照一定的規則選擇一個元素作為基準值
  2. 把基準值與其他元素進行比較，將元素分成兩部分，把所有比基準值小的值放在左側，所有比基準值大的放在右側，即進行區域劃分
  3. 通過遞回上述操作，再次將左右兩區域進行區域劃分，完成排序

2.2 時間復雜度

? 對區域劃分取特殊值，假設n為2的冪，每次都將n個數平均劃分，所以第一次對一整個區域進行回圈n次劃分2個區域，第二次對兩個區域分別進行回圈\(\frac{n}{2}\)次，共n次，劃分4個區域，第三次對4個區域分別進行回圈\(\frac{n}{4}\)次，共計n次，以此類推，最后一次為第log2n次，劃分的每個區域僅有一個元素，即：

\[O(n)=n*log_2n \]

2.3 代碼實作

private static int[] quickSort(int[] arr, int left, int right) {
    if (left < right) {
        int partitionIndex = partition(arr, left, right);
        // 左側右側區間再分別進行排序
        quickSort(arr, left, partitionIndex - 1);
        quickSort(arr, partitionIndex + 1, right);
    }
    return arr;
}

// 以基準值將陣列arr的left~right區間進行磁區，保證回傳的下標左側元素比基準值小，右側比基準值大
private static int partition(int[] arr, int left, int right) {
    // 設定基準值為最左側元素，本身不參與回圈中的交換，僅在最后放到index的位置
    int pivot = left;
    // 該index用于標記一個下標，代表當前已經遍歷的元素中，index位置的元素是最后一個比基準值小的元素
    // arr[index]本身以及陣列左側元素都小于基準值
    int index = left;
    // 遍歷left+1~right區間（因為基準值自身不需要進行比較交換）
    for (int i = left+1; i <= right; i++) {
        if (arr[i] < arr[pivot]) {
            // 保證從當前遍歷到的最后一個比基準值小的元素的下一個元素開始交換，所以先++再交換
            index++;
            swap(arr, i, index);
        }
    }
    // 此時index為分界點，arr[index]<arr[index+1]
    // 其他元素交換完畢之后arr[index]的值應該為基準值，所以進行元素位置交換
    swap(arr, pivot, index);
    // 此時arr[index]兩側元素左小右大
    return index;
}
// 元素交換
private static void swap(int[] arr, int i, int j) {
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

2.4 圖示

3、直接插入排序

? 插入排序，每一次把一個待排序的記錄，按照值的大小，插入到有序陣列的合適位置，

? 相當于把a[n]分割，先排序陣列 a[0] ~ a[1]，再 a[0] ~ a[2]，直到 a[0] ~ a[n] 全部排序完成，

3.1 演算法步驟

  1. 第一個元素之前沒有值，認為已經排序
  2. 取下一個待排序元素，下標為 i，向前進行比較
  3. 如果待排序元素比待比較元素小，則交換位置
  4. 重復步驟3直到有一個元素等于或者小于待排序元素，此次內回圈結束，a[0] ~ a[i]排序完成
  5. 重復步驟2~4，直到最后一個元素

3.2 時間復雜度

? 認為第一元素已經排好序，從第二個元素開始向前比較，計算需要比較的次數：

\[O(n) = 1+2+3+\cdots+n-1= \frac{(n-1)*n}{2}\\ 即O(n) = n^2 \]

3.3 代碼實作

public static int[] insertionSort(int[] arr){
    // 從第二個元素開始到最后一個元素
    for (int i = 1; i <  arr.length; i++) {
        // 向前遍歷
        for( int j = i ; j > 0 ; j -- ){
            if( arr[j] < arr[j-1] ){
             	swap( arr, j , j-1 );   
            } 
            else{
                break;
            }       
        }
    }
    return arr;
}
private static void swap(int[] arr, int i, int j) {
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

3.4 圖示

4、希爾排序

? 插入排序，因為設計該演算法的人叫Shell，所以叫希爾排序，又稱縮小增量排序，思路上是將待排序序列分割成若干個子序列進行直接插入排序，并逐漸縮減少子序列個數，直到針對整體進行一次排序，

4.1 演算法步驟

  1. 設定一個遞減增量序列 $$t_1,t_2,\cdots,t_k$$，\(t_k\)為1
  2. 按照增量個數k，整體上對序列進行k次排序
  3. 每次排序，根據增量 t，將序列分割成 (陣列長度 / \(t_i\)) 個子序列，對子序列分別進行直接插入排序，當增量為1時，對序列整體進行一次排序

4.2 時間復雜度

? 希爾排序的時間復雜度和增量的選擇有關，證明的話我是不會，最壞時間復雜度是\(O(n^2)\)，當n在某個范圍內時，可以達到\(O(n^{1.3})\)

4.3 代碼實作

/**
	該代碼與實際演算法步驟有區別：
	演算法步驟是說針對每個子序列進行直接插入排序，實際上對每個子序列的直插排序是交替進行的
**/
public static void shellSort(int[] arr) {
    int length = arr.length;
    // 記錄需要進行直接插入排序的值
    int temp;
    // 增量step從length/2遞減到1進行回圈
    for (int step = length / 2; step >= 1; step /= 2) {
        // 進行直插排序，默認第一個元素已經排序完成，從step下標的元素開始向前進行直插
        for (int i = step; i < length; i++) {
            // 需要對arr[i]進行直接插入排序，記錄該值
            temp = arr[i];
            // j來記錄temp最后需要插入的位置
            int j = i;
            while (j -step >= 0 && arr[j-step] > temp) {
                arr[j] = arr[j-step];
                j -= step;
            }
            arr[j] = temp;
        }
    }
}

// 使用直接插入版本的代碼：
private static void shellSort2(int[] arr) {
    int len = arr.length;
    for (int step = len / 2; step > 0; step = step / 2) {
        // 直接插入排序的代碼，只不過向前遍歷時遍歷的陣列為i,i-step,i-step-step...
        for (int i = step; i < arr.length; i++) {
            for (int j = i; j-step >= 0; j -= step) {
                if (arr[j] < arr[j - step]) {
                    swap(arr, j, j - step);
                }
            }
        }
    }
}
private static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
}

4.4 圖示

5、簡單選擇排序

? 選擇排序，從未排序序列中查找一個最小值，然后將該值放到已排序序列的末尾位置，回圈下去，直到最后一個元素，

5.1 演算法步驟

  1. 從 a[i] 開始，i=0,1,2,...,n，在陣列中找到最小值的下標，放到arr[i]，此時 a[0] ~ a[i] 有序，a[i+1] ~ a[n] 待排序
  2. 待排序序列重復步驟1
  3. 經過n-1次回圈完成排序

5.2 時間復雜度

? 回圈次數為n-1，n-2，n-3，\(\cdots\)，1

\[O(n) = (n-1)+(n-2)+\cdots+1\\ O(n) = \frac{1}{2}(n^2-n)\\ O(n) = n^2 \]

5.3 代碼實作

public static int[] selectionSort(int[] arr){
    // 外層回圈經過 n-1 輪比較
    for (int i = 0; i < arr.length - 1; i++) {
        // min用來記錄每次比較程序中最小值的下標
        int min = i;
        // 0~i已經排序完成，從i向后比較查找后面序列的最小值
        for (int j = i + 1; j < arr.length; j++) {
            if (arr[j] < arr[min]) {
                // 記錄最小值元下標
                min = j;
            }
        }
        // 將找到的最小值和i位置所在的值進行交換
        if (i != min) {
            swap(arr, i ,min);
        }
    }
    return arr;
}

5.4 圖示

6、堆排序

? 選擇排序，將待排序列構造誠大根堆，根節點則為序列中最大元素，將該節點與最后一個值交換，把剩余的節點重新構建大根堆，繼續進行交換，直到待排序列只剩下一個值，

? 大根堆（大頂堆）：父節點一定大于兩個子節點的值，即：arr[i] > arr[2i+1] && arr[i] > arr[2i+2]

? 將大根堆映射到陣列中示例：

6.1 演算法步驟

  1. 將待排序陣列構建成大根堆（仍然是無序的），根節點則為陣列最大值
  2. 將根節點和最后一個節點進行交換，則最大值放到了陣列尾部，此時 a[0] ~ a[n-1] 無序
  3. 因為步驟2進行了節點交換，需要對 a[0] ~ a[n-1] 重新構建大根堆
  4. 重復步驟 2，3 直到全部有序

6.2 時間復雜度

  1. 初始化大根堆

? 設元素個數為 n，建堆的高度 \(k=log_2(n+1)\)，

? 第 i 層的非葉子節點的最大操作（交換）次數為 k-i

? 第 i 層的節點個數為 \(2^{i-1}\)

? 所以第 i 層總共需要操作 \((k-i)(2^{i-1})\) 次，總共需要操作的次數為

\[S = (k-1)*2^0 + (k-2)*2^{1}+(k-3)*2^2+\cdots+(k-(k-1))*2^{k-1-1} \]

? 用 2S - S計算 S 的值:

\[S = 2^1+2^2+\cdots+2^{k-1}-(k-1)\\ S = 2^k-k-1 \]

? 將 \(k=log_2{(n+1)}\approx log_2n\) 代入得

\[O(n) = n - log_2n-1 \\取最高項O(n) = n \]

? 則初始化大根堆的時間復雜度 O(n) = n

2.重新調整堆

? 根節點和待排序陣列的最后一個元素 a[i] 交換之后，需要重新調整堆，最大調整次數 = a[i] 所在堆的層數 = \(log_2i\)，總共需要調整的次數 = \((n-1)(log_2n)\) ，所以調整堆的時間復雜度為

\[O(n) = nlog_2n \]

總的時間復雜度 \(O(n) = n + nlog_2n = nlog_2n\)

6.3 代碼實作

public static int[] HeapSort(int[] arr) {
    int len = arr.length;
    // 對所有元素建立大根堆
    buildMaxHeap(arr, len);
    // 從陣列尾開始進行回圈，每次找到待排序序列的最大值
    for (int i = arr.length - 1; i > 0; i--) {
        // 此時arr[0]為最大值，交換根節點arr[0]和最后一個節點 i
        swap(arr, 0, i);
        len--;
        // 剩余元素重新建堆
        heapify(arr, 0, len);
    }
    return arr;
}
private static void buildMaxHeap(int[] arr, int len) {
    for (int i = len / 2; i >= 0; i--) {
        heapify(arr, i, len);
    }
}
/**
 * @param arr       排序陣列
 * @param parent    父節點下標
 * @param len       待排序陣列 length
 */
private static void heapify(int[] arr, int parent, int len) {
    // 計算父節點的兩個子節點下標
    int left = 2 * parent + 1;
    int right = 2 * parent + 2;
    // largest為父節點和子節點最大值的下標
    int largest = parent;
    // 比較左右子節點和父節點的大小
    if (left < len && arr[left] > arr[largest]) {
        largest = left;
    }
    if (right < len && arr[right] > arr[largest]) {
        largest = right;
    }
    // 如果當前的最大值不是當前父節點，需要進行元素交換，
    // 交換之后的子節點作為父節點時不一定是大根堆，需要重新建堆
    if (largest != parent) {
        swap(arr, parent, largest);
        heapify(arr, largest, len);
    }
}
private static void swap(int[] arr, int i, int j) {
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

6.4 圖示

初始化大根堆：

回圈取堆頂元素排序：建議自己畫二叉樹更明晰

完整動圖：

7、歸并排序

? 將兩個及以上的有序表合并成一個有序表，以下為兩路合并排序，

? 采用分治法，把無序陣列兩兩分割，分割數次，然后自下至上將兩個子序列進行排序，然后合并成一個有序陣列，逐漸向上進行兩兩合并，直到合并成一個有序陣列，

7.1 演算法步驟

  1. 將陣列從中間拆分為兩個無序陣列
  2. 通過遞回繼續執行步驟 1
  3. 通過兩個指標指向兩個陣列的起始位置
  4. 比較指標指向的兩個元素，把較小的放入合并陣列，移動指標向后
  5. 重復步驟4直到某一個指標到達陣列尾部，此時另一個陣列的元素全部不小于合并陣列元素
  6. 將另一個陣列的元素放入合并陣列
  7. 繼續歸并，直到剩下一個陣列

7.2 時間復雜度

? 時間復雜度 = 兩個陣列歸并排序的時間復雜度 + 重建大根堆的時間復雜度

? $f(n) = 2f(\frac{n}{2})+ n $

? \(n = \frac{n}{2}\) : : \(f(\frac{n}{2}) = 2f(\frac{n}{4}) + \frac{n}{4}\)

? \(n=\frac{n}{4}\) : : \(f(\frac{n}{4})=2f(\frac{n}{8}) + \frac{n}{8}\)

? \(\cdots\)

? \(n=\frac{n}{2^{m-1}}\) : : \(f(\frac{n}{2^{m-1}}) = 2f(\frac{n}{2^m}) + \frac{n}{2^{m-1}}\)

? 即：\(f(n) = 2f(\frac{n}{2}) + n\)

? \(=2[2f(\frac{n}{4} + \frac{n}{4}) + n]\) = $ 22f(\frac{n}{22}) + 2n$

? \(=2^2[f(2f(\frac{n}{8}) + \frac{n}{4})] + 2n\) = \(2^3f(\frac{n}{2^3}) + 3n\)

? \(\cdots\)

? \(=2^mf(\frac{n}{2^m}) + mn\)

? 當陣列被分割成僅剩一個元素時，此時分割為\(2^mf(1)+mn\) 即： \(\frac{n}{2^m} = 1\)

? 則：\(m = log_2n\)

? 代入得\(f(n) = 2^{log_2n}f(1) + n * log_2n = n + nlog_2n\)

? 所以歸并排序的時間復雜度為：

\[O(n) = nlog_2n \]

7.3 代碼實作

public static int[] MergeSort(int[] arr) {
    // 陣列中僅有一個元素==已排序
    if (arr.length < 2) {
        return arr;
    }
    // 分割陣列的下標
    int middle = arr.length / 2;
    // 將陣列分割成arr[0] ~ arr[middle-1] 和 arr[middle] ~ arr[length-1] 兩部分
    int[] left = Arrays.copyOfRange(arr, 0, middle);
    int[] right = Arrays.copyOfRange(arr, middle, arr.length);
    /**
     * 可以拆分為
     * int[] arr1 = MergeSort(left);
     * int[] arr2 = MergeSort(right);
     * 對兩個分割后的陣列分別再進行歸并排序
     * return merge(arr1, arr2);
     */
    return merge2(MergeSort(left), MergeSort(right));
}
/**
 *  將兩個陣列進行合并方法 1
 */
protected static int[] merge1(int[] left, int[] right) {
    // 合并后的陣列
    int[] result = new int[left.length + right.length];
    // i 進行計數，直到等于left或者right陣列的長度
    int i = 0;
    // 回圈對left和right陣列的首個元素進行比較，把小的放入result陣列
    // 并重新給left或right陣列賦值
    while (left.length > 0 && right.length > 0) {
        if (left[0] <= right[0]) {
            result[i] = left[0];
            left = Arrays.copyOfRange(left, 1, left.length);
        } else {
            result[i] = right[0];
            right = Arrays.copyOfRange(right, 1, right.length);
        }
        i++;
    }
    // 此時left或right陣列有一個已經遍歷完畢，直接把剩下的元素全部放入result陣列
    while (left.length > 0) {
        result[i] = left[0];
        i++;
        left = Arrays.copyOfRange(left, 1, left.length);
    }
    while (right.length > 0) {
        result[i] = right[0];
        i++;
        right = Arrays.copyOfRange(right, 1, right.length);
    }
    return result;
}
/**
 *  將兩個陣列進行合并方法 2
 *  個人還是傾向于這個直觀的
 */
private static int[] merge2(int[] left, int[] right) {
    // 合并后的結果
    int[] result = new int[left.length + right.length];
    // i,j分別用于遍歷left，right陣列
    int i = 0;
    int j = 0;
    // count用于放入result陣列時的下標計數
    int count = 0;
    // 回圈對left和right陣列元素進行比較，并把小的賦值給result[count]
    // 直到遍歷完left或者right陣列
    while (i < left.length && j < right.length) {
        if (left[i] < right[j]) {
            result[count] = left[i];
            i++;
        } else {
            result[count] = right[j];
            j++;
        }
        count++;
    }
    // 此時left或right陣列有一個已經遍歷完畢，直接把剩下的元素全部放入result陣列
    while (i < left.length) {
        result[count] = left[i];
        i++;
        count++;
    }
    while (j < right.length) {
        result[count] = right[j];
        j++;
        count++;
    }
    return result;
}

7.4 圖示

注：兩個圖不是同一個演算法程序

8、基數排序

? 取得最大整數的位數，從個位開始進行比較放入新的陣列，再收集起來，此時陣列按照個位有序排列，再進位進行比較收集，以此類推，直到最高位比較完成，此時陣列全部有序，

8.1 演算法步驟

  1. 取得陣列最大數的位數
  2. 根據陣列元素個位數的大小放入不同的陣列中
  3. 按照順序將陣列中的元素收集起來，此時新的陣列按陣列元素的個位數有序
  4. 陣列元素進位（十位、百位...）按照該位的大小重復2、3
  5. 直到按照最大位數進行元素收集后所有元素有序

8.2 時間復雜度

? 設n個數的最大值是k位數，需要的桶（收集元素的陣列）為r個，進行一次遍歷元素收集的時間復雜度為O(n+r)，總的時間復雜度就是O(k(n+r))，一般來說，n >> r 且 n >> k，所以可以認為基數排序的時間復雜度為O(n)，也可以認為事件復雜度為O(kn)，

8.3 代碼實作

private static int[] RadixSort(int[] arr, int maxDigit) {
    int mod = 10;
    int dev = 1;
    for (int i = 0; i < maxDigit; i++, dev *= 10, mod *= 10) {
        // 使用二維陣列作為桶存放資料
        // 考慮負數的情況，其中 [0-9]對應負數，[10-19]對應正數 (bucket + 10)
        int[][] counter = new int[mod * 2][0];
        for (int j = 0; j < arr.length; j++) {
            int bucket = ((arr[j] % mod) / dev) + mod;
            counter[bucket] = arrayAppend(counter[bucket], arr[j]);
        }
        // 收集陣列中的資料
        int pos = 0;
        for (int[] bucket : counter) {
            for (int value : bucket) {
                arr[pos++] = value;
            }
        }
    }
    return arr;
}
// 自動擴容，并保存資料
private static int[] arrayAppend(int[] arr, int value) {
    arr = Arrays.copyOf(arr, arr.length + 1);
    arr[arr.length - 1] = value;
    return arr;
}
// 獲取最高位數
private static int getMaxDigit(int[] arr) {
    int maxValue = https://www.cnblogs.com/william-m/p/getMaxValue(arr);
    return getNumLength(maxValue);
}
// 獲取最大值
private static int getMaxValue(int[] arr) {
    int maxValue = arr[0];
    for (int value : arr) {
        if (maxValue < value) {
            maxValue = value;
        }
    }
    return maxValue;
}
// 獲取最大值的長度
protected static int getNumLength(long num) {
    if (num == 0) {
        return 1;
    }
    int length = 0;
    for (long temp = num; temp != 0; temp /= 10) {
        length++;
    }
    return length;
}

8.4 圖示

演算法可視化網站：

★ https://algorithm-visualizer.org/ 可以手動更改代碼，更改影片速度，英文

★ https://visualgo.net/zh 演算法種類比較多，可中文

https://www.cs.usfca.edu/~galles/visualization/Algorithms.html

繪圖網站：

https://app.diagrams.net/

本文來自博客園，作者：醉千燈，轉載請注明原文鏈接：https://www.cnblogs.com/william-m/p/16206896.html

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/467906.html

標籤：Java

上一篇：Java的三大特性

下一篇：陣列

標籤雲
其他(157675) Python(38076) JavaScript(25376) Java(17977) C(15215) 區塊鏈(8255) C＃(7972) AI(7469) 爪哇(7425) MySQL(7132) html(6777) 基礎類(6313) sql(6102) 熊猫(6058) PHP(5869) 数组(5741) R(5409) Linux(5327) 反应(5209) 腳本語言(PerlPython)(5129) 非技術區(4971) Android(4554) 数据框(4311) css(4259) 节点.js(4032) C語言(3288) json(3245) 列表(3129) 扑(3119) C++語言(3117) 安卓(2998) 打字稿(2995) VBA(2789) Java相關(2746) 疑難問題(2699) 细绳(2522) 單片機工控(2479) iOS(2429) ASP.NET(2402) MongoDB(2323) 麻木的(2285) 正则表达式(2254) 字典(2211) 循环(2198) 迅速(2185) 擅长(2169) 镖(2155) 功能(1967) .NET技术(1958) Web開發(1951) python-3.x(1918) HtmlCss(1915) 弹簧靴(1913) C++(1909) xml(1889) PostgreSQL(1872) .NETCore(1853) 谷歌表格(1846) Unity3D(1843) for循环(1842)

熱門瀏覽
  • 【C++】Microsoft C++、C 和匯編程式檔案

    ......

    uj5u.com 2020-09-10 00:57:23 more
  • 例外宣告

    相比于斷言適用于排除邏輯上不可能存在的狀態，例外通常是用于邏輯上可能發生的錯誤。 例外宣告 Item 1：當函式不可能拋出例外或不能接受拋出例外時，使用noexcept 理由 如果不打算拋出例外的話，程式就會認為無法處理這種錯誤，并且應當盡早終止，如此可以有效地阻止例外的傳播與擴散。 示例 //不可 ......

    uj5u.com 2020-09-10 00:57:27 more
  • Codeforces 1400E Clear the Multiset(貪心 + 分治)

    鏈接：https://codeforces.com/problemset/problem/1400/E 來源：Codeforces 思路：給你一個陣列，現在你可以進行兩種操作，操作1：將一段沒有 0 的區間進行減一的操作，操作2：將 i 位置上的元素歸零。最終問：將這個陣列的全部元素歸零后操作的最少 ......

    uj5u.com 2020-09-10 00:57:30 more
  • UVA11610 【Reverse Prime】

    本人看到此題沒有翻譯，就附帶了一個自己的翻譯版本 思考 這一題，它的第一個要求是找出所有 $7$ 位反向質數及其質因數的個數。 我們應該需要質數篩篩選1~$10^{7}$的所有數，這里就不慢慢介紹了。但是，重讀題，我們突然發現反向質數都是 $7$ 位，而將它反過來后的數字卻是 $6$ 位數，這就說明 ......

    uj5u.com 2020-09-10 00:57:36 more
  • 統計區間素數數量

    1 #pragma GCC optimize(2) 2 #include <bits/stdc++.h> 3 using namespace std; 4 bool isprime[1000000010]; 5 vector<int> prime; 6 inline int getlist(int ......

    uj5u.com 2020-09-10 00:57:47 more
  • C/C++編程筆記：C++中的 const 變數詳解，教你正確認識const用法

    1、C中的const 1、區域const變數存放在堆疊區中，會分配記憶體（也就是說可以通過地址間接修改變數的值）。測驗代碼如下： 運行結果： 2、全域const變數存放在只讀資料段（不能通過地址修改，會發生寫入錯誤）， 默認為外部聯編，可以給其他源檔案使用（需要用extern關鍵字修飾） 運行結果： ......

    uj5u.com 2020-09-10 00:58:04 more
  • 【C++犯錯記錄】VS2019 MFC添加資源不懂如何修改資源宏ID

    1. 首先在資源視圖中，添加資源 2. 點擊新添加的資源，復制自動生成的ID 3. 在解決方案資源管理器中找到Resource.h檔案，編輯，使用整個專案搜索和替換的方式快速替換 宏宣告 4. Ctrl+Shift+F 全域搜索，點擊查找全部，然后逐個替換 5. 為什么使用搜索替換而不使用屬性視窗直 ......

    uj5u.com 2020-09-10 00:59:11 more
  • 【C++犯錯記錄】VS2019 MFC不懂的批量添加資源

    1. 打開資源頭檔案Resource.h，在其中預先定義好宏 ID（不清楚其實ID值應該設定多少，可以先新建一個相同的資源項，再在這個資源的ID值的基礎上遞增即可） 2. 在資源視圖中選中專案資源，按F7編輯資源檔案，按 ID 型別 相對路徑的形式添加 資源。（別忘了先把檔案拷貝到專案中的res檔案 ......

    uj5u.com 2020-09-10 01:00:19 more
  • C/C++編程筆記：關于C++的參考型別，專供新手入門使用

    今天要講的是C++中我最喜歡的一個用法——參考，也叫別名。 參考就是給一個變數名取一個變數名，方便我們間接地使用這個變數。我們可以給一個變數創建N個參考，這N + 1個變數共享了同一塊記憶體區域。(參考型別的變數會占用記憶體空間，占用的記憶體空間的大小和指標型別的大小是相同的。雖然參考是一個物件的別名，但 ......

    uj5u.com 2020-09-10 01:00:22 more
  • 【C/C++編程筆記】從頭開始學習C ++：初學者完整指南

    眾所周知，C ++的學習曲線陡峭，但是花時間學習這種語言將為您的職業帶來奇跡，并使您與其他開發人員區分開。您會更輕松地學習新語言，形成真正的解決問題的技能，并在編程的基礎上打下堅實的基礎。 C ++將幫助您養成良好的編程習慣（即清晰一致的編碼風格，在撰寫代碼時注釋代碼，并限制類內部的可見性），并且由 ......

    uj5u.com 2020-09-10 01:00:41 more
最新发布
  • Rust中的智能指標:Box<T> Rc<T> Arc<T> Cell<T> RefCell<T> Weak

    Rust中的智能指標是什么 智能指標（smart pointers）是一類資料結構，是擁有資料所有權和額外功能的指標。是指標的進一步發展 指標（pointer）是一個包含記憶體地址的變數的通用概念。這個地址參考，或 ” 指向”（points at）一些其 他資料 。參考以 & 符號為標志并借用了他們所 ......

    uj5u.com 2023-04-20 07:24:10 more
  • Java的值傳遞和參考傳遞

    值傳遞不會改變本身，參考傳遞（如果傳遞的值需要實體化到堆里）如果發生修改了會改變本身。 1.基本資料型別都是值傳遞 package com.example.basic; public class Test { public static void main(String[] args) { int ......

    uj5u.com 2023-04-20 07:24:04 more
  • [2]SpinalHDL教程——Scala簡單入門

    第一個 Scala 程式 shell里面輸入 $ scala scala> 1 + 1 res0: Int = 2 scala> println("Hello World!") Hello World! 檔案形式 object HelloWorld { /* 這是我的第一個 Scala 程式 * 以 ......

    uj5u.com 2023-04-20 07:23:58 more
  • 理解函式指標和回呼函式

    理解 函式指標 指向函式的指標。比如： 理解函式指標的偽代碼 void (*p)(int type, char *data); // 定義一個函式指標p void func(int type, char *data); // 宣告一個函式func p = func; // 將指標p指向函式func ......

    uj5u.com 2023-04-20 07:23:52 more
  • Django筆記二十五之資料庫函式之日期函式

    本文首發于公眾號：Hunter后端 原文鏈接：Django筆記二十五之資料庫函式之日期函式 日期函式主要介紹兩個大類，Extract() 和 Trunc() Extract() 函式作用是提取日期，比如我們可以提取一個日期欄位的年份，月份，日等資料 Trunc() 的作用則是截取，比如 2022-0 ......

    uj5u.com 2023-04-20 07:23:45 more
  • 一天吃透JVM面試八股文

    什么是JVM？ JVM，全稱Java Virtual Machine（Java虛擬機），是通過在實際的計算機上仿真模擬各種計算機功能來實作的。由一套位元組碼指令集、一組暫存器、一個堆疊、一個垃圾回收堆和一個存盤方法域等組成。JVM屏蔽了與作業系統平臺相關的資訊，使得Java程式只需要生成在Java虛擬機 ......

    uj5u.com 2023-04-20 07:23:31 more
  • 使用Java接入小程式訂閱訊息！

    更新完微信服務號的模板訊息之后，我又趕緊把微信小程式的訂閱訊息給實作了！之前我一直以為微信小程式也是要企業才能申請，沒想到小程式個人就能申請。 訊息推送平臺🔥推送下發【郵件】【短信】【微信服務號】【微信小程式】【企業微信】【釘釘】等訊息型別。 https://gitee.com/zhongfuch ......

    uj5u.com 2023-04-20 07:22:59 more
  • java -- 緩沖流、轉換流、序列化流

    緩沖流 緩沖流, 也叫高效流, 按照資料型別分類： 位元組緩沖流：BufferedInputStream，BufferedOutputStream 字符緩沖流：BufferedReader，BufferedWriter 緩沖流的基本原理，是在創建流物件時，會創建一個內置的默認大小的緩沖區陣列，通過緩沖 ......

    uj5u.com 2023-04-20 07:22:49 more
  • Java-SpringBoot-Range請求頭設定實作視頻分段傳輸

    老實說，人太懶了，現在基本都不喜歡寫筆記了，但是網上有關Range請求頭的文章都太水了 下面是抄的一段StackOverflow的代碼...自己大修改過的，寫的注釋挺全的，應該直接看得懂，就不解釋了 寫的不好...只是希望能給視頻網站開發的新手一點點幫助吧. 業務場景：視頻分段傳輸、視頻多段傳輸（理 ......

    uj5u.com 2023-04-20 07:22:42 more
  • Windows 10開發教程_編程入門自學教程_菜鳥教程-免費教程分享

    教程簡介 Windows 10開發入門教程 - 從簡單的步驟了解Windows 10開發，從基本到高級概念，包括簡介，UWP，第一個應用程式，商店，XAML控制元件，資料系結，XAML性能，自適應設計，自適應UI，自適應代碼，檔案管理，SQLite資料庫，應用程式到應用程式通信，應用程式本地化，應用程式 ......

    uj5u.com 2023-04-20 07:22:35 more

Copyright © 2010-2020 有解無憂