1.字符串翻轉(zhuǎn)

   char str[] = "abcde";
   reservString(str);

reservString具體實(shí)現(xiàn)如下

    void reservString(char* str){
          //算法基本思路就是頭尾指針指向字符串的頭部和尾部劫拢，然后依次交換頭尾指針的值搓幌。循環(huán)的終止條件是頭指針小于尾指針
          char* begin = str;
          char* end = str + strlen(str) - 1;
          while (begin < end) {
              char temp = *begin;
              *(begin++) = *end;
              *(end--) = temp;
           }

          printf("%s",str); //輸出edcba
     }

2.鏈表原地翻轉(zhuǎn)

    //定義一個(gè)鏈表節(jié)點(diǎn)
    struct Node{
        int data;
        struct Node *next;
    };
    //幾個(gè)鏈表操作的基本方法
    //1構(gòu)建一個(gè)鏈表
    struct Node* constructList(void){
        struct Node* head = NULL;
        struct Node* cur = NULL;
        for (int i = 0; i < 10; i++) {
            struct Node* node = malloc(sizeof(struct Node));
            node->data = rand() % 100;
            if(head == NULL){
                head = node;
            }else{
                cur->next = node;
            }
              //設(shè)置當(dāng)前節(jié)點(diǎn)為新節(jié)點(diǎn)
            cur = node;
        }

        cur->next = NULL;
        return head;
    }
    //2.打印一個(gè)鏈表
    void printList(struct Node* head){
        struct Node* cur = head;
        while (cur != NULL) {
            printf("%d->",cur->data);
            cur = cur->next;
        }
        printf("NULL\n");
    };
    //3.原地翻轉(zhuǎn)鏈表并返回新鏈表的頭結(jié)點(diǎn)嫌佑，頭插法
   struct Node* reverseList(struct Node* head){
        struct Node* p = head;
        struct Node* newH = NULL;
        while (p != NULL) {
            struct Node* temp = p;
            p = p->next;
            temp->next = newH;
            newH = temp;
        }
        return newH;
    }
    //測試代碼
    struct Node* head = constructList();
    printList(head);
    //打印出來:7->49->73->58->30->72->44->78->23->9->NULL
    struct Node* newH =  reverseList(head);
    printList(newH);
    //打印結(jié)果:9->23->78->44->72->30->58->73->49->7->NULL

3.合并有序數(shù)組豆茫，盡可能快

    void chainSortArray(int aArray[], int aLen,int bArray[],int bLen,int result[]){
        int aIndex = 0;
        int bIndex = 0;
        int sortIndex = 0;
        while (aIndex < aLen && bIndex < bLen) {
            if(aArray[aIndex] < bArray[bIndex]){
                result[sortIndex] = aArray[aIndex];
                aIndex++;
            }else{
                result[sortIndex] = bArray[bIndex];
                bIndex++;
            }
            sortIndex++;
        }

        //將剩下沒有比較完的數(shù)組的東西放到數(shù)組中
        while (aIndex < aLen) {
            result[sortIndex] = aArray[aIndex++];
            sortIndex++;
        }

          while (bIndex < bLen) {
            result[sortIndex] = bArray[bIndex++];
            sortIndex++;
        }

   }
    //測試用例ex:
        int a[] = {0,8,9,10,13,16};
        int b[] = {1,4,7,8,45};
        int result[11] = {0};
        chainSortArray(a, 6, b, 5, result);
        for (int i = 0; i < 11; i++) {
            printf("%d,",result[i]);
            //打印結(jié)果:0,1,4,7,8,8,9,10,13,16,45,
         }

4.查找一個(gè)字符串中第一個(gè)出現(xiàn)1次的字符

    char hashFind(char *str){
        //采用hash算法的思想 hash算法就是字符ascii碼就是對(duì)應(yīng)的hash index
        int array[256] = {0};
        char *p = str;
        while (*p != '\0') {
              array[*p]++;
              p++;
        }

        p = str;
        //**這里注意** 這里是遍歷原來的字符數(shù)組侨歉，而不是遍歷hash 數(shù)組
        while (*p != '\0') {
            if(array[*p] == 1){
                return *p;
            }
            p++;
        }

        return *p;
    }

5.求x的n次方

    //遞歸的思想,而且需要考慮邊界條件
    double qart(double x, int n){
        if(n == 0){
            return 1;
        }else if(n > 0){
            return qart_sub(x, n);
        }else{
            return  1 / qart_sub(x, abs(n));
        }
    }


    double qart_sub(double x, int n){
        if(n == 0){
              return 1;
       }else {
            return x * qart(x, n - 1);
        }
        return x;
    }
    //測試用例ex:
    double res = qart(2, -5);
     printf("結(jié)果為:%.6f\n",res); //結(jié)果為:0.031250

