C语言代码查询备忘

最新推荐文章于 2024-05-30 17:38:09 发布
最新推荐文章于 2024-05-30 17:38:09 发布
阅读量63 收藏
点赞数
分类专栏： C语言 文章标签： c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40220242/article/details/134454093
版权

操作环境如下：

操作系统：win10
工具：dev-c++ TDM-GCC 4.9.2 64-bit release
语言标准：C99

char, char*, char**, char*[]类型

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main()
{
    // part 1
    char c = 'a';
    printf("c = %c, c: 0x%p;\n", c, &c);
    // part 2
    char *s1 = "hello world";
    printf("s1 = %s, s1: 0x%p, s1[0] = %c, sizeof(s1) = %d, strlen(s1) = %d;\n", s1, s1, s1[0], sizeof(s1), strlen(s1));
    char s2[10] = "thank you";
    printf("s2 = %s, s2: 0x%p, s2[0] = %c, sizeof(s2) = %d, strlen(s2) = %d;\n", s2, s2, s2[0], sizeof(s2), strlen(s2));
    s1 = "world hello";
    printf("s1' = %s;\n", s1);
    s1 = s2;
    printf("s1'' = %s;\n", s1);
    // error: s2 = "you thank";
    // error :s2 = s1;
    // part 3
    char *s3[] = {"apple", "orange", "banana"};
    printf("s3 = %s, s3: 0x%p;\n", s3, s3);
    printf("s3[0] = %s, s3[0]: 0x%p, s3[0][0] = %c, s3[0][0]: 0x%p, sizeof(s3[0]) = %d, strlen(s3[0]) = %d;\n", s3[0], s3[0], s3[0][0], &s3[0][0], sizeof(s3[0]), strlen(s3[0]));
    printf("s3[1] = %s, s3[1]: 0x%p, s3[1][0] = %c, s3[1][0]: 0x%p, sizeof(s3[1]) = %d, strlen(s3[1]) = %d;\n", s3[1], s3[1], s3[1][0], &s3[1][0], sizeof(s3[1]), strlen(s3[1]));
    printf("s3[2] = %s, s3[2]: 0x%p, s3[2][0] = %c, s3[2][0]: 0x%p, sizeof(s3[2]) = %d, strlen(s3[2]) = %d;\n", s3[2], s3[2], s3[2][0], &s3[2][0], sizeof(s3[2]), strlen(s3[2]));
    printf("sizeof(s3) = %d, sizeof(*s3) = %d, sizeof(**s3) = %d, strlen(*s3) = %d\n", sizeof(s3), sizeof(*s3), sizeof(**s3), strlen(*s3));
    printf("&s3[0]: 0x%p, &s3[1]: 0x%p, &s3[2]: 0x%p\n", &s3[0], &s3[1], &s3[2]);
    printf("*s3 = %s, *(s3 + 1) = %s, *(s3 + 2) = %s\n", *s3, *(s3 + 1), *(s3 + 2));
    char **s4 = s3;
    printf("s4 = %s, s4: 0x%p\n", s4, s4);
    printf("*s4 = %s, *s4: 0x%p\n", *s4, *s4);
    printf("**s4: 0x%p\n", **s4);
    printf("sizeof(s4) = %d, sizeof(*s4) = %d, sizeof(**s4) = %d, strlen(*s4) = %d\n", sizeof(s4), sizeof(*s4), sizeof(**s4), strlen(*s4));
    printf("&s4[0]: 0x%p, &s4[1]: 0x%p, &s4[2]: 0x%p\n", &s4[0], &s4[1], &s4[2]);
    printf("*s4 = %s, *(s4 + 1) = %s, *(s4 + 2) = %s\n", *s4, *(s4 + 1), *(s4 + 2));
    // part 4
    char **s5 = (char **)malloc(sizeof(char **));
    *s5 = "hello world";
    printf("s5: 0x%p, *s5: 0x%p, *s5 = %s\n", s5, *s5, *s5);
    *s5 = "thank you";
    printf("s5': 0x%p, *s5': 0x%p, *s5' = %s\n", s5, *s5, *s5);
    // part 5
    char *s6;
    char **s7 = &s6;
    *s7 = "hello world";
    printf("s6 = %s, s6: 0x%p\n", s6, s6);
    s6 = "thank you";
    printf("s6 = %s, s6: 0x%p\n", s6, s6);
    while(getchar() != '\n') {}
    return 0;
}

