際際滷

際際滷Share a Scribd company logo
3.How fast we can sort


                螻                讌

                                                A0 譟
                                                 譟一
                                         20063532 譟磯蟯
                                         20073547 讌
                                         20083438 蟾覓願化
                                         20093447 蟾
                                         20093489 ″
                                         20093516 レ


        螻殊 蠍郁 : 4 9 ~ 4 20 (12) 豐 8螳.


譯殊 : How fast can we sort?

覈 : 願骸 譟壱 伎  .

螻.

豌 譯(4 9~15)
 螻襴讀 襴
 牛  螳 蟯 郁規
 螻殊 1 蟯 覓語 願屋



讌語(4 16~20)
  譯殊 伎 覈詩 覿覿 殊
 螻殊 2 襦蠏碁 るゼ
豌 譯.

4 09 


覓企
譟一 : ″ 襭譟一 : 蟾覓願化, 蟾, レ, 襦蠏碁貊 : 譟磯蟯, 讌



牛 伎
The fundamental principle of counting.
殊企   蟇伎 螳讌襯 襷 蟆. 1  殊企   
蟇伎 螳讌襯 n企手     蟆曙一 襯 n企手 .

sample.
r 螳 襦 るジ  譴 譴覲旧  n螳襯 觸  譴襦 危
蟆曙一 .
豕豐 r 螳襯   螻 危 螻 r 螳襯   蠍 覓語 
伎 螳 r酔   .

selection
襦 るジ n 螳  譴覲旧 渚 r 螳襯 觸 蟆曙一 . 譴覲旧^
nHr r 螳 れ  蟯 危 蟆企.

k-permutation
襦 るジ n 螳  譴 r 螳(n>=r)襯 觸  譴襦 語磯 蟆曙一 .
nPr 襦 碁. 譴覲旧願骸, , 殊殊 煙 .         p(n, r) = n!
/ (n-r)!

k-combination
讌 朱 襯 豬 覿覿讌 襷 蟆 襷. n 螳 襯 螳
讌 讌 k螳 覿覿讌 螻襯企 譟壱 蟆曙一  危螻 覃,
nCk襦 碁. 譴覲旧^ . C(n, k) = n! / k!(n-k)!
4 11 



螻殊1.
10~29蟾讌 20レ 豺企襯 覦覯 1, 2, 3 磯 貅.

覦覯1.
 螳  螳  蟾讌 谿場  豺企襯 企  覃伎 襦 る襦 .
豌覿 れ 蠏 れ  襯 谿場 蠏 豺企 .  螻殊 覈 豺企襯
谿場 蟾讌 覦覲牛. 螳? 
豌 豺企襯 覈 覯 覲伎 螳? 豕 20, 豕 190 觜蟲襯 伎狩.
豕 蟆曙磯 企至 豐蠍壱  蟆曙一瑚? 10覿 29朱  
螳 襷 觜蟲襯 伎狩. 190 觜蟲襯 牛 蟲 . (20*19 / 2 = 190)
豕 蟆曙磯 企至 豐蠍壱  蟆曙一瑚? 29 10 朱   
螳 蟆 觜蟲  . 20 觜蟲襷 覃 .
螳 覲旧° 朱瑚? 螳 覲旧° n螳 螳    n(n-1) /
2企襦 big O O(n族)企.


覦覯2.
豺企襯  覘豺襦 .  豌 螳 1 蟆願 るジ  豌 螳 2瑚企.
螳 覘豺襯 覦覯1  覯讌 襯 . 豌 覯讌 覘豺襯 覯讌 覘豺 
. 螳? .
豺企 觜蟲  朱瑚? 110. 豺企 豌襯 觜蟲 螳 20願,

伎 豺企 覘豺襯 覦覯1 覦覯朱  覃 螳螳 10C2螳 覩襦, 45 2覯
讀 90覯 觜蟲襯 . 磯殊 觜蟲  110螳 .



