2. 程式人生 > 實用技巧 >資料結構與演算法-排序

資料結構與演算法-排序

阿新 • • 發佈：2020-08-18

排序（不全以後補）

基數排序

原理：
https://www.jb51.net/article/129428.htm

package com.atguigu.sort;
import org.junit.Test;
import java.util.ArrayList;
import java.util.List;
/**
 * @anthor shkstart
 * @create 2020-08-16 15:03
 */
public class JSsort {
	@Test
	    public void test(){
		int[] array = {135,242,192,93,345,11,24,19};
		radixSort(array);
	}
	public void radixSort(int[] array){
		int max = array[0];
		for (int i=0;i<array.length;i++){
			//找到陣列中的最大值
			if(array[i]>max){
				max = array[i];
			}
		}
		int keysNum = 0;
		//關鍵字的個數，我們使用個位、十位、百位...當做關鍵字，所以關鍵字的個數就是最大值的位數
		while(max>0){
			max /= 10;
			keysNum++;
		}
		List<ArrayList<Integer>> buckets = new ArrayList<ArrayList<Integer>>();
		for (int i=0;i<10;i++){
			//每位可能的數字為0~9，所以設定10個桶
			buckets.add(new ArrayList<Integer>());
			//桶由ArrayList<Integer>構成
		}
		for (int i=0;i<keysNum;i++){
			//由最次關鍵字開始，依次按照關鍵字進行分配
			for (int j=0;j<array.length;j++){
				//掃描所有陣列元素，將元素分配到對應的桶中
				//取出該元素對應第i+1位上的數字，比如258，現在要取出十位上的數字，258%100=58,58/10=5
				int key =array[j]%(int)Math.pow(10, i+1)/(int)Math.pow(10, i);
				buckets.get(key).add(array[j]);
				//將該元素放入關鍵字為key的桶中
			}
			//分配完之後，將桶中的元素依次複製回陣列
			int counter = 0;
			//元素計數器
			for (int j=0;j<10;j++){
				ArrayList<Integer> bucket =buckets.get(j);
				//關鍵字為j的桶
				while(bucket.size()>0){
					array[counter++] = bucket.remove(0);
					//將桶中的第一個元素複製到陣列，並移除
				}
			}
			System.out.print("第"+(i+1)+"輪排序：");
			for (int n= 0;n < array.length;n++){
				System.out.print(array[n]+ "   ");
			}
			System.out.println();
		}
	}
}

快速排序

原理




不妨取首元素m = S[lo]作為候選，將其從向量中取出並做備份，騰出的空閒單元便於其它元素的位置調整。然後如圖(b)所示，不斷試圖移動lo和hi，使之相互靠攏。當然，整個移動過程中，需始終保證lo（hi）左側（右側）的元素均不大於（不小於）m。最後如圖(c)所示，當lo與hi彼此重合時，只需將原備份的m回填至這一位置，則S[lo = hi]=m便成為一個名副其實的軸點

package com.atguigu.sort;
import org.junit.Test;
/**
 * @anthor shkstart
 * @create 2020-08-16 15:03
 */
public class Quicksort {
	@Test
	    public void test() {
		int[] array = {135,242,192,93,345,11,24,19};
		this._elem = array;
		this.quickSort(0,8);
		for (int i = 0;i < 8;i++){
			System.out.print(this._elem[i] + "   ");
		}
	}
	public int[] _elem = new int[8];
	public void quickSort(int lo,int hi){
		if (hi - lo < 2) return;
		int mi = partition1(lo,hi - 1);
		quickSort(lo,mi);
		quickSort(mi+1,hi);
	}
	/**
     * 子任務規模接近在這裡卻無法保證
     * 若在最終有序向量中該候選元素的秩為r，則子向量的規模必為r和n - r - 1。
     * 特別地，r = 0時子向量規模分別為0和n - 1左側子向量為空，而右側子向量與原向量幾乎等長
     */
	public int partition1(int lo,int hi){
		swap(_elem[lo],_elem[(int) (lo + Math.random()*(100)%(hi - lo + 1))]);
		int pivot = _elem[lo];
		while (lo < hi){
			while ((lo < hi) && (pivot <= _elem[hi])){
				hi--;
			}
			_elem[lo] = _elem[hi];
			while ((lo < hi) && (_elem[lo] <= pivot)){
				lo++;
			}
			_elem[hi] = _elem[lo];
		}
		_elem[lo] = pivot;
		return lo;
	}
	public void swap(int a,int b){
		int c = a;
		a = b;
		b = c;
	}
	/**
     * 將交替地將右（左）側元素轉移至左（右）側，並最終恰好將軸點置於正中央的位置。
     * 這就意味著，退化的輸入向量能夠始終被均衡的切分，如此反而轉為最好情況，
     */
	public int partition2(int lo,int hi){
		swap(_elem[lo],_elem[(int) (lo + Math.random()*(100)%(hi - lo + 1))]);
		int pivot = _elem[lo];
		while (lo < hi){
			while ((lo < hi)){
				if (pivot < _elem[hi]){
					hi--;
				} else {
					_elem[lo++] = _elem[hi];
					break;
				}
			}
			while ((lo < hi)){
				if (pivot < _elem[hi]){
					lo++;
				} else {
					_elem[hi--] = _elem[lo];
					break;
				}
			}
		}
		_elem[lo] = pivot;
		return lo;
	}
}