if…else 判断语句

#include <stdio.h>

int main ()
{
 /* 局部变量定义 */
 int a = 10;
 /* 检查布尔条件 */
 if( a == 10 )
 {
   /* 如果 if 条件为真，则输出下面的语句 */
   printf("a 的值是 10\n" );
 }
 else if( a == 20 )
 {
   /* 如果 else if 条件为真，则输出下面的语句 */
   printf("a 的值是 20\n" );
 }
 else if( a == 30 )
 {
   /* 如果 else if 条件为真，则输出下面的语句 */
   printf("a 的值是 30\n" );
 }
 else
 {
   /* 如果上面条件都不为真，则输出下面的语句 */
   printf("没有匹配的值\n" );
 }
 printf("a 的准确值是 %d\n", a );
 return 0;
}

for 循环语句

#include <stdio.h>
int main ()
{
   /* for 循环执行 */
   int a=10;
   for(;a<20;a=a+1)
   {
      printf("a的值：%d\n",a);
   }
   return 0;
}

C 数组

//声明数组、数组赋值、访问数组
#include <stdio.h>
 
int main ()
{
   //声明数组：type arrayName [ arraySize ];
   int n[ 10 ]; /* n 是一个包含 10 个整数的数组  ];*/
   int i,j;
 
   /* 初始化数组元素 */         
   for ( i = 0; i < 10; i++ )
   {
      n[ i ] = i + 100; /* 设置元素 i 为 i + 100 */
   }
   
   /* 输出数组中每个元素的值 */
   for (j = 0; j < 10; j++ )
   {
      printf("Element[%d] = %d\n", j, n[j] );
   }
 
   return 0;
}

//获取数组长度
#include <stdio.h>

int main() {
    int array[] = {1, 2, 3, 4, 5};
    int length = sizeof(array) / sizeof(array[0]);//数组长度可以使用 sizeof 运算符来获取数组的长度

    printf("数组长度为: %d\n", length);

    return 0;
}

//使用宏定义,获取数组长度
#include <stdio.h>

#define LENGTH(array) (sizeof(array) / sizeof(array[0])) //使用宏定义

int main() {
    int array[] = {1, 2, 3, 4, 5};
    int length = LENGTH(array);

    printf("数组长度为: %d\n", length);

    return 0;
}

//数组名
#include <stdio.h>
//在 C 语言中，数组名表示数组的地址，即数组首元素的地址
void printArray(int arr[], int size) {
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]); // 数组名arr被当作指针使用
    }
}
/*我们可以使用&运算符来获取数组的地址，如下所示：
int myArray[5] = {10, 20, 30, 40, 50};
int *ptr = &myArray[0]; // 或者直接写作 int *ptr = myArray;
在上面的例子中，ptr 指针变量被初始化为 myArray 的地址，即数组的第一个元素的地址。
需要注意的是，虽然数组名表示数组的地址，但在大多数情况下，数组名会自动转换为指向数组首元素的指针。这意味着我们可以直接将数组名用于指针运算，例如在函数传递参数或遍历数组时： */
int main() {
    int myArray[5] = {10, 20, 30, 40, 50};//包含 5 个元素
    printArray(myArray, 5); // 将数组名传递给函数
    return 0;
/*在上述代码中，printArray 函数接受一个整数数组和数组大小作为参数，我们将 myArray 数组名传递给函数，函数内部可以像使用指针一样使用 arr 数组名。 */
}

C 命令行参数

#include <stdio.h>

int main( int argc, char *argv[] )  
{
   if( argc == 2 )
   {
      printf("The argument supplied is %s\n", argv[1]);
   }
   else if( argc > 2 )
   {
      printf("Too many arguments supplied.\n");
   }
   else
   {
      printf("One argument expected.\n");
   }
}

C 排序算法

冒泡排序

#include <stdio.h>
void bubble_sort(int arr[], int len) {
    int i, j, temp;
    for (i = 0; i < len - 1; i++)
        for (j = 0; j < len - 1 - i; j++)
            if (arr[j] > arr[j + 1]) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
}
int main() {
    int arr[] = { 22, 34, 3, 32, 82, 55, 89, 50, 37, 5, 64, 35, 9, 70 ,111, 2, 2};
    int len = (int) sizeof(arr) / sizeof(*arr);
    bubble_sort(arr, len);
    int i;
    for (i = 0; i < len; i++)
        printf("%d ", arr[i]);
    return 0;
}

