1. /*
   
2. main.m
   
3. 用冒泡和选择排序的方式对数组进行排序
   
4. 外层循环(这数组有多少个元素,就应该循环多少次)
   
5. 内层循环(每次循环都是求1次最值<最大值/最小值>)
   
6. 选择排序
   
7. 分析:
   
8. 选择排序就是,
   
9. 先假设一个元素为最值(最小/最大值),拿这个元素跟另外的元素进行比较,找出真正最值出来!(内循环)
   
10. 
    
11. 获得最值元素的下标,将最值元素的值放在第一个下标位置上,
    
12. 原第一个元素的值,给了上一轮的最值(也就是进行交换)(外循环)
    
13. 
    
14. 再次循环,忽略第一个下标!(int minIndex = i; int j=i)
    
15. 选择排序的核心,假设个最值,跟别的元素比较,得出真正最值!
    
16. 选择好此下标,将此下标的值与第一个元素的值进行互换!
    
17. 
    
18. 冒泡排序
    
19. 冒泡排序的核心,两个相邻的元素进行比较,得出最值,进行交换,将最值放到最后!
    
20. 分析:
    
21. 两个相邻元素进行比较,if(arr[j]>arr[j+1])
    
22. 将最值放在最后! -- 比较后,直接互换位置
    
23. 忽略已经排序好的元素! -- j<len-i
    
24. 
    
25. */
    
26. #import <Foundation/Foundation.h>
    
27. int *minArr(int arr[],int len);
    
28. int *maxArr(int arr[],int len);
    
29. int *minMaoPao(int arr[],int len);
    
30. int *maxMaoPao(int arr[], int len);
    
31. int main(int argc, const char * argv[]) {
    
32.    
    
33.     int arr [5] ={8,9,5,3,4};
    
34.     //数组元素从小到大打印
    
35.     //    int *minAr = minArr(arr,5);
    
36.     //    for (int i=0; i<5; i++) {
    
37.     //        printf("%d",minAr[i]);
    
38.     //    }
    
39.     //    printf("\n");
    
40.     //
    
41.     //    //数组元素从大到小打印
    
42.     //    int *maxAr = maxArr(arr,5);
    
43.     //    for (int i = 0; i<5; i++) {
    
44.     //        printf("%d",maxAr[i]);
    
45.     //    }
    
46.     //    printf("\n");
    
47.    
    
48.     //    //数组元素从小到大打印
    
49.     //    int *minMaoPaoArr = minMaoPao(arr,5);
    
50.     //    for (int i = 0; i<5; i++) {
    
51.     //        printf("%d",minMaoPaoArr[i]);
    
52.     //    }
    
53.     //    printf("\n");
    
54.    
    
55.     //数组元素从大到小打印
    
56.     int *maxMaoPaoArr = maxMaoPao(arr,5);
    
57.     for (int i = 0; i<5; i++) {
    
58.         printf("%d",maxMaoPaoArr[i]);
    
59.     }
    
60.     printf("\n");
    
61.    
    
62.     return 0;
    
63. }
    
64. 
    
65. //使用冒泡排序的方法,从小到大进行排序
    
66. int *minMaoPao(int arr[],int len){
    
67.     int temp =0;
    
68.     for (int i =0; i<len; i++) {//外层循环,
    
69.         for (int j=0; j<len-i; j++) {//内层循环,取出最值! j<len-i,忽略以排序好的值
    
70.             if(arr[j]>arr[j+1]){//两个相邻的元素进行比较,大的换到后面去!
    
71.                 temp = arr[j];
    
72.                 arr[j] =arr[j+1];
    
73.                 arr[j+1] = temp;
    
74.             }
    
75.         }
    
76.     }
    
77.     return arr;
    
78. }
    
79. 
    
80. //使用冒泡排序的方法,将数组元素,从大到小排序
    