實現


/**
     * 子任務規模接近在這裡卻無法保證
     * 若在最終有序向量中該候選元素的秩為r，則子向量的規模必為r和n - r - 1。
     * 特別地，r = 0時子向量規模分別為0和n - 1左側子向量為空，而右側子向量與原向量幾乎等長
     */
public int partition1(int lo,int hi){
	swap(_elem[lo],_elem[(int) (lo + Math.random()*(100)%(hi - lo + 1))]);
	int pivot = _elem[lo];
	while (lo < hi){
		while ((lo < hi) && (pivot <= _elem[hi])){
			hi--;
		}
		_elem[lo] = _elem[hi];
		while ((lo < hi) && (_elem[lo] <= pivot)){
			lo++;
		}
		_elem[hi] = _elem[lo];
	}
	_elem[lo] = pivot;
	return lo;
}
public void swap(int a,int b){
	int c = a;
	a = b;
	b = c;
}

例項

改進


考查所有（或幾乎所有）元素均重複的退化情況。partition()演算法的版本A對此類輸入的處理完全等效於此前所舉的最壞情況。事實上對於此類向量，主迴圈內部前一子迴圈的條件中“pivot <= elem[hi]”形同虛設，故該子迴圈將持續執行，直至“lo < hi”不再滿足

/**
     * 將交替地將右（左）側元素轉移至左（右）側，並最終恰好將軸點置於正中央的位置。
     * 這就意味著，退化的輸入向量能夠始終被均衡的切分，如此反而轉為最好情況，
     */
public int partition2(int lo,int hi){
	swap(_elem[lo],_elem[(int) (lo + Math.random()*(100)%(hi - lo + 1))]);
	int pivot = _elem[lo];
	while (lo < hi){
		while ((lo < hi)){
			if (pivot < _elem[hi]){
				hi--;
			} else {
				_elem[lo++] = _elem[hi];
				break;
			}
		}
		while ((lo < hi)){
			if (pivot < _elem[hi]){
				lo++;
			} else {
				_elem[hi--] = _elem[lo];
				break;
			}
		}
	}
	_elem[lo] = pivot;
	return lo;
}

選取與中位數

眾數

  • 原理



  • 實現
package com.atguigu.sort;
import org.junit.Test;
/**
 * @anthor shkstart
 * @create 2020-08-16 20:39
 */
public class allFind {
	@Test
	    public void test() {
		int[] array = {135,242,192,93,345,11,24,19,19,19,19,19};
		majority(array,0);
	}
	public int[] _elem = new int[8];
	public Boolean majority(int[] A,int maj){
		maj = majEleCandidate(A);
		System.out.println(maj);
		return majEleCheck(A,maj);
	}
	public Boolean majEleCheck(int[] A,int maj){
		int occurrence = 0;
		for (int i = 0;i < A.length;i++){
			if (A[i] == maj) occurrence++;
		}
		return (2*occurrence > A.length);
	}
	public int majEleCandidate(int[] A){
		int maj = 0;
		for (int c = 0,i = 0; i < A.length;i++){
			if (0 == c){
				maj = A[i];
				c = 1;
			} else {
				if (maj == A[i]) {
					c++;
				} else {
					c--;
				}
			}
		}
		return maj;
	}
}

中位數

蠻力演算法