选择排序

//选择排序（升序）
#include <stdio.h>


void selection_sort(int a[], int len) 
{
    int i,j,temp;
 
    for (i = 0 ; i < len - 1 ; i++) 
    {
        int min = i;                  // 记录最小值，第一个元素默认最小
        for (j = i + 1; j < len; j++)     // 访问未排序的元素
        {
            if (a[j] < a[min])    // 找到目前最小值
            {
                min = j;    // 记录最小值
            }
        }
        if(min != i)
        {
            temp=a[min];  // 交换两个变量
            a[min]=a[i];
            a[i]=temp;
        }
        /* swap(&a[min], &a[i]);  */   // 使用自定义函数交換
    }
}
 
/*
void swap(int *a,int *b) // 交换两个变量
{
    int temp = *a;
    *a = *b;
    *b = temp;
}
*/
int main() {
    int arr[] = { 22, 34, 3, 32, 82, 55, 89, 50, 37, 5, 64, 35, 9, 70 };
    int len = (int) sizeof(arr) / sizeof(*arr);
    selection_sort(arr, len);
    int i;
    for (i = 0; i < len; i++)
        printf("%d ", arr[i]);
    return 0;
}

哈希表

普通哈希表

#include <stdio.h>
#include <stdbool.h>
#include <string.h>

#define TABLE_SIZE 10

typedef struct {
    char key[20];
    int value;
} KeyValuePair;

typedef struct {
    KeyValuePair table[TABLE_SIZE];
} HashTable;

unsigned int hash(const char* key) {     // 声明char* key是一个指针，把常量字符串首个字符地址赋给key;指针放不下整个字符串时，常量字符串前必须加const。
    unsigned int hashValue = 0;
    for (int i = 0; key[i] != '\0'; i++) {
        hashValue += key[i];
    }
    return hashValue % TABLE_SIZE;
}

void insert(HashTable* hashTable, const char* key, int value) {
    unsigned int index = hash(key);
    strcpy(hashTable->table[index].key, key);
    hashTable->table[index].value = value;
}

void  get(HashTable* hashTable, const char* key) {
     bool flag;
     int value;
    unsigned int index = hash(key);
    if (strcmp(hashTable->table[index].key, key) == 0 && hashTable->table[index].key[0] != '\0') {
        value = hashTable->table[index].value;
        flag=true;
    }
    else flag=false;
    if(flag) printf("Value for %s:%d\n",key,value);
    else printf("key %s not found.\n",key);
}

int main() {
    HashTable hashTable;
    memset(hashTable.table, 0, sizeof(hashTable.table));

    insert(&hashTable, "apple", 1);
    insert(&hashTable, "apple",88);
    insert(&hashTable, "banana", 2);
    insert(&hashTable, "orange", 3);

    get(&hashTable,"apple");
    get(&hashTable, "orange");

    return 0;
}

哈希表-链地址法

#include <stdio.h>
#include <stdlib.h>

#define SIZE 10

// 哈希表节点结构
typedef struct Node {
    int key;
    int value;
    struct Node* next;
} Node;

// 哈希表结构
typedef struct HashTable {
    // 桶数组，里面有SIZE个链表
    Node* buckets[SIZE];
} HashTable;

// 创建哈希表
HashTable* createHashTable() {
    HashTable* hashtable = (HashTable*)malloc(sizeof(HashTable));
    for (int i = 0; i < SIZE; i++) {
        hashtable->buckets[i] = NULL;
    }
    return hashtable;
}

// 哈希函数
int hashFunction(int key) {
    return key % SIZE;
}

// 向哈希表中插入键值对
void insert(HashTable* hashtable, int key, int value) {
    int index = hashFunction(key);
    
    // 创建新节点
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->key = key;
    newNode->value = value;
    newNode->next = NULL;
    
    // 如果桶为空，则直接插入新节点
    if (hashtable->buckets[index] == NULL) {
        hashtable->buckets[index] = newNode;
    } else {
        // 否则，在链表末尾插入新节点
        Node* current = hashtable->buckets[index];
        while (current->next != NULL) {
            current = current->next;
        }
        current->next = newNode;
    }
}

