zoukankan      html  css  js  c++  java
  • c14---排序,查找

    //
    //  main.c
    //  冒泡排序
    //
    //  Created by xiaomage on 15/6/10.
    //  Copyright (c) 2015年 xiaomage. All rights reserved.
    //
    
    #include <stdio.h>
    
    int main(int argc, const char * argv[]) {
        /*
         思路: 
         1.先分析如何比较
         2.找出比较的规律比较完一次之后第二次比较会少一次
         3.打印倒三角
         4.打印需要比较的角标
         5.比较并交换位置
         6.将常量替换为变量(length)
         */
        // 已知一个无序的数组, 里面有5个元素, 要求对数组进行排序
        int nums[6] = {99, 12, 88, 34, 5, 7};
        int length = sizeof(nums) / sizeof(nums[0]);
        for (int i = 0; i < length; i++) {
            printf("nums[%i] = %i
    ", i, nums[i]);
        }
        for (int i = 0; i < length - 1; i++) {
            for (int j = 0; j < length - 1 - i; j++) {
    //            printf("*");
    //            printf("%i == %i
    ", j, j+1);
                if (nums[j] > nums[j + 1]) {
                    int temp = nums[j];
                    nums[j] = nums[j + 1];
                    nums[j + 1] = temp;
                }
            }
    //        printf("
    ");
        }
        printf("----------
    ");
        for (int i = 0; i < length; i++) {
            printf("nums[%i] = %i
    ", i, nums[i]);
        }
        return 0;
    }
    //
    //  main.c
    //  选择-冒泡排序优化
    //
    //  Created by xiaomage on 15/6/10.
    //  Copyright (c) 2015年 xiaomage. All rights reserved.
    //
    
    #include <stdio.h>
    
    void selectSort(int nums[], int length);
    void printArray(int nums[], int length);
    //void swap(int v1, int v2);
    void swap(int nums[], int i, int j);
    void bubbleSort(int nums[], int length);
    
    int main(int argc, const char * argv[])
    {
        // 已知一个无序的数组, 里面有5个元素, 要求对数组进行排序
        int nums[8] = {99, 12, 88, 34, 5, 44, 12, 100};
        int length = sizeof(nums) / sizeof(nums[0]);
        
        printArray(nums, length);
    //    selectSort(nums, length);
        bubbleSort(nums, length);
        
        printf("----------------
    ");
        printArray(nums, length);
    
        return 0;
    }
    
    // 遍历数组
    void printArray(int nums[], int length)
    {
        for (int i = 0; i < length; i++) {
            printf("nums[%i] = %i
    ", i, nums[i]);
        }
    }
    
    void bubbleSort(int nums[], int length)
    {
        for (int i = 0; i < length - 1; i++) {
            for (int j = 0; j < length - 1 - i; j++) {
                if (nums[j] > nums[j + 1]) {
                    swap(nums, j, j+1);
                }
            }
        }
    }
    
    // 选择排序
    void selectSort(int nums[], int length)
    {
        for (int i = 0; i < length - 1; i++) {
            for (int j = i+1; j < length; j++) {
                if (nums[i] > nums[j]) {
                    /*
                    int temp = nums[i];
                    nums[i] = nums[j];
                    nums[j] = temp;
                     */
    //                swap(nums[i], nums[j]);
                    swap(nums, i, j);
                }
            }
        }
    
    }
    
    // 基本数据类型作为函数的参数, 是值传递, 在函数中修改形参不会影响实参的值
    /*
    void swap(int v1, int v2)
    {
        int temp = v1;
        v1 = v2;
        v2 = temp;
    }
     */
    // 交换两个数的值
    void swap(int nums[], int i, int j)
    {
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
    //
    //  main.c
    //  折半查找
    //
    //  Created by xiaomage on 15/6/10.
    //  Copyright (c) 2015年 xiaomage. All rights reserved.
    //
    
    #include <stdio.h>
    #include <time.h>
    
    int findKey(int nums[], int key, int length);
    int findKey2(int nums[], int length, int key);
    int findKey3(int nums[], int length, int key);
    
    int main(int argc, const char * argv[]) {
        // 现在已知一个有序的数组, 和一个key. 要求从数组中找到key对应的索引的位置
        // 对该方法进行封装, 要求找到就返回对应的索引, 找不到就返回-1
        int nums[500000] = {1, 3, 5, 7, 9, [499999] = 99};
        int key = 99;
        int length = sizeof(nums) / sizeof(nums[0]);
        
        
         // 消耗了多少1181毫秒
        clock_t startTime = clock();
        int index =  findKey(nums, key, length);
        clock_t endTime = clock();
        printf("消耗了多少%lu毫秒
    ", endTime - startTime);
        printf("index = %i
    ", index);
        
        
        // 消耗了多少1毫秒
        clock_t startTime = clock();
    //    int index = findKey2(nums, length, key);
        // 消耗了多少2毫秒
        int index = findKey3(nums, length, key);
        clock_t endTime = clock();
        printf("消耗了多少%lu毫秒
    ", endTime - startTime);
        printf("index = %i
    ", index);
        
        return 0;
    }
    
    int findKey3(int nums[], int length, int key)
    {
        int min, max, mid;
        min = 0;
        max = length - 1;
        
        // 只要还在我们的范围内就需要查找
        while (min <= max) {
            // 计算中间值
            mid = (min  + max) / 2;
            if (key > nums[mid]) {
                min = mid + 1;
            }else if (key < nums[mid])
            {
                max = mid - 1;
            }else
            {
                return mid;
            }
            
        }
        return -1;
    }
    
    int findKey2(int nums[], int length, int key)
    {
        int min, max, mid;
        min = 0;
        max = length - 1;
        mid = (min + max) / 2;
        
        while (key != nums[mid]) {
            // 判断如果要找的值, 大于了取出的值, 那么min要改变
            if (key > nums[mid]) {
                min = mid + 1;
            // 判断如果要找的值, 小雨了取出的值, 那么max要改变
            }else if (key < nums[mid])
            {
                max = mid - 1;
            }
            
            // 超出范围, 数组中没有需要查找的值
            if (min > max) {
                return -1;
            }
            // 每次改变完min和max都需要重新计算mid
            mid = (min + max) / 2;
        }
        printf("aaaaaa
    ");
        
        return mid;
    
    }
    
    int findKey(int nums[], int key, int length)
    {
        for (int i = 0; i < length; i++) {
            if (nums[i] == key) {
                printf("%i
    ", i);
                return i;
            }
        }
        return -1;
    }
    //
    //  main.c
    //  折半查找练习
    //
    //  Created by xiaomage on 15/6/10.
    //  Copyright (c) 2015年 xiaomage. All rights reserved.
    //
    
    #include <stdio.h>
    
    int insertValue(int nums[], int length, int key);
    
    int main(int argc, const char * argv[]) {
        // 现有一个有序的数组, 要求给定一个数字, 将该数字插入到数组中, 还要保证数组是有序的
        // 其实就是找到需要插入数字的位置
        // 其实这个位置就是min的位置
        /*
         min = 0
         max = 4
         mid = 2
         */
    //                 0  1  2  3  4  5
        int nums[5] = {1, 3, 5, 7,9};
        int key = 4;
        int length = sizeof(nums) / sizeof(nums[0]);
        printf("需要插入的位置是%i
    ", insertValue(nums, length, key));
               
        return 0;
    }
    
    int insertValue(int nums[], int length, int key)
    {
        int min , max, mid;
        min = 0;// 1 2
        max = length - 1;// 4  1
        while (min <= max) {
            mid = (min + max) / 2; // 2 0 1
            if (key > nums[mid]) {
                min = mid + 1;
            }else if (key < nums[mid])
            {
                max = mid - 1;
            }
        }
        return min;
    }
    //
    //  main.c
    //  进制查表法
    //
    //  Created by xiaomage on 15/6/10.
    //  Copyright (c) 2015年 xiaomage. All rights reserved.
    //
    
    #include <stdio.h>
    void printfBinary(int value);
    void printfBinary2(int value);
    void printOct(int value);
    void printfHex(int value);
    
    void printfHex2(int value);
    void printfOct2(int value);
    void printfBinary3(int value);
    
    int main(int argc, const char * argv[]) {
        /*
             0000000000000000000000000000
         00000000000000000000000000000111
         */
        int num = 10;// 1010;
    //    printfBinary2(num);
    //    printOct(num);
    //    printfHex2(num);
    //    printfOct2(num);
        printfBinary3(num);
        return 0;
    }
    
    void printfBinary3(int value)
    {
        // 1.定义一个数组, 用于保存二进制中所有的取值
        char charValues[] = {'0', '1'};
        // 2.定义一个数组, 用于保存查询后的结果
        char results[32] = {'0'};
        // 3.定义一个变量, 用于记录当前需要存储到查询结果数组的索引
        int pos = 32;
        
        while (value != 0) {
            // 1.取出1位的值
            int res = value & 1;
            // 2.利用取出来得值到表中查询对应的结果
            char c = charValues[res];
            // 3.存储查询的结果
            results[--pos] = c;
            // 4.移除二进制被取过的1位
            value = value >> 1;
        }
        
        // 4.打印结果
        for (int i = pos; i < 32; i++) {
            printf("%c", results[i]);
        }
        printf("
    ");
    
        
    }
    
    void printfOct2(int value)
    {
        // 1.定义一个数组, 用于保存八进制中所有的取值
        char charValues[] = {'0', '1', '2', '3', '4', '5', '6', '7'};
        // 2.定义一个数组, 用于保存查询后的结果
        char results[11] = {'0'};
        // 3.定义一个变量, 用于记录当前需要存储到查询结果数组的索引
        int pos = 11;
        while (value != 0) {
            // 1.取出3位的值
            int res = value & 7;
            // 2.利用取出来得值到表中查询对应的结果
            char c = charValues[res];
            // 3.存储查询的结果
            results[--pos] = c;
            // 4.移除二进制被取过的三位
            value = value >> 3;
        }
        
        // 4.打印结果
        for (int i = pos; i < 11; i++) {
            printf("%c", results[i]);
        }
        printf("
    ");
        
    }
    
    void printfHex2(int value)
    {
        // 1.定义一个数组, 用于保存十六进制中所有的取值
        // 规律: 取出的4个二进制位得到的值, 正好是数组中角标对应的值
        char charValues[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
    //                    '', '', '', '', '', '', '', ''
        char results[8] = {'0'};
        int pos = 8;
        
        while (value != 0) {
            // 取出4位的值
            int res = value & 15;
            // 利用这个值作为索引去数组中查询对应的十六进制的值
            char c = charValues[res];
    //        printf("%c", c);
            // 将取出来得值放到用于存储结果数组中
            results[--pos] = c;
            
            // 每取完一次就干掉它最低的4位
            value = value >> 4;
    //        printf("pos = %i
    ", pos);
        }
        
        for (int i = pos; i < 8; i++) {
            printf("%c", results[i]);
        }
        printf("
    ");
    }
    
    void printfHex(int value)
    {
        for (int i = 0; i <= 8; i++) {
            int res = value & 15; // 1111
            // 对十六进制进行特殊处理
            if (res > 9) {
                //  11 - 10 1 + a
                char c = res - 10 + 'a';
                printf("%c", c);
            }else
            {
                printf("%i", res);
            }
            value = value >> 4;
        }
    }
    
    void printOct(int value)
    {
        for (int i = 0; i <= 11; i++) {
            int res = value & 7; // 111
            printf("%i", res);
            value = value >> 3;
        }
    }
    
    void printfBinary2(int value)
    {
        for (int i = 0; i <= 32; i++) {
            int res = value & 1;
            printf("%i", res);
            value = value >> 1;
        }
        printf("
    ");
    }
    
    void printfBinary(int value)
    {
    //    int offset = sizeof(value) * 8 - 1;
        int offset = (sizeof(value) << 3) - 1;
        while (offset >= 0) {
            int res = (value >> offset) & 1;
            printf("%i", res);
            offset--;
        }
        printf("
    ");
    }
    //
    //  main.c
    //  进制查表法优化
    //
    //  Created by xiaomage on 15/6/10.
    //  Copyright (c) 2015年 xiaomage. All rights reserved.
    //
    
    #include <stdio.h>
    void total(int value, int base, int offset);
    void ptintBinary(int num);
    void printfOct(int num);
    void printfHex(int num);
    
    int main(int argc, const char * argv[]) {
        // insert code here...
    //    ptintBinary(10);
    //    printfOct(10);
        printfHex(10);
        return 0;
    }
    
    void printfHex(int num)
    {
        total(num, 15, 4);
    }
    
    void printfOct(int num)
    {
        total(num, 7, 3);
    }
    
    void ptintBinary(int num)
    {
        total(num, 1, 1);
    }
    
    // 转换所有的进制
    // value就是需要转换的数值
    // base就是需要&上的数
    // offset就是需要右移的位数
    void total(int value, int base, int offset)
    {
        // 1.定义一个数组, 用于保存十六进制中所有的取值
        char charValues[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
        // 2.定义一个数组, 用于保存查询后的结果
        char results[32] = {'0'};
        // 3.定义一个变量, 用于记录当前需要存储到查询结果数组的索引
        int pos = sizeof(results)/ sizeof(results[0]);
        
        while (value != 0) {
            // 1.取出1位的值
            int res = value & base;// 1 7 15
            // 2.利用取出来得值到表中查询对应的结果
            char c = charValues[res];
            // 3.存储查询的结果
            results[--pos] = c;
            // 4.移除二进制被取过的1位
            value = value >> offset;// 1 3 4
        }
        
        // 4.打印结果
        for (int i = pos; i < 32; i++) {
            printf("%c", results[i]);
        }
        printf("
    ");
        
    }
  • 相关阅读:
    克如斯卡尔 P1546
    真正的spfa
    第四课 最小生成树 要点
    关于vscode中nullptr未定义
    cmake学习笔记
    python学习笔记
    (BFS 图的遍历) 2906. kotori和迷宫
    (图论基础题) leetcode 997. Find the Town Judge
    (BFS DFS 并查集) leetcode 547. Friend Circles
    (BFS DFS 图的遍历) leetcode 841. Keys and Rooms
  • 原文地址:https://www.cnblogs.com/yaowen/p/7384329.html
Copyright © 2011-2022 走看看