81. int *maxMaoPao(int arr[], int len){
    
82.     int temp = 0;
    
83.     for (int i = 0; i<len; i++) {
    
84.         for (int j=0; j<len-i; j++) {
    
85.             if (arr[j]<arr[j+1]) {
    
86.                 temp = arr[j];
    
87.                 arr[j] = arr[j+1];
    
88.                 arr[j+1] = temp;
    
89.             }
    
90.         }
    
91.     }
    
92.     return arr;
    
93. }
    
94. //将数组元素从小到大排序
    
95. int *minArr(int arr[],int len){
    
96.    
    
97.     int temp = 0;
    
98.     for (int i = 0; i<len; i++) {
    
99.         //去除已经排序好的元素
    
100.         //假设一个元素为最值!arr[0]/arr[1]/arr[2]...
     
101.         int minIndex = i;
     
102.         for (int j=i; j<len; j++) {//j=i,再次循环时,会忽略以排好的元素
     
103.             if (arr[minIndex]>arr[j]) {
     
104.                 minIndex =j;//求出最小值的下标
     
105.             }
     
106.         }
     
107.         //既要将最小值给arr[0]的元素,又要将原本arr[0]的值,拿去跟别的值进行比较 --交换
     
108.         temp = arr[minIndex];
     
109.         arr[minIndex] = arr[i];
     
110.         arr[i]=temp;
     
111.     }
     
112.     return arr;//这时候返回的是个指针?也就是首字母的地址
     
113. }
     
114. //将数组元素从大到小的排序
     
115. int *maxArr(int arr[],int len){
     
116.     int temp = 0;
     
117.     for (int i = 0; i<len; i++) {
     
118.         int maxIndex = i;
     
119.         for (int j = i; j<len; j++) {//注意:j=i,这是忽略已经排好序的元素
     
120.             if (arr[maxIndex]<arr[j]) {
     
121.                 maxIndex = j;
     
122.             }
     
123.         }
     
124.         //交换值
     
125.         temp = arr[maxIndex];
     
126.         arr[maxIndex] = arr[i];
     
127.         arr[i] = temp;
     
128.     }
     
129.    
     
130.     return arr;
     
131. }

复制代码

1. /*
   
2. main.m
   
3. 用冒泡和选择排序的方式对数组进行排序
   
4. 外层循环(这数组有多少个元素,就应该循环多少次)
   
5. 内层循环(每次循环都是求1次最值<最大值/最小值>)
   
6. 选择排序
   
7. 分析:
   
8. 选择排序就是,
   
9. 先假设一个元素为最值(最小/最大值),拿这个元素跟另外的元素进行比较,找出真正最值出来!(内循环)
   
10. 
    
11. 获得最值元素的下标,将最值元素的值放在第一个下标位置上,
    
12. 原第一个元素的值,给了上一轮的最值(也就是进行交换)(外循环)
    
13. 
    
14. 再次循环,忽略第一个下标!(int minIndex = i; int j=i)
    
15. 选择排序的核心,假设个最值,跟别的元素比较,得出真正最值!
    
16. 选择好此下标,将此下标的值与第一个元素的值进行互换!
    
17. 
    
18. 冒泡排序
    
19. 冒泡排序的核心,两个相邻的元素进行比较,得出最值,进行交换,将最值放到最后!
    
20. 分析:
    
21. 两个相邻元素进行比较,if(arr[j]>arr[j+1])
    
22. 将最值放在最后! -- 比较后,直接互换位置
    
23. 忽略已经排序好的元素! -- j<len-i
    
24. 
    
25. */
    
26. #import <Foundation/Foundation.h>
    
27. int *minArr(int arr[],int len);
    
28. int *maxArr(int arr[],int len);
    
29. int *minMaoPao(int arr[],int len);
    
30. int *maxMaoPao(int arr[], int len);
    