// 根据键查找哈希表中的值
int search(HashTable* hashtable, int key) {
    int index = hashFunction(key);
    
    // 查找链表中对应的节点
    Node* current = hashtable->buckets[index];
    while (current != NULL) {
        if (current->key == key) {
            return current->value;
        }
        current = current->next;
    }
    
    // 若未找到，返回-1
    return -1;
}

// 从哈希表中删除键值对
void delete(HashTable* hashtable, int key) {
    int index = hashFunction(key);
    
    // 查找链表中对应的节点
    Node* current = hashtable->buckets[index];
    Node* prev = NULL;
    while (current != NULL) {
        if (current->key == key) {
            if (prev == NULL) {
                // 若为头节点，直接修改桶指针
                hashtable->buckets[index] = current->next;
            } else {
                // 否则修改前一个节点的指针
                prev->next = current->next;
            }
            free(current);
            return;
        }
        prev = current;
        current = current->next;
    }
}

// 销毁哈希表
void destroyHashTable(HashTable* hashtable) {
    for (int i = 0; i < SIZE; i++) {
        Node* current = hashtable->buckets[i];
        while (current != NULL) {
            Node* temp = current;
            current = current->next;
            free(temp);
        }
    }
    free(hashtable);
}

int main() {
    HashTable* hashtable = createHashTable();
    
    // 插入键值对
    insert(hashtable, 1, 10);
    insert(hashtable, 11, 20);   
    insert(hashtable, 21, 30);
    
    // 查找值
    int value =search(hashtable, 11);
    if(value) printf("Find key =11 ,value = %d\n",value);
    else printf("key=11 not exist.\n");
    // 销毁哈希表
    destroyHashTable(hashtable);
    
    return 0;
}

哈希表-开放地址法

// 线性探测法
#include <stdio.h>
#include <stdlib.h>

#define SIZE 10

// 哈希表节点结构
typedef struct {
    int key;
    int value;
} Node;

// 哈希表结构
typedef struct {
    Node* data[SIZE];
} HashTable;

// 创建哈希表
HashTable* createHashTable() {
    HashTable* hashtable = (HashTable*)malloc(sizeof(HashTable));
    for (int i = 0; i < SIZE; i++) {
        hashtable->data[i] = NULL;
    }
    return hashtable;
}

// 哈希函数
int hashFunction(int key) {
    return key % SIZE;
}

// 向哈希表中插入键值对
void insert(HashTable* hashtable, int key, int value) {
    int index = hashFunction(key);
    
    // 寻找下一个可用的位置
    while (hashtable->data[index] != NULL) {
        index = (index + 1) % SIZE;
    }
    
    // 创建新节点
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->key = key;
    newNode->value = value;
    
    // 插入新节点
    hashtable->data[index] = newNode;
}

// 根据键查找哈希表中的值
int search(HashTable* hashtable, int key) {
    int index = hashFunction(key);
    int originalIndex = index;
    
    // 从哈希表中寻找对应的键值对
    while (hashtable->data[index] != NULL) {
        if (hashtable->data[index]->key == key) {
            return hashtable->data[index]->value;
        }
        index = (index + 1) % SIZE;
        
        // 如果回到原始位置，则说明未找到
        if (index == originalIndex) {
            break;
        }
    }
    
    // 若未找到，返回-1
    return -1;
}

// 从哈希表中删除键值对
void delete(HashTable* hashtable, int key) {
    int index = hashFunction(key);
    int originalIndex = index;
    
    // 从哈希表中寻找对应的键值对
    while (hashtable->data[index] != NULL) {
        if (hashtable->data[index]->key == key) {
            free(hashtable->data[index]);
            hashtable->data[index] = NULL;
            return;
        }
        index = (index + 1) % SIZE;
        
        // 如果回到原始位置，则说明未找到
        if (index == originalIndex) {
            break;
        }
    }
}

// 销毁哈希表
void destroyHashTable(HashTable* hashtable) {
    for (int i = 0; i < SIZE; i++) {
        if (hashtable->data[i] != NULL) {
            free(hashtable->data[i]);
        }
    }
    free(hashtable);
}

int main() {
    HashTable* hashtable = createHashTable();
    
    // 插入键值对
    insert(hashtable, 1, 10);
    insert(hashtable, 11, 20);
    insert(hashtable, 21, 30);
    
    // 查找值
    int value = search(hashtable, 1);
    if (value != -1) {
        printf("找到了，值为：%d\n", value);
    } else {
        printf("未找到该键\n");
    }
    
    // 删除键值对
    delete(hashtable, 1);
    
    // 再次查找
    value = search(hashtable, 1);
    if (value != -1) {
        printf("找到了，值为：%d\n", value);
    } else {
        printf("未找到该键\n");
    }
    
    // 销毁哈希表
    destroyHashTable(hashtable);
    
    return 0;
}