/**
     * 蠻力演算法
     * @param s1
     * @param lo1
     * @param n1
     * @param s2
     * @param lo2
     * @param n2
     * @return
     */
public int trivialMedian(int[] s1,int lo1,int n1,int[] s2,int lo2,int n2){
	int hi1 = lo1 + n1,hi2 = lo2 + n2;
	Vector s = new Vector();
	while ((lo1 < hi1) && (lo2 < hi2)){
		while ((lo1 < hi1) && (s1[lo1] <= s2[lo2])) s.add(s1[lo1++]);
		if (lo1 == 8) break;
		//以免出現越界，可能換成向量不用寫這個
		while ((lo2 < hi2) && (s2[lo2] <= s1[lo1])) s.add(s2[lo2++]);
	}
	while (lo1 < hi1) s.add(s1[lo1++]);
	while (lo2 < hi2) s.add(s2[lo2++]);
	return (int) s.elementAt((n1 + n2 +1)/2);
}

兩個都為n


/**
     * 子串的長度相同
     * @param s1
     * @param lo1
     * @param s2
     * @param lo2
     * @param n
     * @return
     */
public int median1(int[] s1,int lo1,int[] s2,int lo2,int n){
	if (n < 3) return trivialMedian(s1,lo1,n,s2,lo2,n);
	int mi1 = lo1 + n / 2,mi2 = lo2 + (n - 1)/2;
	if (s1[mi1] < s2[mi2]){
		return median1(s1,mi1,s2,lo2,n + lo1 - mi1);
	} else if (s1[mi1] > s2[mi2]){
		return median1(s1,lo1,s2,mi2,n + lo2 -mi2);
	} else {
		return s1[mi1];
	}
}

一般情況


public int median2(int[] s1,int lo1,int n1,int[] s2,int lo2,int n2){
	if (n1 > n2) return median2(s2,lo2,n2,s1,lo1,n1);
	//因為下面僅針對n1 <= n2的情況在討論
	if (n2 < 6) //蠻力演算法
	return trivialMedian(s1,lo1,n1,s2,lo2,n2);
	if(2 * n1 < n2){
		//若兩個向量的長度相差懸殊，則長者（S2）的兩翼可直接截除
		return median2(s1,lo1,n1,s2,lo2 + (n2 - n1 -1)/2,n1 + 2 - (n2 -n1)%2);
		//這裡怎麼取兩邊的可以看一下
	}
	int mi1 = lo1 + n1/2;
	int mi2a = lo2 + (n1 - 1)/2;
	//這裡其實是保證擷取的左右平衡
	int mi2b = lo2 + n2 -1 - n1/2;
	if (s1[mi1] > s2[mi2b]){
		return median2(s1,lo1,n1/2 + 1,s2,mi2a,n2 - (n1 - 1)/2);
	} else if (s1[mi1] < s2[mi2a]){
		return median2(s1,mi1,(n1+1)/2,s2,lo2,n2 - n1/2);
	} else {
		return median2(s1,lo1,n1,s2,mi2a,n2 - (n1 - 1)/2 *2);
	}
}

總的

package com.atguigu.sort;
import org.junit.Test;
import java.util.Vector;
/**
 * @anthor shkstart
 * @create 2020-08-16 21:07
 */
