iOS 相关常见算法整理

 

1）冒牌排序：

-(void)MPSort{
    int array[]={1,5,8,9,3,6,0};
    for (int i=0; i<sizeof(array)/sizeof(array[0]); i++) {
        for (int j=0; j<sizeof(array)/ sizeof(array[0])-i-1; j++) {
            if (array[j] >array[j+1]) {
                int temp = array[j];
                array[j]=array[j+1];
                array[j+1]=temp;
            }
        }
    }
    
}

2）快速排序

 int array[]={1,5,8,9,3,6,0};
 sort(array ,0, 7);

void sort(int *a, int left, int right){
    
    if (left>=right) {
        return;
    }
    
    int i=left;
    int j=right;
    int key=a[left];
    
    while (i<j) {
        
        /*而寻找结束的条件就是，1，找到一个小于或者大于key的数（大于或小于取决于你想升
         序还是降序）2，没有符合条件1的，并且i与j的大小没有反转*/
        while (i<j&&key<=a[j]) {
            j--;
        }
        /*找到一个这样的数后就把它赋给前面的被拿走的i的值（如果第一次循环且key是
         a[left]，那么就是给key）*/
        a[i]=a[j];
        
        /*这是i在当组内向前寻找，同上，不过注意与key的大小关系停止循环和上面相反，
         因为排序思想是把数往两边扔，所以左右两边的数大小与key的关系相反*/
        while(i < j && key >= a[i]){
            i++;
        }
        a[j]=a[i];
        
        a[i] = key;/*当在当组内找完一遍以后就把中间数key回归*/
        sort(a, left, i - 1);/*最后用同样的方式对分出来的左边的小组进行同上的做法*/
        sort(a, i + 1, right);/*用同样的方式对分出来的右边的小组进行同上的做法*/
        /*当然最后可能会出现很多分左右，直到每一组的i = j 为止*/
        
    }
    
    
}

 

3) 二分查找

void find(int *a, int left, int right,int value){
    
   
    while (left<=right) {
        int mid=left+(right-left)/2;
        if (a[mid]==value) {
            NSLog(@"%d",mid);
             return ;
        }else if (a[mid]>value){
            
            right=mid-1;
        }else{
            
            left=mid+1;
        }
        find(a, left, right, value);
        
    }
    
}

4)字符串反转

-(void)strChange{
    char str[]="hello word";
    char *begin=str;
    char *end=str+strlen(str)-1;
    if (begin<end) {
        char temp=*end;
        *end=*begin;
        *begin=temp;
        begin++;
        end--;
    }
    
    NSLog(@"%s",str);
    dello worh
    
}

5) Pow(x, n) 求一个数的n次方 优化

最慢求递归
2^3=2*2*2
double pow(double x, int n){
    if(n == 0){
        return 1;
    }
    if(n > 0 ){
          return x * pow(x, n - 1);
     }else{
          return 1 /  pow(x, -n);
     }
    
}

优化后：
2^4=2^2*2^2
2^7=2^3*2^3*2

double pow(double x, int n){
	if(n == 0){
		return 1;
	}
        if(n > 0 ){
	    double half = pow(x, n / 2);
	    if(n % 2 == 0){
		return half * half;
	    }else{
		return half * half * x;
	    }			
	}else{
		return 1 /  pow(x, -n);
	}
}

请找出数组中的莫个数，他的左边相加等于右边

除了从头到尾的遍历，换个思路：既然某个数字的左边的值等于右边，那么可以算出数组的全部数值，然后加入一个二分查找的办法，定位到中间，如果左边的值*2=数组的和-当前位置的值，那么就可以说找到了，如果大于，那就向前移动，小于就向后移动。（为什么要左边的值*2，而不是（数组的和-当前位置的值)/2，
public static int splitFind(int[] array) {
    if (null == array || array.length == 0) {
        return -1;
    }
    int length = array.length;

    int head, tall, index;
    head = 0;
    tall = length - 1;
    index = length / 2;
    int total = 0;
    for (int i : array) {
        total += i;
    }
    do {
        int totalLeft = 0;
        for (int le = 0; le < index; le++) {
            totalLeft += array[le];
        }
        int doubleValue=(total - array[index]);
        if (totalLeft*2 < doubleValue) {
            head=index;
            index = index + (length - index) / 2;
        } else if (totalLeft*2 > doubleValue) {
            tall=index;
            index = head + (index - head) / 2;
        } else {
            return index;
        }
    } while (index > head && index < tall);
    return -1;
}

链表相关算法题

https://www.cnblogs.com/tojian/p/10055036.html