31. int main(int argc, const char * argv[]) {
    
32.    
    
33.     int arr [5] ={8,9,5,3,4};
    
34.     //数组元素从小到大打印
    
35.     //    int *minAr = minArr(arr,5);
    
36.     //    for (int i=0; i<5; i++) {
    
37.     //        printf("%d",minAr[i]);
    
38.     //    }
    
39.     //    printf("\n");
    
40.     //
    
41.     //    //数组元素从大到小打印
    
42.     //    int *maxAr = maxArr(arr,5);
    
43.     //    for (int i = 0; i<5; i++) {
    
44.     //        printf("%d",maxAr[i]);
    
45.     //    }
    
46.     //    printf("\n");
    
47.    
    
48.     //    //数组元素从小到大打印
    
49.     //    int *minMaoPaoArr = minMaoPao(arr,5);
    
50.     //    for (int i = 0; i<5; i++) {
    
51.     //        printf("%d",minMaoPaoArr[i]);
    
52.     //    }
    
53.     //    printf("\n");
    
54.    
    
55.     //数组元素从大到小打印
    
56.     int *maxMaoPaoArr = maxMaoPao(arr,5);
    
57.     for (int i = 0; i<5; i++) {
    
58.         printf("%d",maxMaoPaoArr[i]);
    
59.     }
    
60.     printf("\n");
    
61.    
    
62.     return 0;
    
63. }
    
64. 
    
65. //使用冒泡排序的方法,从小到大进行排序
    
66. int *minMaoPao(int arr[],int len){
    
67.     int temp =0;
    
68.     for (int i =0; i<len; i++) {//外层循环,
    
69.         for (int j=0; j<len-i; j++) {//内层循环,取出最值! j<len-i,忽略以排序好的值
    
70.             if(arr[j]>arr[j+1]){//两个相邻的元素进行比较,大的换到后面去!
    
71.                 temp = arr[j];
    
72.                 arr[j] =arr[j+1];
    
73.                 arr[j+1] = temp;
    
74.             }
    
75.         }
    
76.     }
    
77.     return arr;
    
78. }
    
79. 
    
80. //使用冒泡排序的方法,将数组元素,从大到小排序
    
81. int *maxMaoPao(int arr[], int len){
    
82.     int temp = 0;
    
83.     for (int i = 0; i<len; i++) {
    
84.         for (int j=0; j<len-i; j++) {
    
85.             if (arr[j]<arr[j+1]) {
    
86.                 temp = arr[j];
    
87.                 arr[j] = arr[j+1];
    
88.                 arr[j+1] = temp;
    
89.             }
    
90.         }
    
91.     }
    
92.     return arr;
    
93. }
    
94. //将数组元素从小到大排序
    
95. int *minArr(int arr[],int len){
    
96.    
    
97.     int temp = 0;
    
98.     for (int i = 0; i<len; i++) {
    
99.         //去除已经排序好的元素
    
100.         //假设一个元素为最值!arr[0]/arr[1]/arr[2]...
     
101.         int minIndex = i;
     
102.         for (int j=i; j<len; j++) {//j=i,再次循环时,会忽略以排好的元素
     
103.             if (arr[minIndex]>arr[j]) {
     
104.                 minIndex =j;//求出最小值的下标
     
105.             }
     
106.         }
     
107.         //既要将最小值给arr[0]的元素,又要将原本arr[0]的值,拿去跟别的值进行比较 --交换
     
108.         temp = arr[minIndex];
     
109.         arr[minIndex] = arr[i];
     
110.         arr[i]=temp;
     
111.     }
     
112.     return arr;//这时候返回的是个指针?也就是首字母的地址
     
113. }
     
114. //将数组元素从大到小的排序
     
115. int *maxArr(int arr[],int len){
     
116.     int temp = 0;
     
117.     for (int i = 0; i<len; i++) {
     
118.         int maxIndex = i;
     
119.         for (int j = i; j<len; j++) {//注意:j=i,这是忽略已经排好序的元素
     
120.             if (arr[maxIndex]<arr[j]) {
     
121.                 maxIndex = j;
     
122.             }
     
123.         }
     
124.         //交换值
     
125.         temp = arr[maxIndex];
     
126.         arr[maxIndex] = arr[i];
     
127.         arr[i] = temp;
     
128.     }
     
129.    
     
130.     return arr;
     
131. }

复制代码