public class middleFind {
	@Test
	    public void test(){
		int[] array1 = {1,2,3,4,5,6,7,8};
		int[] array2 = {9,10,11,12,13,14,15,16};
		System.out.println(trivialMedian(array1,0,8,array2,0,8));
	}
	/**
     * 蠻力演算法
     * @param s1
     * @param lo1
     * @param n1
     * @param s2
     * @param lo2
     * @param n2
     * @return
     */
	public int trivialMedian(int[] s1,int lo1,int n1,int[] s2,int lo2,int n2){
		int hi1 = lo1 + n1,hi2 = lo2 + n2;
		Vector s = new Vector();
		while ((lo1 < hi1) && (lo2 < hi2)){
			while ((lo1 < hi1) && (s1[lo1] <= s2[lo2])) s.add(s1[lo1++]);
			if (lo1 == 8) break;
			//以免出現越界，可能換成向量不用寫這個
			while ((lo2 < hi2) && (s2[lo2] <= s1[lo1])) s.add(s2[lo2++]);
		}
		while (lo1 < hi1) s.add(s1[lo1++]);
		while (lo2 < hi2) s.add(s2[lo2++]);
		return (int) s.elementAt((n1 + n2 +1)/2);
	}
	/**
     * 子串的長度相同
     * @param s1
     * @param lo1
     * @param s2
     * @param lo2
     * @param n
     * @return
     */
	public int median1(int[] s1,int lo1,int[] s2,int lo2,int n){
		if (n < 3) return trivialMedian(s1,lo1,n,s2,lo2,n);
		int mi1 = lo1 + n / 2,mi2 = lo2 + (n - 1)/2;
		if (s1[mi1] < s2[mi2]){
			return median1(s1,mi1,s2,lo2,n + lo1 - mi1);
		} else if (s1[mi1] > s2[mi2]){
			return median1(s1,lo1,s2,mi2,n + lo2 -mi2);
		} else {
			return s1[mi1];
		}
	}
	public int median2(int[] s1,int lo1,int n1,int[] s2,int lo2,int n2){
		if (n1 > n2) return median2(s2,lo2,n2,s1,lo1,n1);
		//因為下面僅針對n1 <= n2的情況在討論
		if (n2 < 6) //蠻力演算法
		return trivialMedian(s1,lo1,n1,s2,lo2,n2);
		if(2 * n1 < n2){
			//若兩個向量的長度相差懸殊，則長者（S2）的兩翼可直接截除
			return median2(s1,lo1,n1,s2,lo2 + (n2 - n1 -1)/2,n1 + 2 - (n2 -n1)%2);
			//這裡怎麼取兩邊的可以看一下
		}
		int mi1 = lo1 + n1/2;
		int mi2a = lo2 + (n1 - 1)/2;
		//這裡其實是保證擷取的左右平衡
		int mi2b = lo2 + n2 -1 - n1/2;
		if (s1[mi1] > s2[mi2b]){
			return median2(s1,lo1,n1/2 + 1,s2,mi2a,n2 - (n1 - 1)/2);
		} else if (s1[mi1] < s2[mi2a]){
			return median2(s1,mi1,(n1+1)/2,s2,lo2,n2 - n1/2);
		} else {
			return median2(s1,lo1,n1,s2,mi2a,n2 - (n1 - 1)/2 *2);
		}
	}
}

基於優先順序佇列


第一種演算法如圖(a1)所示。首先，花費O(n)時間將全體元素組織為一個小頂堆；然後，經
過k次delMin()操作，則如圖(a2)所示得到位序為k的元素

@Test
    public void test1() {
	Integer[] array = {135,242,192,93,345,11,24,19,19,19,19,19};
	PQ_CompHeap pq = new PQ_CompHeap(array,4);
	for (int i = 0;i < array.length;i++){
		pq.insert(array[array.length - 4 -1 + i]);
		pq.delMax();
	}
	System.out.println(pq.getMax());
}


任取k個元素，並在O(k)時間以內將其組織為大頂堆。然後將剩餘的n - k個元素逐個插入堆中；每插入一個，隨即刪除堆頂，以使堆的規模恢復為k。待所有元素處理完畢之後，堆頂即為目標元素

@Test
    public void test2() {
	Integer[] array = {135,242,192,93,345,11,24,19,19,19,19,19};
	PQ_CompHeap pq = new PQ_CompHeap(array,array.length);
	for (int i = 0;i < 6;i++){
		pq.delMin();
	}
	System.out.println(pq.getMin());
}


首先將全體元素分為兩組，分別構建一個規模為n - k的小頂堆G和一個規模為k的大頂堆H。接下來，反覆比較它們的堆頂g和h，只要g < h，則將二者交換，並重新調整兩個堆。如此，G的堆頂g將持續增大，H的堆頂h將持續減小。當g>=h時，h即為所要找的元素

@Test
    public void test3() {
	Integer[] array1 = {135,242,192,93,345,11,24,19,19,19,19,19};
	Integer[] array2 = new Integer[array1.length - 4];
	for (int i = 4;i < array1.length;i++){
		array2[i-4] = array1[i];
	}
	PQ_CompHeap pq1 = new PQ_CompHeap(array2,array1.length - 4);
	PQ_CompHeap pq2 = new PQ_CompHeap(array1,4);
	while (pq1.getMin() < pq2.getMax()){
		swap(pq1.getMin(),pq2.getMax());
	}
	System.out.println(pq2.getMax());
}
public void swap(Integer a,Integer b){
	Integer c = a;
	a = b;
	b = c;
}

