數(shù)組翻轉(zhuǎn)
NSMutableArray *temp = [NSMutableArray arrayWithObjects:@"1",@"2",@"3",@"4",@"5",@"6",nil];
NSArray *reverseArr = [[temp reverseObjectEnumerator] allObjects];
數(shù)組升序
NSMutableArray *temp = [NSMutableArray arrayWithObjects:@"4",@"2",@"3",@"1",@"5",@"6",nil];
NSArray *result = [temp sortedArrayUsingComparator:^NSComparisonResult(id _Nonnull obj1, id _Nonnull obj2) {
return [obj1 compare:obj2];
}];
數(shù)組降序
NSMutableArray *temp = [NSMutableArray arrayWithObjects:@"4",@"2",@"3",@"1",@"5",@"6",nil];
NSArray *result = [temp sortedArrayUsingComparator:^NSComparisonResult(id _Nonnull obj1, id _Nonnull obj2) {
return [obj2 compare:obj1];
}];
獲取數(shù)組對象和，平均數(shù)，最大值，最小值
NSArray *array = [NSArray arrayWithObjects:@"2.0", @"2.3", @"3.0", @"4.0", @"10", nil];
CGFloat sum = [[array valueForKeyPath:@"@sum.floatValue"] floatValue];
CGFloat avg = [[array valueForKeyPath:@"@avg.floatValue"] floatValue];
CGFloat max =[[array valueForKeyPath:@"@max.floatValue"] floatValue];
CGFloat min =[[array valueForKeyPath:@"@min.floatValue"] floatValue];
冒泡排序
原理：比較兩個相鄰的元素，將值大的元素交換至右端。
思路：依次比較相鄰的兩個數(shù)，將小數(shù)放在前面，大數(shù)放在后面。即在第一趟：首先比較第1個和第2個數(shù)，將小數(shù)放前，大數(shù)放后。然后比較第2個數(shù)和第3個數(shù)，將小數(shù)放前，大數(shù)放后，如此繼續(xù)，直至比較最后兩個數(shù)，將小數(shù)放前，大數(shù)放后。重復(fù)第一趟步驟，直至全部排序完成。
第一趟比較完成后，最后一個數(shù)一定是數(shù)組中最大的一個數(shù)，所以第二趟比較的時候最后一個數(shù)不參與比較；
第二趟比較完成后，倒數(shù)第二個數(shù)也一定是數(shù)組中第二大的數(shù)，所以第三趟比較的時候最后兩個數(shù)不參與比較；
依次類推，每一趟比較次數(shù)-1；
1.冒泡升序
- (void)bubbleAscSortWithArray:(NSMutableArray *)array
{
for (int i = 0; i < array.count; i++) {
for (int j = 0; j < array.count - i-1; j++) {
if ([array[j] intValue] > [array[j + 1] intValue]) {
int tmp = [array[j] intValue];
array[j] = array[j + 1];
array[j + 1] = [NSNumber numberWithInt:tmp];
}
}
}
NSLog(@"冒泡升序后結(jié)果：%@", array);
}
2.冒泡降序
- (void)bubbleDescSortWithArray:(NSMutableArray *)array
{
for (int i = 0; i < array.count; i++) {
for (int j = 0; j < array.count - i - 1;j++) {
if ([array[j] intValue] < [array[j + 1] intValue]) {
int temp = [array[j] intValue];
array[j] = array[j + 1];
array[j + 1] = [NSNumber numberWithInt:temp];
}
}
}
NSLog(@"冒泡降序后結(jié)果：%@", array);
}
選擇排序
原理：每一趟從待排序的記錄中選出最小的元素，順序放在已排好序的序列最后，直到全部記錄排序完畢。也就是：每一趟在n-i+1(i=1，2，…n-1)個記錄中選取關(guān)鍵字最小的記錄作為有序序列中第i個記錄。
簡單選擇排序的基本思想：從數(shù)組的第i個元素開始到第n個元素，尋找最小的元素。（具體過程為:先設(shè)arr[i]為最小，逐一比較，若遇到比之小的則交換）。
給定數(shù)組：int[] arr={里面n個數(shù)據(jù)}；第1趟排序，在待排序數(shù)據(jù)arr[1]-arr[n]中選出最小的數(shù)據(jù)，將它與arrr[1]交換；第2趟，在待排序數(shù)據(jù)arr[2]-arr[n]中選出最小的數(shù)據(jù)，將它與r[2]交換；以此類推，第i趟在待排序數(shù)據(jù)arr[i]-arr[n]中選出最小的數(shù)據(jù)，將它與r[i]交換，直到全部排序完成。
舉例：數(shù)組 int[] arr={5,2,8,4,9,1};
第一趟排序： 原始數(shù)據(jù)：5 2 8 4 9 1
最小數(shù)據(jù)1，把1放在首位，也就是1和5互換位置，
排序結(jié)果：1 2 8 4 9 5
第二趟排序：
第1以外的數(shù)據(jù){2 8 4 9 5}進(jìn)行比較，2最小，
排序結(jié)果：1 2 8 4 9 5
第三趟排序：
除1、2以外的數(shù)據(jù){8 4 9 5}進(jìn)行比較，4最小，8和4交換
排序結(jié)果：1 2 4 8 9 5
第四趟排序：
除第1、2、4以外的其他數(shù)據(jù){8 9 5}進(jìn)行比較，5最小，8和5交換
排序結(jié)果：1 2 4 5 9 8
第五趟排序：
除第1、2、4、5以外的其他數(shù)據(jù){9 8}進(jìn)行比較，8最小，8和9交換
排序結(jié)果：1 2 4 5 8 9
選擇升序排序
- (void)selectionAscendingOrderSortWithArray:(NSMutableArray *)array
{
for (int i = 0; i < array.count; i ++) {
for (int j = i + 1; j < array.count; j ++) {
if ([array[i] integerValue] > [array[j] integerValue]) {
int temp = [array[i] intValue];
array[i] = array[j];
array[j] = [NSNumber numberWithInt:temp];
}
}
}
NSLog(@"選擇升序排序后結(jié)果：%@", array);
}
選擇降序
- (void)selectionDescendingOrderSortWithArray:(NSMutableArray *)array
{
for (int i = 0; i < array.count; i ++) {
for (int j = i + 1; j < array.count; j ++) {
if ([array[i] integerValue] < [array[j] integerValue]) {
int temp = [array[i] intValue];
array[i] = array[j];
array[j] = [NSNumber numberWithInt:temp];
}
}
}
NSLog(@"選擇降序排序后結(jié)果：%@", array);
}
快速排序
參考資料：https://blog.csdn.net/qq_32062459/article/details/78258161
基本實現(xiàn)思路：
- 從數(shù)列中挑出一個元素，稱為 "基準(zhǔn)"
- 重新排序數(shù)列，所有元素比基準(zhǔn)值小的擺放在基準(zhǔn)前面，所有元素比基準(zhǔn)值大的擺在基準(zhǔn)的后面（相同的數(shù)可以到任一邊）。在這個分割之后，該基準(zhǔn)是它的最后位置。這個稱為分割操作。
- 遞歸地把小于基準(zhǔn)值元素的子數(shù)列和大于基準(zhǔn)值元素的子數(shù)列排序。
假設(shè)我們現(xiàn)在對“6 1 2 7 9 3 4 5 10 8”這個10個數(shù)進(jìn)行排序。首先在這個序列中隨便找一個數(shù)作為基準(zhǔn)數(shù)（不要被這個名詞嚇到了，就是一個用來參照的數(shù)，待會你就知道它用來做啥的了）。為了方便，就讓第一個數(shù)6作為基準(zhǔn)數(shù)吧。接下來，需要將這個序列中所有比基準(zhǔn)數(shù)大的數(shù)放在6的右邊，比基準(zhǔn)數(shù)小的數(shù)放在6的左邊，類似下面這種排列。
3 1 2 5 4 6 9 7 10 8
分別從初始序列“6 1 2 7 9 3 4 5 10 8”兩端開始“探測”。先從右往左找一個小于6的數(shù)，再從左往右找一個大于6的數(shù)，然后交換他們。這里可以用兩個變量i和j，分別指向序列最左邊和最右邊。我們?yōu)檫@兩個變量起個好聽的名字“哨兵i”和“哨兵j”。剛開始的時候讓哨兵i指向序列的最左邊（即i=1），指向數(shù)字6。讓哨兵j指向序列的最右邊（即j=10），指向數(shù)字8。
首先哨兵j開始出動。因為此處設(shè)置的基準(zhǔn)數(shù)是最左邊的數(shù)，所以需要讓哨兵j先出動，這一點(diǎn)非常重要（請自己想一想為什么）。哨兵j一步一步地向左挪動（即j--），直到找到一個小于6的數(shù)停下來。接下來哨兵i再一步一步向右挪動（即i++），直到找到一個數(shù)大于6的數(shù)停下來。最后哨兵j停在了數(shù)字5面前，哨兵i停在了數(shù)字7面前。
現(xiàn)在交換哨兵i和哨兵j所指向的元素的值。交換之后的序列如下。
6 1 2 5 9 3 4 7 10 8
到此，第一次交換結(jié)束。接下來開始哨兵j繼續(xù)向左挪動（再友情提醒，每次必須是哨兵j先出發(fā)）。他發(fā)現(xiàn)了4（比基準(zhǔn)數(shù)6要小，滿足要求）之后停了下來。哨兵i也繼續(xù)向右挪動的，他發(fā)現(xiàn)了9（比基準(zhǔn)數(shù)6要大，滿足要求）之后停了下來。此時再次進(jìn)行交換，交換之后的序列如下。
6 1 2 5 4 3 9 7 10 8
第二次交換結(jié)束，“探測”繼續(xù)。哨兵j繼續(xù)向左挪動，他發(fā)現(xiàn)了3（比基準(zhǔn)數(shù)6要小，滿足要求）之后又停了下來。哨兵i繼續(xù)向右移動，糟啦！此時哨兵i和哨兵j相遇了，哨兵i和哨兵j都走到3面前。說明此時“探測”結(jié)束。我們將基準(zhǔn)數(shù)6和3進(jìn)行交換。交換之后的序列如下。
3 1 2 5 4 6 9 7 10 8
到此第一輪“探測”真正結(jié)束。此時以基準(zhǔn)數(shù)6為分界點(diǎn)，6左邊的數(shù)都小于等于6，6右邊的數(shù)都大于等于6?；仡櫼幌聞偛诺倪^程，其實哨兵j的使命就是要找小于基準(zhǔn)數(shù)的數(shù)，而哨兵i的使命就是要找大于基準(zhǔn)數(shù)的數(shù)，直到i和j碰頭為止。
OK，解釋完畢。現(xiàn)在基準(zhǔn)數(shù)6已經(jīng)歸位，它正好處在序列的第6位。此時我們已經(jīng)將原來的序列，以6為分界點(diǎn)拆分成了兩個序列，左邊的序列是“3 1 2 5 4”，右邊的序列是“9 7 10 8”。接下來還需要分別處理這兩個序列。因為6左邊和右邊的序列目前都還是很混亂的。不過不要緊，我們已經(jīng)掌握了方法，接下來只要模擬剛才的方法分別處理6左邊和右邊的序列即可?，F(xiàn)在先來處理6左邊的序列現(xiàn)吧。
左邊的序列是“3 1 2 5 4”。請將這個序列以3為基準(zhǔn)數(shù)進(jìn)行調(diào)整，使得3左邊的數(shù)都小于等于3，3右邊的數(shù)都大于等于3。好了開始動筆吧。
如果你模擬的沒有錯，調(diào)整完畢之后的序列的順序應(yīng)該是。
2 1 3 5 4
OK，現(xiàn)在3已經(jīng)歸位。接下來需要處理3左邊的序列“2 1”和右邊的序列“5 4”。對序列“2 1”以2為基準(zhǔn)數(shù)進(jìn)行調(diào)整，處理完畢之后的序列為“1 2”，到此2已經(jīng)歸位。序列“1”只有一個數(shù)，也不需要進(jìn)行任何處理。至此我們對序列“2 1”已全部處理完畢，得到序列是“1 2”。序列“5 4”的處理也仿照此方法，最后得到的序列如下。
1 2 3 4 5 6 9 7 10 8
對于序列“9 7 10 8”也模擬剛才的過程，直到不可拆分出新的子序列為止。最終將會得到這樣的序列，如下。
1 2 3 4 5 6 7 8 9 10
到此，排序完全結(jié)束。細(xì)心的同學(xué)可能已經(jīng)發(fā)現(xiàn)，快速排序的每一輪處理其實就是將這一輪的基準(zhǔn)數(shù)歸位，直到所有的數(shù)都?xì)w位為止，排序就結(jié)束了。下面上個霸氣的圖來描述下整個算法的處理過程。
快速排序之所比較快，因為相比冒泡排序，每次交換是跳躍式的。每次排序的時候設(shè)置一個基準(zhǔn)點(diǎn)，將小于等于基準(zhǔn)點(diǎn)的數(shù)全部放到基準(zhǔn)點(diǎn)的左邊，將大于等于基準(zhǔn)點(diǎn)的數(shù)全部放到基準(zhǔn)點(diǎn)的右邊。這樣在每次交換的時候就不會像冒泡排序一樣每次只能在相鄰的數(shù)之間進(jìn)行交換，交換的距離就大的多了。因此總的比較和交換次數(shù)就少了，速度自然就提高了。當(dāng)然在最壞的情況下，仍可能是相鄰的兩個數(shù)進(jìn)行了交換。因此快速排序的最差時間復(fù)雜度和冒泡排序是一樣的都是O(N2)，它的平均時間復(fù)雜度為O(NlogN)。其實快速排序是基于一種叫做“二分”的思想。
- (void)quickSortArray:(NSMutableArray *)array leftIndex:(NSInteger)leftIndex rightIndex:(NSInteger)rightIndex
{
if (leftIndex >= rightIndex) {//如果數(shù)組長度為0或1時返回
return ;
}
NSInteger left = leftIndex;
NSInteger right = rightIndex;
//記錄比較基準(zhǔn)數(shù)
NSInteger base = [array[left] integerValue];
while (left < right) {
/**** 首先從右邊開始查找比基準(zhǔn)數(shù)小的值 ***/
while (left < right && [array[right] integerValue] >= base) {//如果比基準(zhǔn)數(shù)大，繼續(xù)查找
right--;
}
if (left < right) {
array[left] = array[right];
}
/**** 當(dāng)在右邊查找到一個比基準(zhǔn)數(shù)小的值時，就從i開始往后找比基準(zhǔn)數(shù)大的值 ***/
while (left < right && [array[left] integerValue] <= base) {//如果比基準(zhǔn)數(shù)小，繼續(xù)查找
left++;
}
if (left < right) {
array[right] = array[left];
}
}
//將基準(zhǔn)數(shù)放到正確位置
array[left] = [NSNumber numberWithInteger:base];
/**** 遞歸排序 ***/
//排序基準(zhǔn)數(shù)左邊的
[self quickSortArray:array leftIndex:leftIndex rightIndex:left - 1];
//排序基準(zhǔn)數(shù)右邊的
[self quickSortArray:array leftIndex:left + 1 rightIndex:rightIndex];
NSLog(@"快速排序結(jié)果:%@",array);
}