哈希表-二次探测

// 二次探测
#include <stdio.h>
#include <stdlib.h>

#define SIZE 10

// 哈希表节点结构
typedef struct {
    int key;
    int value;
} Node;

// 哈希表结构
typedef struct {
    Node* data[SIZE];
} HashTable;

// 创建哈希表
HashTable* createHashTable() {
    HashTable* hashtable = (HashTable*)malloc(sizeof(HashTable));
    for (int i = 0; i < SIZE; i++) {
        hashtable->data[i] = NULL;
    }
    return hashtable;
}

// 哈希函数
int hashFunction(int key) {
    return key % SIZE;
}

// 向哈希表中插入键值对
void insert(HashTable* hashtable, int key, int value) {
    int index = hashFunction(key);
    int step = 1;
    
    // 寻找下一个可用的位置
    while (hashtable->data[index] != NULL) {
        index = (index + step * step) % SIZE;
        step++;
    }
    
    // 创建新节点
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->key = key;
    newNode->value = value;
    
    // 插入新节点
    hashtable->data[index] = newNode;
}

// 根据键查找哈希表中的值
int search(HashTable* hashtable, int key) {
    int index = hashFunction(key);
    int step = 1;
    
    // 从哈希表中寻找对应的键值对
    while (hashtable->data[index] != NULL) {
        if (hashtable->data[index]->key == key) {
            return hashtable->data[index]->value;
        }
        index = (index + step * step) % SIZE;
        step++;
    }
    
    // 若未找到，返回-1
    return -1;
}

// 从哈希表中删除键值对
void delete(HashTable* hashtable, int key) {
    int index = hashFunction(key);
    int step = 1;
    
    // 从哈希表中寻找对应的键值对
    while (hashtable->data[index] != NULL) {
        if (hashtable->data[index]->key == key) {
            free(hashtable->data[index]);
            hashtable->data[index] = NULL;
            return;
        }
        index = (index + step * step) % SIZE;
        step++;
    }
}

// 销毁哈希表
void destroyHashTable(HashTable* hashtable) {
    for (int i = 0; i < SIZE; i++) {
        if (hashtable->data[i] != NULL) {
            free(hashtable->data[i]);
        }
    }
    free(hashtable);
}

int main() {
    HashTable* hashtable = createHashTable();
    
    // 插入键值对
    insert(hashtable, 1, 10);
    insert(hashtable, 11, 20);
    insert(hashtable, 21, 30);
    
    // 查找值
    int value = search(hashtable, 1);
    if (value != -1) {
        printf("找到了，值为：%d\n", value);
    } else {
        printf("未找到该键\n");
    }
    
    // 删除键值对
    delete(hashtable, 1);
    
    // 再次查找
    value = search(hashtable, 1);
    if (value != -1) {
        printf("找到了，值为：%d\n", value);
    } else {
        printf("未找到该键\n");
    }
    
    // 销毁哈希表
    destroyHashTable(hashtable);
    
    return 0;
}

哈希表-双重哈希

// 双重哈希
#include <stdio.h>
#include <stdlib.h>

#define SIZE 10

// 哈希表节点结构
typedef struct {
    int key;
    int value;
} Node;

// 哈希表结构
typedef struct {
    Node* data[SIZE];
} HashTable;

// 创建哈希表
HashTable* createHashTable() {
    HashTable* hashtable = (HashTable*)malloc(sizeof(HashTable));
    for (int i = 0; i < SIZE; i++) {
        hashtable->data[i] = NULL;
    }
    return hashtable;
}

// 哈希函数1
int hashFunction1(int key) {
    return key % SIZE;
}

// 哈希函数2
int hashFunction2(int key) {
    return 1 + (key % (SIZE - 1));
}

// 向哈希表中插入键值对
void insert(HashTable* hashtable, int key, int value) {
    int index = hashFunction1(key);
    int step = hashFunction2(key);
    
    // 寻找下一个可用的位置
    while (hashtable->data[index] != NULL) {
        index = (index + step) % SIZE;
    }
    
    // 创建新节点
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->key = key;
    newNode->value = value;
    
    // 插入新节点
    hashtable->data[index] = newNode;
}

