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[] = {, , , , , };
    int length = sizeof(nums) / sizeof(nums[]);
    for (int i = ; i < length; i++) {
        printf("nums[%i] = %i\n", i, nums[i]);
    }
    for (int i = ; i < length - ; i++) {
        for (int j = ; j < length -  - i; j++) {
//            printf("*");
//            printf("%i == %i\n", j, j+1);
            if (nums[j] > nums[j + ]) {
                int temp = nums[j];
                nums[j] = nums[j + ];
                nums[j + ] = temp;
            }
        }
//        printf("\n");
    }
    printf("----------\n");
    for (int i = ; i < length; i++) {
        printf("nums[%i] = %i\n", i, nums[i]);
    }
    return ;
}

//
//  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[] = {, , , , , , , };
    int length = sizeof(nums) / sizeof(nums[]);

    printArray(nums, length);
//    selectSort(nums, length);
    bubbleSort(nums, length);

    printf("----------------\n");
    printArray(nums, length);

    return ;
}

// 遍历数组
void printArray(int nums[], int length)
{
    for (int i = ; i < length; i++) {
        printf("nums[%i] = %i\n", i, nums[i]);
    }
}

void bubbleSort(int nums[], int length)
{
    for (int i = ; i < length - ; i++) {
        for (int j = ; j < length -  - i; j++) {
            if (nums[j] > nums[j + ]) {
                swap(nums, j, j+);
            }
        }
    }
}

