Как найти несколько минимумов в массиве

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

#include <stdio.h>
 
#define K       10
#define N       5       //количество минимальных
 
unsigned int arr[K] = {23,1,56,7,89,9,0,4,777,65535};
 
unsigned int findMinimal(unsigned int leastDig);
 
int main(void)
{
    int minCount = 0;
    unsigned int min[N] = {0};.  //Массив N количества искомых
    #define I (minCount == 0) ? minCount: minCount-1
    
    int temp;
    //запись N минимальных в массив min
    for(int i = 0; i < N; i++)
    {
        min[minCount] = findMinimal(min[I]);
        
        minCount++;
    }
    
    //вывод
    printf("String of numbers:n");
    for(int i = 0; i < K; i++)
        printf("%d ", arr[i]);
    printf("nn%d minimal numbers:n", N);
    for(int i = 0; i < minCount; i++)
    {
        printf("%d. %un", i, min[i]);
    }
    return 0;
}
 
 
unsigned int findMinimal(unsigned int leastDig)
{
    unsigned int tmp = ~(0);     //выставить все биты 
    int i = 0;
    while(i < K)
    {
        //если текущее число меньше tmp и больше ранее найденого, то запишем новое
        if(arr[i] <= tmp && arr[i] > leastDig)
        {
            tmp = arr[i];
        }
        i++;
    }
    return tmp;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

#define SWAP(x, y) do { x ^= y; y ^= x; x ^= y; } while (0)
 
void gnome_sort(int* a, size_t size) {
    for (size_t i = 0; i < size-1; ++i) {
        if (a[i] > a[i+1]) {
            SWAP(a[i], a[i+1]);
            (i >= 1) ? i -= 2 : --i;
        }
    }
}
 
int main(int argc, char const *argv[]) {
    int arr[] = {10, -1, 3, 0, 2, 1, 2, 19, 13, 9, 7, 7};
 
    gnome_sort(arr, sizeof(arr) / sizeof(int));
 
    for (size_t i = 0; i < N; ++i)
        printf("%d ", arr[i]);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

#include <stdio.h>
 
int main()
{
 
    int arr[] = {23,1,56,7,89,9,0,4,777,65535};
    int n = sizeof(arr) / sizeof(arr[0]);
    
    int k = 3; // Количество минимумов 
    int mins[k + 1]; // Массив для их хранения (один вспомогательный)
    // Инициализация
    mins[0] = arr[0];
    // Поиск минимумов
    size_t d = 1; 
    for(size_t i = 0; i < n; i++) {
        size_t j = d;
        while(j > 0 && mins[j - 1] > arr[i]) {
            mins[j] = mins[j - 1];
            j--;
        }
        mins[j] = arr[i];
        if (d < k) d++;
    }
    // Вывод минимумов
    for(size_t i = 0; i < k; i++) {
        printf("%d ", mins[i]);
    }
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

#include <stdio.h>
#include <stdlib.h>
 
#define K       10
#define N       5       //êîëè÷åñòâî ìèíèìàëüíûõ
 
void merge(unsigned int *a,  int n)
{
  int mid = n / 2; // íàõîäèì ñåðåäèíó ñîðòèðóåìîé ïîñëåäîâàòåëüíîñòè
  if (n % 2 == 1)
    mid++;
  int h = 1; // øàã
  // âûäåëÿåì ïàìÿòü ïîä ôîðìèðóåìóþ ïîñëåäîâàòåëüíîñòü
  int *c = new int [n];
  int step;
  while (h < n) 
  {
    step = h;
    int i = 0;   // èíäåêñ ïåðâîãî ïóòè
    int j = mid; // èíäåêñ âòîðîãî ïóòè
    int k = 0;   // èíäåêñ ýëåìåíòà â ðåçóëüòèðóþùåé ïîñëåäîâàòåëüíîñòè
    while (step <= mid) 
    {
      while ((i < step) && (j < n) && (j < (mid + step))) 
      { // ïîêà íå äîøëè äî êîíöà ïóòè
        // çàïîëíÿåì ñëåäóþùèé ýëåìåíò ôîðìèðóåìîé ïîñëåäîâàòåëüíîñòè
        // ìåíüøèì èç äâóõ ïðîñìàòðèâàåìûõ
        if (a[i] < a[j])  
        {
          c[k] = a[i];
          i++; k++;
        }
        else {
          c[k] = a[j];
          j++; k++;
        }
      }
      while (i < step) 
      { // ïåðåïèñûâàåì îñòàâøèåñÿ ýëåìåíòû ïåðâîãî ïóòè (åñëè âòîðîé êîí÷èëñÿ ðàíüøå)
        c[k] = a[i];
        i++; k++;
      }
      while ((j < (mid + step)) && (j<n)) 
      {  // ïåðåïèñûâàåì îñòàâøèåñÿ ýëåìåíòû âòîðîãî ïóòè (åñëè ïåðâûé êîí÷èëñÿ ðàíüøå)
        c[k] = a[j];
        j++; k++;
      }
      step = step + h; // ïåðåõîäèì ê ñëåäóþùåìó ýòàïó
    }
    h = h * 2;
    // Ïåðåíîñèì óïîðÿäî÷åííóþ ïîñëåäîâàòåëüíîñòü (ïðîìåæóòî÷íûé âàðèàíò) â èñõîäíûé ìàññèâ
    for (i = 0; i<n; i++)
      a[i] = c[i];
  }
}
 
unsigned int arr[K] = {23,1,56,7,89,9,2,4,777,65535};
 
unsigned int findMinimal(unsigned int leastDig);
 
int main(void)
{
    int minCount = 0;
    int p1=1;
    int p2=2, x;
    unsigned int min[N] = {0};  //Ìàññèâ N êîëè÷åñòâà èñêîìûõ
    #define I (minCount == 0) ? minCount: minCount-1
    
    int temp;
    //çàïèñü N ìèíèìàëüíûõ â ìàññèâ min
    scanf("%d", &x);
    if (x==1)
    {
    for(int i = 0; i < N; i++)
    {
        min[minCount] = findMinimal(min[I]);
        
        minCount++;
    }
      printf("String of numbers:n");
    for(int i = 0; i < K; i++)
        printf("%d ", arr[i]);
    printf("nn%d minimal numbers:n", N);
    for(int i = 0; i < minCount; i++)
    {
        printf("%d. %un", i, min[i]);
    }}
    else
    {
        merge(arr ,K); // ВОТ ЗДЕСЬ неправильно сортирует
  for (int i = 0; i<10; i++){
    printf("%d ", arr[i]);
    printf("n");}
 
    }
    
    //âûâîä
 
    return 0;
}
 
 
unsigned int findMinimal(unsigned int leastDig)
{
    unsigned int tmp = ~(0);     //
    int i = 0;
    while(i < K)
    {
        //
        if(arr[i] <= tmp && arr[i] > leastDig)
        {
            tmp = arr[i];
        }
        i++;
    }
    return tmp;
}

1

 #define I (minCount == 0) ? minCount: minCount-1

1

  unsigned int tmp = ~0;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

#include <stdio.h>
#include <stdlib.h>
 
#define K       10
#define N       5       //количество минимальных
 
void merge(int*a, int n)
{
    int rght, rend, b[20];
    int i, j, m;
 
    for (int k = 1; k < n; k *= 2)
    {
        for (int left = 0; left + k < n; left += k * 2)
        {
            rght = left + k;
            rend = rght + k;
            if (rend > n) rend = n;
            m = left; i = left; j = rght;
            while (i < rght && j < rend)
            {
                if (a[i] <= a[j])
                {
                    b[m] = a[i]; i++;
                }
                else
                {
                    b[m] = a[j]; j++;
                }
                m++;
            }
            while (i < rght)
            {
                b[m] = a[i];
                i++; m++;
            }
            while (j < rend)
            {
                b[m] = a[j];
                j++; m++;
            }
            for (m = left; m < rend; m++)
            {
                a[m] = b[m];
            }
        }
    }
}
 
 int arr[K] = {23,1,56,7,89,9,2,4,777,65535};
 
unsigned int findMinimal(unsigned int leastDig);
 
int main(void)
{
    int minCount = 0;
    int p1=1;
    int p2=2, x;
    unsigned int min[N] = {0};  //Массив N количества искомых
    #define I (minCount == 0) ? minCount: minCount-1
    
    int temp;
    //запись N минимальных в массив min
    scanf("%d", &x);
    if (x==1)
    {
    for(int i = 0; i < N; i++)
    {
        min[minCount] = findMinimal(min[I]);
        
        minCount++;
    }
      printf("String of numbers:n");
    for(int i = 0; i < K; i++)
        printf("%d ", arr[i]);
    printf("nn%d minimal numbers:n", N);
    for(int i = 0; i < minCount; i++)
    {
        printf("%d. %un", i, min[i]);
    }}
    else
    {
        merge(arr ,K); // ????? ??????? ??????????
  // ????? ????????? ??????? ????? ??????????
    for(int i = 0; i < N; i++)
    {
        min[minCount] = findMinimal(min[I]);
        
        minCount++;
    }
      printf("String of numbers:n");
    for(int i = 0; i < K; i++)
        printf("%d ", arr[i]);
    printf("nn%d minimal numbers:n", N);
    for(int i = 0; i < minCount; i++)
    {
        printf("%d. %un", i, min[i]);
    }
 
    }
    
    //вывод
 
    return 0;
}
 
 
unsigned int findMinimal(unsigned int leastDig)
{
    unsigned int tmp = ~(0);     //выставить все биты 
    int i = 0;
    while(i < K)
    {
        //если текущее число меньше tmp и больше ранее найденого, то запишем новое
        if(arr[i] <= tmp && arr[i] > leastDig)
        {
            tmp = arr[i];
        }
        i++;
    }
    return tmp;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

unsigned int findMinimal(unsigned int leastDig)
{
    unsigned int tmp = ~(0);    
    int i = 0;
    while(i < K)
    {
        
        if(arr[i] <= tmp && arr[i] > leastDig)
        {
            tmp = arr[i];
        }
        i++;
    }
    return tmp;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

//Возвращает минимальное число из массива arr, с учётом младшего числа leastDig
unsigned int findMinimal(unsigned int leastDig)         
{
    unsigned int tmp = ~(0);     //выставить все биты 
    int i = 0;
    while(i < K)
    {
        //если текущее число меньше tmp и больше ранее найденого, то запишем новое
        if(arr[i] <= tmp && arr[i] > leastDig)
        {
            tmp = arr[i];
        }
        i++;
    }
    return tmp;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

#include <stdio.h>
 
#define K       10
#define N       5       //количество минимальных
 
long long arr[K] = {23,1,56,-7,89,9,0,4,777,-65534};
 
long long findMinimal(long long leastDig);
 
int main(void)
{
    int minCount = 0;
    long long min[N] = {1 << 31};  //Массив N количества искомых
    #define I (minCount == 0) ? minCount: minCount-1
    
    //запись N минимальных в массив min
    for(int i = 0; i < N; i++, minCount++)
        min[minCount] = findMinimal(min[I]);
    
    
    //вывод
    printf("String of numbers:n");
    for(int i = 0; i < K; i++)
        printf("%lld ", arr[i]);
    
    printf("nn%d minimal numbers:n", N);
    for(int i = 0; i < minCount; i++)
    {
        printf("%d. %lldn", i, min[i]);
    }
    return 0;
}
 
 
long long findMinimal(long long leastDig)
{
    long long tmp = ~(1 << 31);//получить макс.число
    int i = 0;
    while(i < K)
    {
        //если текущее число меньше tmp и больше ранее найденого, то запишем новое
        if(arr[i] <= tmp && arr[i] > leastDig)
            tmp = arr[i];
        i++;
    }
    return tmp;
}