基於快速劃分


呼叫演算法partition()構造向量A的一個軸點A[i] = x。若i =k，則該軸點恰好就是待選取的目標元素，即可直接將其返回；沒有的話，相應減去不可能包含的部分如L段、G段

K-選取演算法


package com.atguigu.sort;
import org.junit.Test;
import java.util.Vector;
/**
 * @anthor shkstart
 * @create 2020-08-18 8:34
 */
public class K_Find {
	@Test
	    public void test(){
		int[] array = {135,242,192,93,345,11,24,19};
	}
	public static int Q = 5;
	public int select(Vector A, int k){
		if (A.size() < Q){
			return trivialSelect(A,k);
		}
		Vector B = new Vector();
		int[] C = new int[Q];
		for (int i = 1;i <= A.size()/Q;i++){
			for (int j = (i-1) * Q;j < Q*i;j++){
				C[j - (i-1) * Q] =(int) A.elementAt((i-1) * Q);
			}
			sort(C);
			B.add(meddile(C));
		}
		int m = select(B,C.length/2);
		int i = 0;
		Vector l = new Vector();
		int e = 0;
		Vector g = new Vector();
		while (i < A.size()){
			if ((int)A.elementAt(i) < m){
				l.add((int)A.elementAt(i));
			} else if((int)A.elementAt(i) == m){
				e++;
			} else {
				g.add((int)A.elementAt(i));
			}
			i++;
		}
		if (l.size() >= k) {
			return select(l,k);
		} else if (l.size() + e >= k){
			return m;
		} else {
			return select(g,k - l.size() - e);
		}
	}
	public int trivialSelect(Vector A,int k){
		return 0;
	}
	public void sort(int[] A){
	}
	public int meddile(int[] A){
		return 0;
	}
}

希爾排序

原理



實現（感覺很難按上面的方式寫，先複製了一個，以後改）

package sortdemo;
import java.util.Arrays;
/**
 * Created by chengxiao on 2016/11/24.
 */
public class ShellSort {
	public static void main(String []args){
		int []arr ={1,4,2,7,9,8,3,6};
		sort(arr);
		System.out.println(Arrays.toString(arr));
		int []arr1 ={1,4,2,7,9,8,3,6};
		sort1(arr1);
		System.out.println(Arrays.toString(arr1));
	}
	/**
     * 希爾排序 針對有序序列在插入時採用交換法
     * @param arr
     */
	public static void sort(int []arr){
		//增量gap，並逐步縮小增量
		for (int gap=arr.length/2;gap>0;gap/=2){
			//從第gap個元素，逐個對其所在組進行直接插入排序操作
			for (int i=gap;i<arr.length;i++){
				int j = i;
				while(j-gap>=0 && arr[j]<arr[j-gap]){
					//插入排序採用交換法
					swap(arr,j,j-gap);
					j-=gap;
				}
			}
		}
	}
	/**
     * 希爾排序 針對有序序列在插入時採用移動法。
     * @param arr
     */
	public static void sort1(int []arr){
		//增量gap，並逐步縮小增量
		for (int gap=arr.length/2;gap>0;gap/=2){
			//從第gap個元素，逐個對其所在組進行直接插入排序操作
			for (int i=gap;i<arr.length;i++){
				int j = i;
				int temp = arr[j];
				if(arr[j]<arr[j-gap]){
					while(j-gap>=0 && temp<arr[j-gap]){
						//移動法
						arr[j] = arr[j-gap];
						j-=gap;
					}
					arr[j] = temp;
				}
			}
		}
	}
	/**
     * 交換陣列元素
     * @param arr
     * @param a
     * @param b
     */
	public static void swap(int []arr,int a,int b){
		arr[a] = arr[a]+arr[b];
		arr[b] = arr[a]-arr[b];
		arr[a] = arr[a]-arr[b];
	}
}

改進



相關推薦

資料結構與演算法--排序

author:phaethonWB e-mail:[email protected] 排序與搜尋 排序演算法（英語：Sorting algorithm）是一種能將一串資料依照特定順序進行排列的一種演算法。

資料結構與演算法-排序

排序（不全以後補） 基數排序 原理： https://www.jb51.net/article/129428.htm package com.atguigu.sort;

資料結構與演算法-排序-選擇排序(2)