// 选择排序
void selectSort(int nums[], int length)
{
    for (int i = ; i < length - ; i++) {
        for (int j = i+; 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[] = {, , , , , [] = };
    int key = ;
    int length = sizeof(nums) / sizeof(nums[]);

     // 消耗了多少1181毫秒
    clock_t startTime = clock();
    int index =  findKey(nums, key, length);
    clock_t endTime = clock();
    printf("消耗了多少%lu毫秒\n", endTime - startTime);
    printf("index = %i\n", 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毫秒\n", endTime - startTime);
    printf("index = %i\n", index);

    return ;
}

int findKey3(int nums[], int length, int key)
{
    int min, max, mid;
    min = ;
    max = length - ;

    // 只要还在我们的范围内就需要查找
    while (min <= max) {
        // 计算中间值
        mid = (min  + max) / ;
        if (key > nums[mid]) {
            min = mid + ;
        }else if (key < nums[mid])
        {
            max = mid - ;
        }else
        {
            return mid;
        }

    }
    return -;
}

int findKey2(int nums[], int length, int key)
{
    int min, max, mid;
    min = ;
    max = length - ;
    mid = (min + max) / ;

    while (key != nums[mid]) {
        // 判断如果要找的值, 大于了取出的值, 那么min要改变
        if (key > nums[mid]) {
            min = mid + ;
        // 判断如果要找的值, 小雨了取出的值, 那么max要改变
        }else if (key < nums[mid])
        {
            max = mid - ;
        }

        // 超出范围, 数组中没有需要查找的值
        if (min > max) {
            return -;
        }
        // 每次改变完min和max都需要重新计算mid
        mid = (min + max) / ;
    }
    printf("aaaaaa\n");

    return mid;

}

int findKey(int nums[], int key, int length)
{
    for (int i = ; i < length; i++) {
        if (nums[i] == key) {
            printf("%i\n", i);
            return i;
        }
    }
    return -;
}

//
//  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[] = {, , , ,};
    int key = ;
    int length = sizeof(nums) / sizeof(nums[]);
    printf("需要插入的位置是%i\n", insertValue(nums, length, key));

    return ;
}

int insertValue(int nums[], int length, int key)
{
    int min , max, mid;
    min = ;// 1 2
    max = length - ;// 4  1
    while (min <= max) {
        mid = (min + max) / ; // 2 0 1
        if (key > nums[mid]) {
            min = mid + ;
        }else if (key < nums[mid])
        {
            max = mid - ;
        }
    }
    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 = ;// 1010;
//    printfBinary2(num);
//    printOct(num);
//    printfHex2(num);
//    printfOct2(num);
    printfBinary3(num);
    return ;
}

void printfBinary3(int value)
{
    // 1.定义一个数组, 用于保存二进制中所有的取值
    char charValues[] = {'', ''};
    // 2.定义一个数组, 用于保存查询后的结果
    char results[] = {''};
    // 3.定义一个变量, 用于记录当前需要存储到查询结果数组的索引
    int pos = ;

    while (value != ) {
        // 1.取出1位的值
        int res = value & ;
        // 2.利用取出来得值到表中查询对应的结果
        char c = charValues[res];
        // 3.存储查询的结果
        results[--pos] = c;
        // 4.移除二进制被取过的1位
        value = value >> ;
    }

    // 4.打印结果
    for (int i = pos; i < ; i++) {
        printf("%c", results[i]);
    }
    printf("\n");

}

void printfOct2(int value)
{
    // 1.定义一个数组, 用于保存八进制中所有的取值
    char charValues[] = {'', '', '', '', '', '', '', ''};
    // 2.定义一个数组, 用于保存查询后的结果
    char results[] = {''};
    // 3.定义一个变量, 用于记录当前需要存储到查询结果数组的索引
    int pos = ;
    while (value != ) {
        // 1.取出3位的值
        int res = value & ;
        // 2.利用取出来得值到表中查询对应的结果
        char c = charValues[res];
        // 3.存储查询的结果
        results[--pos] = c;
        // 4.移除二进制被取过的三位
        value = value >> ;
    }

    // 4.打印结果
    for (int i = pos; i < ; i++) {
        printf("%c", results[i]);
    }
    printf("\n");

}

void printfHex2(int value)
{
    // 1.定义一个数组, 用于保存十六进制中所有的取值
    // 规律: 取出的4个二进制位得到的值, 正好是数组中角标对应的值
    char charValues[] = {'', '', '', '', '', '', '', '', '', '', 'a', 'b', 'c', 'd', 'e', 'f'};
//                    '', '', '', '', '', '', '', ''
    char results[] = {''};
    int pos = ;

    while (value != ) {
        // 取出4位的值
        int res = value & ;
        // 利用这个值作为索引去数组中查询对应的十六进制的值
        char c = charValues[res];
//        printf("%c", c);
        // 将取出来得值放到用于存储结果数组中
        results[--pos] = c;

        // 每取完一次就干掉它最低的4位
        value = value >> ;
//        printf("pos = %i\n", pos);
    }

    for (int i = pos; i < ; i++) {
        printf("%c", results[i]);
    }
    printf("\n");
}

void printfHex(int value)
{
    for (int i = ; i <= ; i++) {
        int res = value & ; // 1111
        // 对十六进制进行特殊处理
        if (res > ) {
            //  11 - 10 1 + a
            char c = res -  + 'a';
            printf("%c", c);
        }else
        {
            printf("%i", res);
        }
        value = value >> ;
    }
}

void printOct(int value)
{
    for (int i = ; i <= ; i++) {
        int res = value & ; //
        printf("%i", res);
        value = value >> ;
    }
}

void printfBinary2(int value)
{
    for (int i = ; i <= ; i++) {
        int res = value & ;
        printf("%i", res);
        value = value >> ;
    }
    printf("\n");
}

void printfBinary(int value)
{
//    int offset = sizeof(value) * 8 - 1;
    int offset = (sizeof(value) << ) - ;
    while (offset >= ) {
        int res = (value >> offset) & ;
        printf("%i", res);
        offset--;
    }
    printf("\n");
}

//
//  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();
    return ;
}

void printfHex(int num)
{
    total(num, , );
}

void printfOct(int num)
{
    total(num, , );
}

void ptintBinary(int num)
{
    total(num, , );
}

// 转换所有的进制
// value就是需要转换的数值
// base就是需要&上的数
// offset就是需要右移的位数
void total(int value, int base, int offset)
{
    // 1.定义一个数组, 用于保存十六进制中所有的取值
    char charValues[] = {'', '', '', '', '', '', '', '', '', '', 'a', 'b', 'c', 'd', 'e', 'f'};
    // 2.定义一个数组, 用于保存查询后的结果
    char results[] = {''};
    // 3.定义一个变量, 用于记录当前需要存储到查询结果数组的索引
    int pos = sizeof(results)/ sizeof(results[]);

    while (value != ) {
        // 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 < ; i++) {
        printf("%c", results[i]);
    }
    printf("\n");

}