覦覯3
豺企  覯讌 襯 伎 10螳 覘豺(0~9)襦. 伎  覯讌 螳 0
覘豺襯 讌伎 豌 覯讌語襯 覲願  覘豺襦 螻 れ .  覯讌語螳 1
覘豺襯 讌伎 れ 豌 覯讌 襯 覲願  覘豺襦   覘豺  れ
. 覈 豺企  覦覲牛.
豺企 觜蟲  朱瑚? 30.  覯讌 襯 る 螻殊 20
觜蟲螳 螻, 豌 覯讌 襯  螻殊 10覯 觜蟲螳 . 磯殊 30
觜蟲螳 .
讌語.

4 18 

豕譬 .

#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>


void combination(char*, int, int, int, int, int*); // combination func..


int main()
{
        int i,j, number ,*array
 //i = r , number = n
 int c=0;// 螳 = n
 int next =0;
 int nums = 0;
 char a[100] = {0};
 char *ap = a;
 char ar[21]={0};
 printf("[ex){a,s,d}3] ロ : ");
        gets(a);
 printf("input item number: ");


 for(j=0;j<100;j++)
 {
    if((a[j]>=65&&a[j]<=90)||(a[j]>=97&&a[j]<=122))
    {
     ar[next]=a[j];
     next++;
    }
    else if((a[j]>=48&&a[j]<=57)||a[j]==0)
    {
     i=atoi(ap+j);
break
     }
 }
 while(1)// count 讀螳覿覿
 {
     if(ar[c]==0)break
     c++;}


 printf("%dn",c);
 printf("%d",i);




         // create memory..
         array = (int*)malloc(sizeof(int)*(c+1));



               printf("n* %d - combination >n", i);
               combination(ar, 0, 0, i, c, array);


         printf("n");


//           getch();
         free(array);    // free memory..
         return 0;
}


