vue: 元件之間傳值
阿新 • • 發佈：2020-09-21
1 1.氣泡排序 2 時間複雜度：O(n²) 3 氣泡排序演算法的運作如下：（從後往前） 4 1)比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。 5 2)對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對。在這一點，最後的元素應該會是最大的數。 6 3)針對所有的元素重複以上的步驟，除了最後一個。 7 4)持續每次對越來越少的元素重複上面的步驟，直到沒有任何一對數字需要比較。 8 程式碼實現： 9 10 package cn.lpq.sort; 11 12 public class BubbleSort { 13 publicstatic void main(String[] args) { 14 System.out.println("排序前："); 15 int[] arr={51, 46, 20, 18, 65, 97, 82, 30, 77, 50,2,33,12,100 }; 16 printSort(arr); 17 System.out.println("排序後："); 18 bubbleSort(arr); 19 printSort(arr); 20 21 } 22 publicstatic void bubbleSort(int[]arr){ 23 for(int x=0;x<arr.length-1;x++){ 24 for(int y=0;y<arr.length-1-x;y++){ 25 if(arr[y]>arr[y+1]){ 26 int temp=arr[y]; 27 arr[y]=arr[y+1]; 28 arr[y+1]=temp;29 } 30 } 31 32 } 33 } 34 public static void printSort(int []arr){ 35 StringBuilder res=new StringBuilder(); 36 res.append("["); 37 for(int i=0;i<arr.length;i++){ 38 if(i==arr.length-1) 39 res.append(arr[i]+"]"); 40 else 41 res.append(arr[i]+","); 42 } 43 System.out.println(res.toString()); 44 } 45 } 46 1 47 2 48 3 49 4 50 5 51 6 52 7 53 8 54 9 55 10 56 11 57 12 58 13 59 14 60 15 61 16 62 17 63 18 64 19 65 20 66 21 67 22 68 23 69 24 70 25 71 26 72 27 73 28 74 29 75 30 76 31 77 32 78 33 79 34 80 35 81 36 82 37 83 結果： 84 氣泡排序結果 85 2.選擇排序： 86 時間複雜度：O(n²) 87 選擇排序（Selection sort）同樣也是最經典最簡單的排序演算法之一，特點就是簡單直觀。 88 排序的原理：首先在未排序的序列裡找到最小(大)元素，放到序列的首端，再從剩餘元素中找到最小(大)的元素，放到序列的尾端。依次迴圈，直到排序完成。 89 程式碼實現： 90 91 package cn.lpq.sort; 92 93 public class SelectSort { 94 public static void main(String[] args) { 95 int[] arr={11,9,3,44,12,98,292,34,522,232}; 96 System.out.println("選擇排序前："); 97 printSort(arr); 98 selectSort(arr); 99 System.out.println("選擇排序後："); 100 printSort(arr); 101 } 102 public static void selectSort(int[]arr){ 103 for(int x=0;x<arr.length-1;x++){ 104 for(int y=x+1;y<arr.length;y++){ 105 if(arr[x]>arr[y]){ 106 int temp=arr[y]; 107 arr[y]=arr[x]; 108 arr[x]=temp; 109 110 } 111 } 112 113 } 114 } 115 public static void printSort(int []arr){ 116 StringBuilder res=new StringBuilder(); 117 res.append("["); 118 for(int i=0;i<arr.length;i++){ 119 if(i==arr.length-1) 120 res.append(arr[i]+"]"); 121 else 122 res.append(arr[i]+","); 123 } 124 System.out.println(res.toString()); 125 } 126 } 127 1 128 2 129 3 130 4 131 5 132 6 133 7 134 8 135 9 136 10 137 11 138 12 139 13 140 14 141 15 142 16 143 17 144 18 145 19 146 20 147 21 148 22 149 23 150 24 151 25 152 26 153 27 154 28 155 29 156 30 157 31 158 32 159 33 160 34 161 35 162 36 163 37 164 結果： 165 選擇排序結果 166 167 3.快速排序： 168 快排思想： 169 快速排序的原理：選擇一個關鍵值作為基準值。比基準值小的都在左邊序列（一般是無序的），比基準值大的都在右邊（一般是無序的）。一般選擇序列的第一個元素。 170 一次迴圈：從後往前比較，用基準值和最後一個值比較，如果比基準值小的交換位置，如果沒有繼續比較下一個，直到找到第一個比基準值小的值才交換。找到這個值之後，又從前往後開始比較，如果有比基準值大的，交換位置，如果沒有繼續比較下一個，直到找到第一個比基準值大的值才交換。直到從前往後的比較索引>從後往前比較的索引，結束第一次迴圈，此時，對於基準值來說，左右兩邊就是有序的了，接著分別比較左右兩邊的序列，重複上述的迴圈。 171 時間複雜度為：nlog(n) 172 173 package cn.dataStructures.Sort; 174 //快速排序演算法--利用遞迴 175 public class QuickSort { 176 public static void main(String[] args) { 177 int []arr={12,20,5,16,15,1,2,100,30,45,23,9}; 178 int low=0; 179 int high=arr.length-1; 180 quickSort(arr,low,high); 181 printSortArr(arr); 182 } 183 public static void quickSort(int [] arr,int low,int high){ 184 int start=low;//設定可以移動的最小值 185 int end=high;//設定可以移動的最大值 186 int key=arr[low];//設定標識 187 while(start<end){//整體大迴圈 188 while(start<end&&arr[end]>=key)//先從迴圈後面的，從後向前，找小於key的 189 end--; 190 if(arr[end]<=key){ 191 int temp=arr[end]; 192 arr[end]=arr[start]; 193 arr[start]=temp; 194 } 195 while(start<end&&arr[start]<=key)//迴圈前面的，從前往後找大於key的值 196 start++; 197 if(arr[start]>=key){ 198 int temp=arr[start]; 199 arr[start]=arr[end]; 200 arr[end]=temp; 201 } 202 } 203 //遞迴呼叫 204 if(low<start) 205 quickSort(arr,low,start-1); 206 if(end<high) 207 quickSort(arr,end+1,high); 208 209 }//列印輸出陣列 210 public static void printSortArr(int []arr){ 211 StringBuilder res=new StringBuilder(); 212 res.append("["); 213 for(int i=0;i<arr.length;i++){ 214 if(i==arr.length-1){ 215 res.append(arr[i]+"]"); 216 } 217 else{ 218 res.append(arr[i]+","); 219 } 220 } 221 System.out.println(res.toString()); 222 } 223 } 224 1 225 2 226 3 227 4 228 5 229 6 230 7 231 8 232 9 233 10 234 11 235 12 236 13 237 14 238 15 239 16 240 17 241 18 242 19 243 20 244 21 245 22 246 23 247 24 248 25 249 26 250 27 251 28 252 29 253 30 254 31 255 32 256 33 257 34 258 35 259 36 260 37 261 38 262 39 263 40 264 41 265 42 266 43 267 44 268 45 269 46 270 47 271 48 272 49 273 50 274 51 275 52 276 結果： 277 快速排序結果 278 4.歸併排序： 279 時間複雜度為：nlog(n) 280 排序原理： 281 （1）申請空間，使其大小為兩個已經排序序列之和，該空間用來存放合併後的序列 282 （2）設定兩個指標，最初位置分別為兩個已經排序序列的起始位置 283 （3）比較兩個指標所指向的元素，選擇相對小的元素放入到合併空間，並移動指標到下一位置 284 （4）重複步驟3直到某一指標達到序列尾 285 （5）將另一序列剩下的所有元素直接複製到合併序列尾 286 287 package cn.dataStructures.Sort; 288 289 /** 290 * **歸併排序（理解描述）**: 291 * 思想： 292 * 1.對原始序列arr進行一半分割，設定原始序列的第一個索引low和最後一個索引值high，並建立臨時序列 293 * 2.求出原始序列的中間索引mid=(low+high)/2，根據mid對序列分割 294 * 3.判斷low是否小於high，滿足則遞迴呼叫步驟1和2，一直對分割的序列再分割，直到剩餘一個元素為止 295 * 4.對分割的序列分別根據其索引指向的元素值進行比較，小的則放入臨時序列中，各序列索引加1、、 296 * 5.對剩餘沒有加入到臨時序列中的元素直接新增到臨時序列的最後的位置 297 * 6.將臨時序列賦值給原始序列，此時原始序列就是已經排好序的序列 298 * @author lpq 299 * 300 */ 301 302 public class MergeSort { 303 public static void main(String[] args) { 304 System.out.println("排序前："); 305 int[] arr={51, 46, 20, 18, 65, 97, 82, 30, 77, 50 }; 306 printSort(arr); 307 mergeSort(arr,0,arr.length-1); 308 System.out.println("排序後："); 309 printSort(arr); 310 } 311 //切分原始陣列 312 public static void mergeSort(int[]arr,int low,int high){ 313 int mid=(low+high)/2;//將序列按中間分開 314 315 if(low<high){ 316 //分開左邊 317 mergeSort(arr,low,mid); 318 //右半邊 319 mergeSort(arr,mid+1,high); 320 //將左右已經排序好的合併 321 merge(arr,low,mid,high); 322 } 323 324 325 } 326 public static void merge(int[]arr,int low,int mid,int high){ 327 /** 328 * 這裡的start和end分別是左半邊序列和右半邊序列的其實指標，分別指向各半邊序列的第一個位置，隨著的元素的比較而發生改變 329 * 而low和high是不發生改變的，一般來說low指的是序列的第一個索引0即low=0，high=arr.lenth-1, 330 * low和length值不發生改變 331 */ 332 //臨時陣列（序列） 333 int [] temp=new int[high-low+1]; 334 //左半邊序列的指標（一般指向第一個位置low） 335 int start=low; 336 //右半邊序列的指標 337 int end=mid+1; 338 //臨時陣列序列的索引 339 int k=0; 340 //把小的元素加入到臨時陣列中 341 while(start<=mid&&end<=high){ 342 if(arr[start]<arr[end]) 343 temp[k++]=arr[start++]; 344 else 345 temp[k++]=arr[end++]; 346 } 347 //把左邊剩餘元素加入到臨時陣列的後面 348 while(start<=mid)//這裡不能用if判斷，因為if只能判斷一次，while只要滿足條件就會一直迴圈判斷下去 349 temp[k++]=arr[start++]; 350 //把右半邊剩餘元素加入到臨時陣列的後面 351 while(end<=high) 352 temp[k++]=arr[end++]; 353 //將排序好的臨時陣列複製給原始陣列arr 354 for(int i=0;i<temp.length;i++){ 355 arr[i+low]=temp[i]; 356 } 357 } 358 public static void printSort(int []arr){ 359 StringBuilder res=new StringBuilder(); 360 res.append("["); 361 for(int i=0;i<arr.length;i++){ 362 if(i==arr.length-1) 363 res.append(arr[i]+"]"); 364 else 365 res.append(arr[i]+","); 366 } 367 System.out.println(res.toString()); 368 } 369 } 370 371 1 372 2 373 3 374 4 375 5 376 6 377 7 378 8 379 9 380 10 381 11 382 12 383 13 384 14 385 15 386 16 387 17 388 18 389 19 390 20 391 21 392 22 393 23 394 24 395 25 396 26 397 27 398 28 399 29 400 30 401 31 402 32 403 33 404 34 405 35 406 36 407 37 408 38 409 39 410 40 411 41 412 42 413 43 414 44 415 45 416 46 417 47 418 48 419 49 420 50 421 51 422 52 423 53 424 54 425 55 426 56 427 57 428 58 429 59 430 60 431 61 432 62 433 63 434 64 435 65 436 66 437 67 438 68 439 69 440 70 441 71 442 72 443 73 444 74 445 75 446 76 447 77 448 78 449 79 450 80 451 81 452 82 453 83 454 84 455 85 456 結果： 457 歸併排序結果 458 時間複雜度分析: 459 遞迴法分析： 460 因為歸併排序實現要將原始序列分為2部分，然後將這2個序列排序好後再賦值給臨時序列temp，假設原始序列的元素個數為N，則時間複雜度的主要表示式為：T(N)=2T(N/2)+N; 461 1.首先將N/2帶入主要表示式。結果：2T(N/2)=2(2T(N/4))+N=4T(N/4)+N,根據主要表示式可知：2T(N/2)=T(N)-N,所以可簡化為：T（N）=4T(N/4)+2N 462 2.將N/4帶入主表示式，同理可得到：T(N)=8T(N/8)+3N,可類比為：T(N)=2^kT(N/2^k)+kN 463 3.利用k=log(N),可得T(N)=NT(1)+Nlog(N)=Nlog(N)+N 464 4.時間複雜度為：O(Nlog(N)) 465 二分搜尋法： 466 二分查詢也稱折半查詢（Binary Search），它是一種效率較高的查詢方法。但是，折半查詢要求線性表必須採用順序儲存結構，而且表中元素按關鍵字有序排列。 467 注意：二分查詢前提條件是：該序列有序 468 469 package cn.lpq.sort; 470 471 import java.util.Arrays; 472 473 //二分查詢前提是該陣列有序 474 public class BinarySerch { 475 public static void main(String[] args) { 476 int []arr={11,22,33,44,55,66,77}; 477 Arrays.sort(arr);//對陣列排序 478 System.out.println(binarySerch(arr,55)); 479 } 480 public static int binarySerch(int[]arr,int value){ 481 int min=0; 482 int max=arr.length-1; 483 int mid=(min+max)/2; 484 while(arr[mid]!=value){ 485 if(arr[mid]>value){ 486 max=mid-1; 487 } 488 else if(arr[mid]<value){ 489 min=mid+1; 490 } 491 mid=(min+max)/2; 492 } 493 if(min>max){ 494 return -1;//說明陣列為空或所查詢元素不存在 495 } 496 return mid; 497 498 } 499 }