// 根据键查找哈希表中的值
int search(HashTable* hashtable, int key) {
    int index = hashFunction1(key);
    int step = hashFunction2(key);
    
    // 从哈希表中寻找对应的键值对
    while (hashtable->data[index] != NULL) {
        if (hashtable->data[index]->key == key) {
            return hashtable->data[index]->value;
        }
        index = (index + step) % SIZE;
    }
    
    // 若未找到，返回-1
    return -1;
}

// 从哈希表中删除键值对
void delete(HashTable* hashtable, int key) {
    int index = hashFunction1(key);
    int step = hashFunction2(key);
    
    // 从哈希表中寻找对应的键值对
    while (hashtable->data[index] != NULL) {
        if (hashtable->data[index]->key == key) {
            free(hashtable->data[index]);
            hashtable->data[index] = NULL;
            return;
        }
        index = (index + step) % SIZE;
    }
}

// 销毁哈希表
void destroyHashTable(HashTable* hashtable) {
    for (int i = 0; i < SIZE; i++) {
        if (hashtable->data[i] != NULL) {
            free(hashtable->data[i]);
        }
    }
    free(hashtable);
}

int main() {
    HashTable* hashtable = createHashTable();
    
    // 插入键值对
    insert(hashtable, 1, 10);
    insert(hashtable, 11, 20);
    insert(hashtable, 21, 30);
    
    // 查找值
    int value = search(hashtable, 1);
    if (value != -1) {
        printf("找到了，值为：%d\n", value);
    } else {
        printf("未找到该键\n");
    }
    
    // 删除键值对
    delete(hashtable, 1);
    
    // 再次查找
    value = search(hashtable, 1);
    if (value != -1) {
        printf("找到了，值为：%d\n", value);
    } else {
        printf("未找到该键\n");
    }
    
    // 销毁哈希表
    destroyHashTable(hashtable);
    
    return 0;
}

参考链接：
https://blog.csdn.net/weixin_43764974/article/details/131053431
https://www.runoob.com/cprogramming/c-sort-algorithm.html

