데이터 구조 --- 동적 배열 [1]

  1 #include <stdio.h>

  2 #include <stdlib.h>

  3 

  4 

  5 #define bool    int

  6 #define true    1

  7 #define false    0

  8 

  9 /*      struct Arr     */

 10 struct Arr

 11 {

 12     int count;  //       

 13     int length; //      

 14     int *pHead; //        

 15 };

 16 

 17 

 18 /*    */

 19 void init_arr(struct Arr *array1, int length);

 20 bool is_empty(struct  Arr *array1);

 21 bool is_full(struct Arr *array1);

 22 void show_arr(struct Arr *array1);

 23 bool append_arr(struct Arr *array1, int val);

 24 void inversion(struct Arr *array1);

 25 void insert_arr(struct Arr *array1, int pos, int val);

 26 void sort_arr(struct Arr *array1);

 27 

 28 

 29 

 30 /*   */

 31 int main(void)

 32 {

 33     struct Arr array1;    //    struct Arr      array1

 34     int val = 0;

 35     int pos = 0;

 36     array1.pHead = NULL; // pHead     NULL                  !

 37     init_arr(&array1, 3);

 38     append_arr(&array1, 1);

 39     append_arr(&array1, 3);

 40     insert_arr(&array1, 1, 2);

 41     show_arr(&array1);

 42     sort_arr(&array1);

 43     show_arr(&array1);

 44     return 0;

 45 }

 46 

 47 

 48 /*        */

 49 void init_arr(struct Arr *array1, int length)

 50 {

 51     array1->pHead = (int *)malloc(sizeof(struct Arr) * length);

 52     if (NULL == array1->pHead)

 53     {

 54         printf("      .
");

 55         exit(1);

 56     }

 57     array1->length = length;

 58     array1->count = 0;

 59 }

 60 

 61 /*        */

 62 bool is_empty(struct  Arr *array1)

 63 {

 64     if (0 == array1->count)

 65         return true;

 66     return false;

 67 }

 68 

 69 

 70 /*        */

 71 bool is_full(struct Arr *array1)

 72 {

 73     if (array1->count == array1->length)

 74         return true;

 75     return false;

 76 }

 77 

 78 

 79 /*         */

 80 void show_arr(struct Arr *array1)

 81 {

 82     int i;

 83     if ( 0 == array1->count)

 84         printf("    .
");

 85     for (i = 0; i < array1->count; i++)

 86         printf("%d\t", array1->pHead[i]);

 87     printf("
");

 88 }

 89 

 90 /*  */

 91 bool append_arr(struct Arr *array1, int val)

 92 {

 93     int i;

 94     if ( is_full(array1) )

 95     {

 96         printf("    .
");

 97         return false;

 98     }

 99     i = array1->count;

100     (array1->pHead)[i] = val;

101     array1->count++;

102     return true;

103 }

104 

105 /*  */

106 void inversion(struct Arr *array1)

107 {

108     int i = array1->count - 1;

109     int j = 0;

110     int *temp = (int *)malloc(sizeof(int) * array1->count);

111     if ( NULL == temp )

112     {

113         printf("      
");

114         exit(1);

115     }

116     if ( is_empty(array1) )

117     {

118         printf("    .
");

119         return;

120     }

121     for (; i >= 0; i--)

122     {

123         printf("%d\t", array1->pHead[i]);

124         temp[j] = array1->pHead[i];

125         j++;

126     }

127     printf("
");

128     free(temp);

129 }

130 

131 

132 /*  */

133 void insert_arr(struct Arr *array1, int pos, int val)

134 {

135     int i = pos;

136     int j = 0;

137     int *temp = (int *)malloc(sizeof(int) * (array1->length - pos + 1));

138     if (NULL == temp)

139     {

140         printf("      .
");

141         exit(1);

142     }

143     for (; i <= array1->length; ++i)

144     {

145         temp[j] = array1->pHead[i-1];

146         j++;

147     }

148     j = 0;

149     array1->pHead[pos-1] = val;

150     for (i = pos; i < array1->length; ++i)

151     {

152         array1->pHead[i] = temp[j];

153         j++;

154     }

155     free(temp);

156     array1->count++;

157 }

158 

159 

160 /*              */

161 void sort_arr(struct Arr *array1)

162 {

163     int i, j, temp;

164     for (i = 0; i < array1->count; i++)

165     {

166         for (j = 0; j < array1->count - 1; j++)

167         {

168             if (array1->pHead[j] > array1->pHead[j+1])

169             {

170                 temp = array1->pHead[j];

171                 array1->pHead[j] = array1->pHead[j+1];

172                 array1->pHead[j+1] = temp;

173             }

174         }

175     }

176 }