6.寫一個(gè)快速排序

    //將從left起到right的子數(shù)組 做中間元素的分割
    int partition(int arr[], int left,  int right){
        int i = left;
        int j = right;
        int tmp = arr[left];
        while (i < j) {
            //從右往左掃描
            while (i < j && arr[j] > tmp) {
                j--;
            }
            //遇到比分割元素小的元素,將元素挪到數(shù)組左邊填坑
            if(i < j){
                arr[i] = arr[j];
                i++;
            }
            //從左往右掃描
            while (i < j && arr[i] < tmp) {
                i++;
            }
            //遇到比b分割元素大的元素，將元素挪到數(shù)組右邊填坑
            if(i < j){
                arr[j] = arr[i];
                j--;
            }
        }
        //放置分割元素,arr[left,i-1] 全部小于 arr[i] arr[i+1,right]全部大于arr[i]
        arr[i] = tmp;
        return i;
    }

    void quickSort(int array[],int left, int right){
        if (left > right)
            return;
        int j = partition(array, left, right);
        //分治法揩魂，劃分子問題幽邓，遞歸解決子問題
        quickSort(array, left, j-1);
        quickSort(array, j+1, right);

    }
    //測試ex:
    int arrayEx[20] = {0};
        for (int i = 0; i < 20; i++) {
            arrayEx[i] = arc4random() % 100;
        }
        quickSort(arrayEx, 0, 19);

        for(int i = 0; i < 20; i++){
            printf("%d,",arrayEx[i]);
        }
      //輸出：8,11,12,20,20,28,43,46,48,52,55,65,66,70,72,74,76,78,80,99,

7.求一個(gè)無序數(shù)組的中位數(shù)

   // 使用快速排序的思想，左右交替掃描
  int findMedianNumber(int array[], int aLen){

        //中位數(shù)的在數(shù)組中的index
        int mid = (aLen - 1)/2;
        //利用快排的分割思想
        int div = partition(array, 0, aLen - 1);
        while (mid != div) {
            if(mid < div){
                div = partition(array, 0, div - 1);
            }else{
                div = partition(array, div + 1, aLen - 1);
            }
        }
        return array[mid];
    }
    //測試用例ex：
     int array2[] = {2,13,9,5,7,20,18,3,8,10};
    int median = findMedianNumber(array2, 10);
    printf("中位數(shù)%d",median);
    //輸出 8

8.求一個(gè)鏈表的中間節(jié)點(diǎn)

    //采用快慢指針的方式
    //返回中間節(jié)點(diǎn)
    struct Node* findLinkMedian(struct Node *head){
        //一次走一步
        struct Node* slowPtr = head;
        //一次走兩步
        struct Node* fastPtr = head;

        while (fastPtr != NULL) {
          //當(dāng)快指針走到最后的時(shí)候火脉，慢指針指向的就是中間節(jié)點(diǎn)
           if(fastPtr->next == NULL){
                break;
            }
            slowPtr = slowPtr->next;
            fastPtr = fastPtr->next->next;
        }
        return slowPtr;
    }
    //測試代碼ex:用到了前面2鏈表翻轉(zhuǎn)的數(shù)據(jù)結(jié)構(gòu)和方法
     struct Node *head1 = constructList();
        printList(head1);
        struct Node* medianNode = findLinkMedian(head1);
        printf("中間節(jié)點(diǎn)是 %d",medianNode->data);
        //答應(yīng)結(jié)果:
        //3->69->9->57->60->33->99->78->16->35->97->26->12->67->10->33->79->49->79->21->NULL
        //中間節(jié)點(diǎn)是 97

9.求兩個(gè)view的共同父視圖

10.檢測鏈表中是否有環(huán)

    //鏈表中環(huán)的檢測
        int isHaveCircleInList(struct Node *head){
        //定義兩個(gè)指針 快慢指針 如果快慢指針能相遇 說明有環(huán)的存在
        if (head == NULL) {
            return 0;
        }

        if(head->next == NULL){
            return 0;
        }

        struct Node* slowHead = head;
        struct Node* fasthead = head;
        while (slowHead != NULL && fasthead != NULL) {
            slowHead = slowHead->next;
            fasthead = fasthead->next->next;
            if(slowHead == fasthead){
                return 1;
            }
        }
        return 0;
    }

11.兩個(gè)有序鏈表的合并

    //兩個(gè)有序的鏈表合并
    struct Node* mergerTwoOrderList(struct Node* list1, struct Node* list2){
        if(list1 == NULL){
            return list2;
        }
        if(list2 == NULL){
            return list1;
        }

        struct Node *cur1 = list1;
        struct Node *cur2 = list2;
        struct Node *newHead = NULL;
        struct Node *cur = NULL;
        while (cur1 != NULL && cur2 != NULL) {
            if(cur1->data < cur2->data){
                if(newHead == NULL){
                    newHead = cur1;
                    cur = newHead;
                }else{
                    cur->next = cur1;
                    cur = cur1;
                }
                cur1 = cur1->next;
              }else{
                  if(newHead == NULL){
                      newHead = cur2;
                    cur = newHead;
                }else{
                    cur->next = cur2;
                    cur = cur2;
                }
                cur2 = cur2->next;
            }
        }
while (cur1 != NULL) {
    cur->next = cur1;
    cur = cur1;
    cur1 = cur1->next;
}

while (cur2 != NULL) {
    cur->next = cur2;
    cur = cur2;
    cur2 = cur2->next;
}
cur->next = NULL;
return newHead;
    }