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

    return 0;
}

// 遍历数组
void printArray(int nums[], int length)
{
    for (int i = 0; i < length; i++) {
        printf("nums[%i] = %i\n", 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毫秒\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 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\n");
    
    return mid;

}

int findKey(int nums[], int key, int length)
{
    for (int i = 0; i < length; i++) {
        if (nums[i] == key) {
            printf("%i\n", 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\n", 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("\n");

    
}

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("\n");
    
}

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\n", pos);
    }
    
    for (int i = pos; i < 8; i++) {
        printf("%c", results[i]);
    }
    printf("\n");
}

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("\n");
}

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("\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(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("\n");
    
}