技術標籤：資料結構和演算法資料結構演算法排序演算法 選擇排序簡介 簡單選擇排序是最簡單直觀的一種演算法，基本思想為每一趟從待排序的資料元素中選擇最小（或最大）的一個元素作為首元素，直到所有元素排完為

資料結構與演算法 - 排序1 氣泡排序

技術標籤：Java演算法資料結構與演算法資料結構排序演算法java演算法 public class BubbleSort {

資料結構與演算法——排序演算法-選擇排序

基本介紹 選擇排序（select sorting）也屬於內部排序法，是從欲排序的資料中，按指定的規則選出來某個元素，再依規定交換位置後達到排序的目的。

資料結構與演算法——排序演算法-歸併排序

目錄簡單介紹基本思想思路分析程式碼實現對程式碼的一些改進大資料量耗時測試複雜度

Java資料結構與演算法之快速排序、歸併排序

7. 快速排序 7.1 快速排序思路 快速排序的基本思想是任取待排序序列的一個元素作為中心元素(可以用第一個，最後一個，也可以是中間任何一個)，習慣將其稱為pivot，樞軸元素；

資料結構與演算法（十二）：堆排序

一、什麼是堆排序 1.概述 堆排序是利用堆這種資料結構而設計的一種排序演算法，堆排序是一種選擇排序，它的最壞，最好，平均時間複雜度均為O(nlogn)，它也是不穩定排序。

資料結構與演算法（18）——歸併排序

歸併排序 演算法處理思路：將資料表持續分裂成兩半，對兩半分別進行歸併排序。可以用遞迴的思想解決。

資料結構與演算法（19）——快速排序

快速排序 思想：依據一箇中值資料項，把資料表分成兩半：小於中值的一半和大於中值的一半，然後把每部分分別進行快速排序(遞迴)。

2-資料結構與演算法-二叉樹和排序二叉樹

二叉樹 根節點 柱狀結構最上層的一個節點 葉子節點 左葉子節點 右葉子節點 完整的子樹

資料結構與演算法-二叉樹和排序二叉樹

二叉樹 根節點 柱狀結構最上層的一個節點 葉子節點 左葉子節點 右葉子節點 完整的子樹

資料結構與演算法複習（二）插入排序

演算法描述： 　　插入排序將陣列分成有序和無序兩個部分，每次排序選擇無序部分的第一個元素與有序部分從後到前比較，找到適當位置插入。插入排序是一種穩定排序。

資料結構與演算法複習（一）快速排序

快速排序的步驟是：1、在陣列中任意選擇一個元素，稱為軸值2、掃描陣列，將大於等於軸值的元素放到軸的右邊，將小於軸值的元素放到軸的左邊；固定軸的位置不動，於是，陣列被分為大於軸值和小於軸值的兩個部分4、對軸

《戀上資料結構與演算法》筆記1-排序

排序演算法： #include <iostream> //氣泡排序 void bubbleSort(int array[],int size){ std::cout << \"array= \" << array << std::endl;

資料結構與演算法-歸併排序

　　歸併排序的核心思想是使用分治的策略來進行排序。分治是將大問題分成一些小問題，小問題解決後在合併在一起。

資料結構與演算法複習（三）歸併排序

歸併排序的思想是：將兩個有序的子序列通過歸併得到一個大的子序列實現序列有序化演算法實現過程如下：1、將陣列劃分為一個個最小的子序列，即每個子序列只有一個元素2、將最小的子序列兩兩歸併得到大的子序列3、遞迴

《資料結構與演算法之美》筆記 11 | 排序(上)：為什麼插入排序比氣泡排序更受歡迎？

排序演算法 章 節 排序演算法 時間複雜度 是否基於比較 11 冒泡、插入、選擇 O(n^2)

Java資料結構與演算法（二）--簡單排序

目錄 1.氣泡排序 2.選擇排序 3.插入排序 4.總結 為了對大量的資料進行檢索，需要對資料進行排序，就像上章講的，二分查詢要快於迭代查詢。

資料結構與演算法習題總結——查詢與排序演算法

本篇為Datawhale程式設計實踐專案的學習筆記，會隨著學習程序不斷更新，題目都借鑑自網路或書籍，僅用作個人學習。由於水平實在有限，不免產生謬誤，歡迎讀者多多批評指正。如需要轉載請與博主聯絡，謝謝