newdf观察者
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构与算法：查找
JackChan
01-04 5766
所谓查找(Search)又称检索，就是在一个数据元素集合中寻找满足某种条件的数据元素。查找在计算机数据处理中是经常使用的操作。查找算法的效率高低直接关系到应用系统的性能。查找的方法很多，本章将介绍一些常用的查找算法，主要有：线性表的查找、树表的查找和散列表的查找，并对有关的算法进行性能分析和对比基本概念1．数据表就是指数据元素的有限集合。例如，为统计职工工作业绩，建立一个包括：职工编号、职工姓名、业
C语言备忘录程序代码
07-01
根据给定的文件信息，我们可以总结出以下关于“C语言备忘录程序代码”的关键知识点： ### C语言备忘录程序概述 此备忘录系统是用C语言编写的，旨在帮助用户记录并管理日常生活或工作中重要的事件。系统通过结构体`...
C语言实现基础查找算法
C学习
01-05 8433
顺序查找 ( Sequential search ) 顺序查找是按照序列原有顺序对 数组/链表 进行遍历比较查询的基本查找算法。 算法实现 从表中的最后一个数据元素开始，逐个同记录的关键字做比较 如果匹配成功，则查找成功；反之，如果直到表中第一个关键字查找完也没有成功匹配，则查找失败。 时间复杂度：O(n) 静态查找表既可以使用顺序表表示，也可以使用链表结构表示。虽然一个是数组、一个链表，但两者在做查找操作时，基本上大同小异。我们这里使用数组进行操作。 // 顺序查找--如果发现则返回查找到的值，否则返
C语言实现日历查询
qq_47798402的博客
02-01 444
【代码】C语言实现日历查询。
C语言查询数据类型查看
最新发布
weixin_38849487的博客
05-30 196
【代码】C语言查询数据类型查看。
C语言的查找
qq_47896523的博客
08-15 2338
C语言的两种查找方法
使用C语言实现查找
Keep_Trying_Go的博客
08-23 3288
使用C语言实现查找
c语言教材编写备忘录
07-13
《C语言教材编写备忘录》 在编程世界中，C语言是一门强大的基础语言，它连接了问题解决者和计算机的实际运作。程序员扮演着桥梁的角色，通过C语言将复杂的问题转化为计算机能够理解和执行的指令。理解计算机底层的...
beiwanglu.zip_备忘录源代码
09-23
【标题】"备忘录源代码"所涉及的知识点主要集中在软件开发领域，特别是C语言编程和源代码管理。这个压缩包"beiwanglu.zip"包含了一个名为"letter"的项目的源代码及相关工程文件，这通常是个人或团队在开发过程中用于...
C语言库函数查询工具
05-23
本资源是一个专门用于查询C语言库函数的工具，它使得开发者在编写代码时能够快速查找并理解库函数的用途和用法，极大地提高了编程效率。 这个经典且实用的查询工具将库函数进行了分类，主要包括以下几个类别： 1. ...
用C语言编写的备忘录程序（事件记录程序）
01-12
标题中的“用C语言编写的备忘录程序（事件记录程序）”指的是一个使用C语言实现的应用程序，其主要功能是帮助用户管理他们的日常事件，如会议、约会或任务，起到提醒和记录的作用。这样的程序通常包含数据结构来存储...
学生课程成绩查询系统（C语言）
05-15
学生课程成绩查询系统，C语言编写，大一大二均适用，内含12个功能，功能齐全
c语言库函数查询
11-09
1、基于C语言的 2、查询标准c语言库函数，能显示函数的使用方法
c语言万年历查询系统
03-08
功能： 1.输入年份查询整年的日历 2.输入年月份查询该月的日历 3.输入年月日查询该日是星期几，并计算到程序运行时本地日期到查询日期相差的天数
c语言 快速查找算法
12-27
快速排序（Quicksort）是对冒泡排序的一种改进。由C. A. R. Hoare在1962年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。 假设要排序的数组是A[1]……A[N]，首先任意选取一个数据（通常选用第一个数据）作为关键数据，然后将所有比它的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一躺快速排序。一躺快速排序的算法是： 1）、设置两个变量I、J，排序开始的时候I：=1，J：=N； 2）以第一个数组元素作为关键数据，赋值给X，即X：=A[1]； 3）、从J开始向前搜索，即由后开始向前搜索（J：=J-1），找到第一个小于X的值，两者交换； 4）、从I开始向后搜索，即由前开始向后搜索（I：=I+1），找到第一个大于X的值，两者交换； 5）、重复第3、4步，直到I=J
C语言库函数功能查询器
03-26
C语言函数查询 本软件是将C语言库库函数的相关信息收集并通过用户的查询获得指定函数的详细信息。 作者在设计的时侯，考虑到C语言初学者对库函数功能的陌生，因此添加了例程和综合例程。 同时，作者也毫不保有留地 将自己对相关函数的理解和编程经验写给用户。 用户不仅能查询到相关函数的详细信息，还能获得很多的经 验。 这也是作者要写这样的一个软件的主要原因。 希望用户能通过本软件的使用，给您的学习和工作带来便利。
c语言指令作用,c语言主要知识点总结
weixin_39980347的博客
05-16 260
C语言是一门通用计算机编程语言，下面是小编整理的c语言主要知识点总结，希望对大家有帮助！◆知识点1：交换两个变量值的方法1)采用第三方变量(最容易想到的方法)2)采用加减法进行值得交换(面试时常用**)代码如下：b = a - b;a = a - b;b = a + b;3)采用按位异或的位方式代码如下：a = a^b;b = a^b; a = a^b;◆知识点2：取余运算%的结果与被除的符号相同...
七大查找之哈希查找
qq_46359697的博客
12-15 7178
文章目录1.基本思想2.算法步骤3.代码实现3.1.算法实现3.2.测试程序4.程序结果 1.基本思想 哈希查找算法又称散列查找算法，是一种借助哈希表（散列表）查找目标元素的方法，查找效率最高时对应的时间复杂度为 O(1)。 哈希查找算法适用于大多数场景，既支持在有序序列中查找目标元素，也支持在无序序列中查找目标元素。讲解哈希查找算法之前，我们首先要搞清楚什么是哈希表。 哈希表（Hash table）又称散列表，是一种存储结构，通常用来存储多个元素。 和其它存储结构（线性表、树等）相比，哈希表查找目标元素的
万年历附备忘录c语言代码
12-04
根据提供的引用内容，我们可以找到一个C语言实现的万年历系统，其中包括备忘录功能。以下是该系统的部分代码： ```c #include #include #include #include #include #define MAX 1000 struct date { int ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值