struct
Posted C# java C++ 开源通信
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了struct相关的知识，希望对你有一定的参考价值。
1 struct QSortStack { 2 public int high; 3 public int low; 4 }
1 QSortStack* stack = stackalloc QSortStack [32];
1 unsafe static void qsort<T, U> (T[] keys, U[] items, int low0, int high0) where T : IComparable<T> 2 { 3 QSortStack* stack = stackalloc QSortStack [32]; 4 const int QSORT_THRESHOLD = 7; 5 int high, low, mid, i, k; 6 int sp = 1; 7 T key; 8 9 // initialize our stack 10 stack[0].high = high0; 11 stack[0].low = low0; 12 13 do { 14 // pop the stack 15 sp--; 16 high = stack[sp].high; 17 low = stack[sp].low; 18 19 if ((low + QSORT_THRESHOLD) > high) { 20 // switch to insertion sort 21 for (i = low + 1; i <= high; i++) { 22 for (k = i; k > low; k--) { 23 // if keys[k] >= keys[k-1], break 24 if (keys[k-1] == null) 25 break; 26 27 if (keys[k] != null && keys[k].CompareTo (keys[k-1]) >= 0) 28 break; 29 30 swap (keys, items, k - 1, k); 31 } 32 } 33 34 continue; 35 } 36 37 // calculate the middle element 38 mid = low + ((high - low) / 2); 39 40 // once we re-order the lo, mid, and hi elements to be in 41 // ascending order, we‘ll use mid as our pivot. 42 QSortArrange<T, U> (keys, items, low, mid); 43 if (QSortArrange<T, U> (keys, items, mid, high)) 44 QSortArrange<T, U> (keys, items, low, mid); 45 46 key = keys[mid]; 47 48 // since we‘ve already guaranteed that lo <= mid and mid <= hi, 49 // we can skip comparing them again 50 k = high - 1; 51 i = low + 1; 52 53 do { 54 if (key != null) { 55 // find the first element with a value >= pivot value 56 while (i < k && key.CompareTo (keys[i]) > 0) 57 i++; 58 59 // find the last element with a value <= pivot value 60 while (k > i && key.CompareTo (keys[k]) < 0) 61 k--; 62 } else { 63 while (i < k && keys[i] == null) 64 i++; 65 66 while (k > i && keys[k] != null) 67 k--; 68 } 69 70 if (k <= i) 71 break; 72 73 swap (keys, items, i, k); 74 75 i++; 76 k--; 77 } while (true); 78 79 // push our partitions onto the stack, largest first 80 // (to make sure we don‘t run out of stack space) 81 if ((high - k) >= (k - low)) { 82 if ((k + 1) < high) { 83 stack[sp].high = high; 84 stack[sp].low = k; 85 sp++; 86 } 87 88 if ((k - 1) > low) { 89 stack[sp].high = k; 90 stack[sp].low = low; 91 sp++; 92 } 93 } else { 94 if ((k - 1) > low) { 95 stack[sp].high = k; 96 stack[sp].low = low; 97 sp++; 98 } 99 100 if ((k + 1) < high) { 101 stack[sp].high = high; 102 stack[sp].low = k; 103 sp++; 104 } 105 } 106 } while (sp > 0); 107 } 108 109 // Specialized version for items==null 110 unsafe static void qsort<T> (T[] keys, int low0, int high0) where T : IComparable<T> 111 { 112 QSortStack* stack = stackalloc QSortStack [32]; 113 const int QSORT_THRESHOLD = 7; 114 int high, low, mid, i, k; 115 int sp = 1; 116 T key; 117 118 // initialize our stack 119 stack[0].high = high0; 120 stack[0].low = low0; 121 122 do { 123 // pop the stack 124 sp--; 125 high = stack[sp].high; 126 low = stack[sp].low; 127 128 if ((low + QSORT_THRESHOLD) > high) { 129 // switch to insertion sort 130 for (i = low + 1; i <= high; i++) { 131 for (k = i; k > low; k--) { 132 // if keys[k] >= keys[k-1], break 133 if (keys[k-1] == null) 134 break; 135 136 if (keys[k] != null && keys[k].CompareTo (keys[k-1]) >= 0) 137 break; 138 139 swap (keys, k - 1, k); 140 } 141 } 142 143 continue; 144 } 145 146 // calculate the middle element 147 mid = low + ((high - low) / 2); 148 149 // once we re-order the lo, mid, and hi elements to be in 150 // ascending order, we‘ll use mid as our pivot. 151 QSortArrange<T> (keys, low, mid); 152 if (QSortArrange<T> (keys, mid, high)) 153 QSortArrange<T> (keys, low, mid); 154 155 key = keys[mid]; 156 157 // since we‘ve already guaranteed that lo <= mid and mid <= hi, 158 // we can skip comparing them again 159 k = high - 1; 160 i = low + 1; 161 162 do { 163 if (key != null) { 164 // find the first element with a value >= pivot value 165 while (i < k && key.CompareTo (keys[i]) > 0) 166 i++; 167 168 // find the last element with a value <= pivot value 169 while (k >= i && key.CompareTo (keys[k]) < 0) 170 k--; 171 } else { 172 while (i < k && keys[i] == null) 173 i++; 174 175 while (k >= i && keys[k] != null) 176 k--; 177 } 178 179 if (k <= i) 180 break; 181 182 swap (keys, i, k); 183 184 i++; 185 k--; 186 } while (true); 187 188 // push our partitions onto the stack, largest first 189 // (to make sure we don‘t run out of stack space) 190 if ((high - k) >= (k - low)) { 191 if ((k + 1) < high) { 192 stack[sp].high = high; 193 stack[sp].low = k; 194 sp++; 195 } 196 197 if ((k - 1) > low) { 198 stack[sp].high = k; 199 stack[sp].low = low; 200 sp++; 201 } 202 } else { 203 if ((k - 1) > low) { 204 stack[sp].high = k; 205 stack[sp].low = low; 206 sp++; 207 } 208 209 if ((k + 1) < high) { 210 stack[sp].high = high; 211 stack[sp].low = k; 212 sp++; 213 } 214 } 215 } while (sp > 0); 216 } 217 218 static bool QSortArrange<K, V> (K [] keys, V [] items, int lo, int hi, IComparer<K> comparer) 219 { 220 IComparable<K> gcmp; 221 IComparable cmp; 222 223 if (comparer != null) { 224 if (comparer.Compare (keys[hi], keys[lo]) < 0) { 225 swap<K, V> (keys, items, lo, hi); 226 return true; 227 } 228 } else if (keys[lo] != null) { 229 if (keys[hi] == null) { 230 swap<K, V> (keys, items, lo, hi); 231 return true; 232 } 233 234 gcmp = keys[hi] as IComparable<K>; 235 if (gcmp != null) { 236 if (gcmp.CompareTo (keys[lo]) < 0) { 237 swap<K, V> (keys, items, lo, hi); 238 return true; 239 } 240 241 return false; 242 } 243 244 cmp = keys[hi] as IComparable; 245 if (cmp != null) { 246 if (cmp.CompareTo (keys[lo]) < 0) { 247 swap<K, V> (keys, items, lo, hi); 248 return true; 249 } 250 251 return false; 252 } 253 } 254 255 return false; 256 } 257 258 // Specialized version for items==null 259 static bool QSortArrange<K> (K [] keys, int lo, int hi, IComparer<K> comparer) 260 { 261 IComparable<K> gcmp; 262 IComparable cmp; 263 264 if (comparer != null) { 265 if (comparer.Compare (keys[hi], keys[lo]) < 0) { 266 swap<K> (keys, lo, hi); 267 return true; 268 } 269 } else if (keys[lo] != null) { 270 if (keys[hi] == null) { 271 swap<K> (keys, lo, hi); 272 return true; 273 } 274 275 gcmp = keys[hi] as IComparable<K>; 276 if (gcmp != null) { 277 if (gcmp.CompareTo (keys[lo]) < 0) { 278 swap<K> (keys, lo, hi); 279 return true; 280 } 281 282 return false; 283 } 284 285 cmp = keys[hi] as IComparable; 286 if (cmp != null) { 287 if (cmp.CompareTo (keys[lo]) < 0) { 288 swap<K> (keys, lo, hi); 289 return true; 290 } 291 292 return false; 293 } 294 } 295 296 return false; 297 } 298 299 unsafe static void qsort<K, V> (K [] keys, V [] items, int low0, int high0, IComparer<K> comparer) 300 { 301 QSortStack* stack = stackalloc QSortStack [32]; 302 const int QSORT_THRESHOLD = 7; 303 int high, low, mid, i, k; 304 IComparable<K> gcmp; 305 IComparable cmp; 306 int sp = 1; 307 K key; 308 309 // initialize our stack 310 stack[0].high = high0; 311 stack[0].low = low0; 312 313 do { 314 // pop the stack 315 sp--; 316 high = stack[sp].high; 317 low = stack[sp].low; 318 319 if ((low + QSORT_THRESHOLD) > high) { 320 // switch to insertion sort 321 for (i = low + 1; i <= high; i++) { 322 for (k = i; k > low; k--) { 323 // if keys[k] >= keys[k-1], break 324 if (comparer != null) { 325 if (comparer.Compare (keys[k], keys[k-1]) >= 0) 326 break; 327 } else { 328 if (keys[k-1] == null) 329 break; 330 331 if (keys[k] != null) { 332 gcmp = keys[k] as IComparable<K>; 333 cmp = keys[k] as IComparable; 334 if (gcmp != null) { 335 if (gcmp.CompareTo (keys[k-1]) >= 0) 336 break; 337 } else { 338 if (cmp.CompareTo (keys[k-1]) >= 0) 339 break; 340 } 341 } 342 } 343 344 swap<K, V> (keys, items, k - 1, k); 345 } 346 } 347 348 continue; 349 } 350 351 // calculate the middle element 352 mid = low + ((high - low) / 2); 353 354 // once we re-order the low, mid, and high elements to be in 355 // ascending order, we‘ll use mid as our pivot. 356 QSortArrange<K, V> (keys, items, low, mid, comparer); 357 if (QSortArrange<K, V> (keys, items, mid, high, comparer)) 358 QSortArrange<K, V> (keys, items, low, mid, comparer); 359 360 key = keys[mid]; 361 gcmp = key as IComparable<K>; 362 cmp = key as IComparable; 363 364 // since we‘ve already guaranteed that lo <= mid and mid <= hi, 365 // we can skip comparing them again. 366 k = high - 1; 367 i = low + 1; 368 369 do { 370 // Move the walls in 371 if (comparer != null) { 372 // find the first element with a value >= pivot value 373 while (i < k && comparer.Compare (key, keys[i]) > 0) 374 i++; 375 376 // find the last element with a value <= pivot value 377 while (k > i && comparer.Compare (key, keys[k]) < 0) 378 k--; 379 } else { 380 if (gcmp != null) { 381 // find the first element with a value >= pivot value 382 while (i < k && gcmp.CompareTo (keys[i]) > 0) 383 i++; 384 385 // find the last element with a value <= pivot value 386 while (k > i && gcmp.CompareTo (keys[k]) < 0) 387 k--; 388 } else if (cmp != null) { 389 // find the first element with a value >= pivot value 390 while (i < k && cmp.CompareTo (keys[i]) > 0) 391 i++; 392 393 // find the last element with a value <= pivot value 394 while (k > i && cmp.CompareTo (keys[k]) < 0) 395 k--; 396 } else { 397 while (i < k && keys[i] == null) 398 i++; 399 400 while (k > i && keys[k] != null) 401 k--; 402 } 403 } 404 405 if (k <= i) 406 break; 407 408 swap<K, V> (keys, items, i, k); 409 410 i++; 411 k--; 412 } while (true); 413 414 // push our partitions onto the stack, largest first 415 // (to make sure we don‘t run out of stack space) 416 if ((high - k) >= (k - low)) { 417 if ((k + 1) < high) { 418 stack[sp].high = high; 419 stack[sp].low = k; 420 sp++; 421 } 422 423 if ((k - 1) > low) { 424 stack[sp].high = k; 425 stack[sp].low = low; 426 sp++; 427 } 428 } else { 429 if ((k - 1) > low) { 430 stack[sp].high = k; 431 stack[sp].low = low; 432 sp++; 433 } 434 435 if ((k + 1) < high) { 436 stack[sp].high = high; 437 stack[sp].low = k; 438 sp++; 439 } 440 } 441 } while (sp > 0); 442 } 443 444 // Specialized version for items==null 445 unsafe static void qsort<K> (K [] keys, int low0, int high0, IComparer<K> comparer) 446 { 447 QSortStack* stack = stackalloc QSortStack [32]; 448 const int QSORT_THRESHOLD = 7; 449 int high, low, mid, i, k; 450 IComparable<K> gcmp; 451 IComparable cmp; 452 int sp = 1; 453 K key; 454 455 // initialize our stack 456 stack[0].high = high0; 457 stack[0].low = low0; 458 459 do { 460 // pop the stack 461 sp--; 462 high = stack[sp].high; 463 low = stack[sp].low; 464 465 if ((low + QSORT_THRESHOLD) > high) { 466 // switch to insertion sort 467 for (i = low + 1; i <= high; i++) { 468 for (k = i; k > low; k--) { 469 // if keys[k] >= keys[k-1], break 470 if (comparer != null) { 471 if (comparer.Compare (keys[k], keys[k-1]) >= 0) 472 break; 473 } else { 474 if (keys[k-1] == null) 475 break; 476 477 if (keys[k] != null) { 478 gcmp = keys[k] as IComparable<K>; 479 cmp = keys[k] as IComparable; 480 if (gcmp != null) { 481 if (gcmp.CompareTo (keys[k-1]) >= 0) 482 break; 483 } else { 484 if (cmp.CompareTo (keys[k-1]) >= 0) 485 break; 486 } 487 } 488 } 489 490 swap<K> (keys, k - 1, k); 491 } 492 } 493 494 continue; 495 } 496 497 // calculate the middle element 498 mid = low + ((high - low) / 2); 499 500 // once we re-order the low, mid, and high elements to be in 501 // ascending order, we‘ll use mid as our pivot. 502 QSortArrange<K> (keys, low, mid, comparer); 503 if (QSortArrange<K> (keys, mid, high, comparer)) 504 QSortArrange<K> (keys, low, mid, comparer); 505 506 key = keys[mid]; 507 gcmp = key as IComparable<K>; 508 cmp = key as IComparable; 509 510 // since we‘ve already guaranteed that lo <= mid and mid <= hi, 511 // we can skip comparing them again. 512 k = high - 1; 513 i = low + 1; 514 515 do { 516 // Move the walls in 517 if (comparer != null) { 518 // find the first element with a value >= pivot value 519 while (i < k && comparer.Compare (key, keys[i]) > 0) 520 i++; 521 522 // find the last element with a value <= pivot value 523 while (k > i && comparer.Compare (key, keys[k]) < 0) 524 k--; 525 } else { 526 if (gcmp != null) { 527 // find the first element with a value >= pivot value 528 while (i < k && gcmp.CompareTo (keys[i]) > 0) 529 i++; 530 531 // find the last element with a value <= pivot value 532 while (k > i && gcmp.CompareTo (keys[k]) < 0) 533 k--; 534 } else if (cmp != null) { 535 // find the first element with a value >= pivot value 536 while (i < k && cmp.CompareTo (keys[i]) > 0) 537 i++; 538 539 // find the last element with a value <= pivot value 540 while (k > i && cmp.CompareTo (keys[k]) < 0) 541 k--; 542 } else { 543 while (i < k && keys[i] == null) 544 i++; 545 546 while (k > i && keys[k] != null) 547 k--; 548 } 549 } 550 551 if (k <= i) 552 break; 553 554 swap<K> (keys, i, k); 555 556 i++; 557 k--; 558 } while (true); 559 560 // push our partitions onto the stack, largest first 561 // (to make sure we don‘t run out of stack space) 562 if ((high - k) >= (k - low)) { 563 if ((k + 1) < high) { 564 stack[sp].high = high; 565 stack[sp].low = k; 566 sp++; 567 } 568 569 if ((k - 1) > low) { 570 stack[sp].high = k; 571 stack[sp].low = low; 572 sp++; 573 } 574 } else { 575 if ((k - 1) > low) { 576 stack[sp].high = k; 577 stack[sp].low = low; 578 sp++; 579 } 580 581 if ((k + 1) < high) { 582 stack[sp].high = high; 583 stack[sp].low = k; 584 sp++; 585 } 586 } 587 } while (sp > 0); 588 } 589 590 static bool QSortArrange<T> (T [] array, int lo, int hi, Comparison<T> compare) 591 { 592 if (array[lo] != null) { 593 if (array[hi] == null || compare (array[hi], array[lo]) < 0) { 594 swap<T> (array, lo, hi); 595 return true; 596 } 597 } 598 599 return false; 600 } 601 602 unsafe static void qsort<T> (T [] array, int low0, int high0, Comparison<T> compare) 603 { 604 QSortStack* stack = stackalloc QSortStack [32]; 605 const int QSORT_THRESHOLD = 7; 606 int high, low, mid, i, k; 607 int sp = 1; 608 T key; 609 610 // initialize our stack 611 stack[0].high = high0; 612 stack[0].low = low0; 613 614 do { 615 // pop the stack 616 sp--; 617 high = stack[sp].high; 618 low = stack[sp].low; 619 620 if ((low + QSORT_THRESHOLD) > high) { 621 // switch to insertion sort 622 for (i = low + 1; i <= high; i++) { 623 for (k = i; k > low; k--) { 624 if (compare (array[k], array[k-1]) >= 0) 625 break; 626 627 swap<T> (array, k - 1, k); 628 } 629 } 630 631 continue; 632 } 633 634 // calculate the middle element 635 mid = low + ((high - low) / 2); 636 637 // once we re-order the lo, mid, and hi elements to be in 638 // ascending order, we‘ll use mid as our pivot. 639 QSortArrange<T> (array, low, mid, compare); 640 if (QSortArrange<T> (array, mid, high, compare)) 641 QSortArrange<T> (array, low, mid, compare); 642 643 key = array[mid]; 644 645 // since we‘ve already guaranteed that lo <= mid and mid <= hi, 646 // we can skip comparing them again 647 k = high - 1; 648 i = low + 1; 649 650 do { 651 // Move the walls in 652 if (key != null) { 653 // find the first element with a value >= pivot value 654 while (i < k && compare (key, array[i]) > 0) 655 i++; 656 657 // find the last element with a value <= pivot value 658 while (k > i && compare (key, array[k]) < 0) 659 k--; 660 } else { 661 while (i < k && array[i] == null) 662 i++; 663 664 while (k > i && array[k] != null) 665 k--; 666 } 667 668 if (k <= i) 669 break; 670 671 swap<T> (array, i, k); 672 673 i++; 674 k--; 675 } while (true); 676 677 // push our partitions onto the stack, largest first 678 // (to make sure we don‘t run out of stack space) 679 if ((high - k) >= (k - low)) { 680 if ((k + 1) < high) { 681 stack[sp].high = high; 682 stack[sp].low = k; 683 sp++; 684 } 685 686 if ((k - 1) > low) { 687 stack[sp].high = k; 688 stack[sp].low = low; 689 sp++; 690 } 691 } else { 692 if ((k - 1) > low) { 693 stack[sp].high = k; 694 stack[sp].low = low; 695 sp++; 696 } 697 698 if ((k + 1) < high) { 699 stack[sp].high = high; 700 stack[sp].low = k; 701 sp++; 702 } 703 } 704 } while (sp > 0); 705 }
以上是关于struct的主要内容，如果未能解决你的问题，请参考以下文章
Linux 内核进程管理 task_struct 结构体 ① ( task_struct 结构体引入 | task_struct 代码示例 )