// recursive combination function..
void combination(char *ar, int now, int count, int step, int number, int*
array)
{
         int i;


         *(array+count) = now;


         if (count == step)     // search r-combination ..
         {
printf(" { %c", ar[*(array+1)-1]);      // print frist item..
          for (i = 2; i <= count; i++)
         {
             printf(", %c", ar[*(array+i)-1]); // print other item..
         }


         printf(" } ");   // close..


         return ;
    }
        // recursive routine..
    for (i = now+1; i <= number; i++)
    {
         combination(ar, i, count+1, step, number, array);
    }




蟆郁骸.

More Related Content

Similar to 2012 Dm A0 03 Pdf (20)

伎一 Project3
伎一 Project3伎一 Project3
伎一 Project3
KoChungWook
2012 Ds 01
2012 Ds 012012 Ds 01
2012 Ds 01
Jungyerin
襭蟲譟 Project6
襭蟲譟 Project6襭蟲譟 Project6
襭蟲譟 Project6
KoChungWook
2012 Dm C3 03
2012 Dm C3 032012 Dm C3 03
2012 Dm C3 03
chl132435
[Algorithm] Counting Sort
[Algorithm] Counting Sort[Algorithm] Counting Sort
[Algorithm] Counting Sort
Bill Kim
3貊るれ伎
3貊るれ伎3貊るれ伎
3貊るれ伎
herojoon1378
Project#3 How Fast Can We Sort Hwp
Project#3 How Fast Can We Sort HwpProject#3 How Fast Can We Sort Hwp
Project#3 How Fast Can We Sort Hwp
Kimjeongmoo
2012 Dm A0 02 Pdf
2012 Dm A0 02 Pdf2012 Dm A0 02 Pdf
2012 Dm A0 02 Pdf
kd19h
[Algorithm] Selection Sort
[Algorithm] Selection Sort[Algorithm] Selection Sort
[Algorithm] Selection Sort
Bill Kim
襭蟲譟01
襭蟲譟01襭蟲譟01
襭蟲譟01
herojoon1378
Computational Complexity
Computational ComplexityComputational Complexity
Computational Complexity
skku_npc
螻襴讀 ろ磯() Seungdols
螻襴讀 ろ磯() Seungdols螻襴讀 ろ磯() Seungdols
螻襴讀 ろ磯() Seungdols
seungdols
[磯襭]碁_螻襴讀 ろ磯
[磯襭]碁_螻襴讀 ろ磯[磯襭]碁_螻襴讀 ろ磯
[磯襭]碁_螻襴讀 ろ磯
Amugona study 1 jjw
Amugona study 1 jjwAmugona study 1 jjw
Amugona study 1 jjw
Amugona study 1 jjw
Amugona study 1 jjwAmugona study 1 jjw
Amugona study 1 jjw
伎一 Project3
伎一 Project3伎一 Project3
伎一 Project3
KoChungWook
2012 Ds 01
2012 Ds 012012 Ds 01
2012 Ds 01
Jungyerin
襭蟲譟 Project6
襭蟲譟 Project6襭蟲譟 Project6
襭蟲譟 Project6
KoChungWook
2012 Dm C3 03
2012 Dm C3 032012 Dm C3 03
2012 Dm C3 03
chl132435
[Algorithm] Counting Sort
[Algorithm] Counting Sort[Algorithm] Counting Sort
[Algorithm] Counting Sort
Bill Kim
Project#3 How Fast Can We Sort Hwp
Project#3 How Fast Can We Sort HwpProject#3 How Fast Can We Sort Hwp
Project#3 How Fast Can We Sort Hwp
Kimjeongmoo
2012 Dm A0 02 Pdf
2012 Dm A0 02 Pdf2012 Dm A0 02 Pdf
2012 Dm A0 02 Pdf
kd19h
[Algorithm] Selection Sort
[Algorithm] Selection Sort[Algorithm] Selection Sort
[Algorithm] Selection Sort
Bill Kim
Computational Complexity
Computational ComplexityComputational Complexity
Computational Complexity
skku_npc
螻襴讀 ろ磯() Seungdols
螻襴讀 ろ磯() Seungdols螻襴讀 ろ磯() Seungdols
螻襴讀 ろ磯() Seungdols
seungdols
[磯襭]碁_螻襴讀 ろ磯
[磯襭]碁_螻襴讀 ろ磯[磯襭]碁_螻襴讀 ろ磯
[磯襭]碁_螻襴讀 ろ磯
Amugona study 1 jjw
Amugona study 1 jjwAmugona study 1 jjw
Amugona study 1 jjw
Amugona study 1 jjw
Amugona study 1 jjwAmugona study 1 jjw
Amugona study 1 jjw

2012 Dm A0 03 Pdf

  • 1. 3.How fast we can sort 螻 讌 A0 譟 譟一 20063532 譟磯蟯 20073547 讌 20083438 蟾覓願化 20093447 蟾 20093489 ″ 20093516 レ 螻殊 蠍郁 : 4 9 ~ 4 20 (12) 豐 8螳. 譯殊 : How fast can we sort? 覈 : 願骸 譟壱 伎 . 螻. 豌 譯(4 9~15) 螻襴讀 襴 牛 螳 蟯 郁規 螻殊 1 蟯 覓語 願屋 讌語(4 16~20) 譯殊 伎 覈詩 覿覿 殊 螻殊 2 襦蠏碁 るゼ
  • 2. 豌 譯. 4 09 覓企 譟一 : ″ 襭譟一 : 蟾覓願化, 蟾, レ, 襦蠏碁貊 : 譟磯蟯, 讌 牛 伎 The fundamental principle of counting. 殊企 蟇伎 螳讌襯 襷 蟆. 1 殊企 蟇伎 螳讌襯 n企手 蟆曙一 襯 n企手 . sample. r 螳 襦 るジ 譴 譴覲旧 n螳襯 觸 譴襦 危 蟆曙一 . 豕豐 r 螳襯 螻 危 螻 r 螳襯 蠍 覓語 伎 螳 r酔 . selection 襦 るジ n 螳 譴覲旧 渚 r 螳襯 觸 蟆曙一 . 譴覲旧^ nHr r 螳 れ 蟯 危 蟆企. k-permutation 襦 るジ n 螳 譴 r 螳(n>=r)襯 觸 譴襦 語磯 蟆曙一 . nPr 襦 碁. 譴覲旧願骸, , 殊殊 煙 . p(n, r) = n! / (n-r)! k-combination 讌 朱 襯 豬 覿覿讌 襷 蟆 襷. n 螳 襯 螳 讌 讌 k螳 覿覿讌 螻襯企 譟壱 蟆曙一 危螻 覃, nCk襦 碁. 譴覲旧^ . C(n, k) = n! / k!(n-k)!
  • 3. 4 11 螻殊1. 10~29蟾讌 20レ 豺企襯 覦覯 1, 2, 3 磯 貅. 覦覯1. 螳 螳 蟾讌 谿場 豺企襯 企 覃伎 襦 る襦 . 豌覿 れ 蠏 れ 襯 谿場 蠏 豺企 . 螻殊 覈 豺企襯 谿場 蟾讌 覦覲牛. 螳? 豌 豺企襯 覈 覯 覲伎 螳? 豕 20, 豕 190 觜蟲襯 伎狩. 豕 蟆曙磯 企至 豐蠍壱 蟆曙一瑚? 10覿 29朱 螳 襷 觜蟲襯 伎狩. 190 觜蟲襯 牛 蟲 . (20*19 / 2 = 190) 豕 蟆曙磯 企至 豐蠍壱 蟆曙一瑚? 29 10 朱 螳 蟆 觜蟲 . 20 觜蟲襷 覃 . 螳 覲旧° 朱瑚? 螳 覲旧° n螳 螳 n(n-1) / 2企襦 big O O(n族)企. 覦覯2. 豺企襯 覘豺襦 . 豌 螳 1 蟆願 るジ 豌 螳 2瑚企. 螳 覘豺襯 覦覯1 覯讌 襯 . 豌 覯讌 覘豺襯 覯讌 覘豺 . 螳? . 豺企 觜蟲 朱瑚? 110. 豺企 豌襯 觜蟲 螳 20願, 伎 豺企 覘豺襯 覦覯1 覦覯朱 覃 螳螳 10C2螳 覩襦, 45 2覯 讀 90覯 觜蟲襯 . 磯殊 觜蟲 110螳 . 覦覯3 豺企 覯讌 襯 伎 10螳 覘豺(0~9)襦. 伎 覯讌 螳 0 覘豺襯 讌伎 豌 覯讌語襯 覲願 覘豺襦 螻 れ . 覯讌語螳 1 覘豺襯 讌伎 れ 豌 覯讌 襯 覲願 覘豺襦 覘豺 れ . 覈 豺企 覦覲牛. 豺企 觜蟲 朱瑚? 30. 覯讌 襯 る 螻殊 20 觜蟲螳 螻, 豌 覯讌 襯 螻殊 10覯 觜蟲螳 . 磯殊 30 觜蟲螳 .
  • 4. 讌語. 4 18 豕譬 . #include <stdio.h> #include <malloc.h> #include <stdlib.h> void combination(char*, int, int, int, int, int*); // combination func.. int main() { int i,j, number ,*array //i = r , number = n int c=0;// 螳 = n int next =0; int nums = 0; char a[100] = {0}; char *ap = a; char ar[21]={0}; printf("[ex){a,s,d}3] ロ : "); gets(a); printf("input item number: "); for(j=0;j<100;j++) { if((a[j]>=65&&a[j]<=90)||(a[j]>=97&&a[j]<=122)) { ar[next]=a[j]; next++; } else if((a[j]>=48&&a[j]<=57)||a[j]==0) { i=atoi(ap+j);
  • 5. break } } while(1)// count 讀螳覿覿 { if(ar[c]==0)break c++;} printf("%dn",c); printf("%d",i); // create memory.. array = (int*)malloc(sizeof(int)*(c+1)); printf("n* %d - combination >n", i); combination(ar, 0, 0, i, c, array); printf("n"); // getch(); free(array); // free memory.. return 0; } // recursive combination function.. void combination(char *ar, int now, int count, int step, int number, int* array) { int i; *(array+count) = now; if (count == step) // search r-combination .. {
  • 6. printf(" { %c", ar[*(array+1)-1]); // print frist item.. for (i = 2; i <= count; i++) { printf(", %c", ar[*(array+i)-1]); // print other item.. } printf(" } "); // close.. return ; } // recursive routine.. for (i = now+1; i <= number; i++) { combination(ar, i, count+1, step, number, array); } 蟆郁骸.