合并表记录

#include <stdio.h>
int main() {
    int n;
    int *x,*y;
    scanf("%d",&n);
    x=(int *)malloc(n*sizeof(int));
    y=(int *)malloc(n*sizeof(int));
    for(int k=0;k<n;k++){
        scanf("%d %d",&x[k],&y[k]);
    }
    for(int i=0;i<n;i++){
        for(int j=i+1;j<n;j++){
            if(x[i]==x[j]){              //x[i]=x[j]时，索引相同，合并数值
                y[i]+=y[j];
                y[j]=0;
            }
            else if(x[i]>x[j]){          //x[i]比x[j]大时，交换x[i]与x[j]并交换对应的y[i]与y[j]，相当于排序
                int t;
                t=x[i];
                x[i]=x[j];
                x[j]=t;
                t=y[i];
                y[i]=y[j];
                y[j]=t;
            }
        }
    }
    for(int i=0;i<n;i++){
        if(y[i]!=0) printf("%d %d\n",x[i],y[i]);
    }
    free(x);
    free(y);
    return 0;
}

#include <stdio.h>
struct Book {
    int index;
    int value;
};
//结构体升序排列
void B_sort(struct Book* nums, int numsSize) {
    int flag = 1;
    int tempindex;
    int tempvalue;
    for (int i = 0; i < numsSize - 1; i++) {
        for (int j = numsSize - 1; j > i; j--) {
            if (nums[j].index < nums[j - 1].index) {
                tempindex = nums[j - 1].index;
                tempvalue = nums[j - 1].value;
                nums[j - 1].index = nums[j].index;
                nums[j - 1].value = nums[j].value;
                nums[j].index = tempindex;
                nums[j].value = tempvalue;
                flag = 0;
            }

        }
        if (flag==1) {
            break;
        }
    }
}
int main() {
    int n;
    scanf("%d", &n);
    struct Book arr[n];
    int i = 0;
    while (i < n) {
        scanf("%d %d", &arr[i].index, &arr[i].value);
        i++;
    }
    //排序
    B_sort(arr, n);
    //从小到大排序在开始
    for (i = 0; i < n - 1; i++) {
        if (arr[i].index == arr[i + 1].index) {
            arr[i].value = arr[i].value + arr[i + 1].value;
            for (int j = i + 1; j < n - 1; j++) {
                arr[j].index = arr[j + 1].index;
                arr[j].value = arr[j + 1].value;
            }
            n = n - 1;
            //防止多个重复
            i=i-1;
        }

    }
    for (int k = 0; k < n; k++) {
        printf("%d %d\n", arr[k].index, arr[k].value);
    }
    return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdint.h>
#include <stdbool.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <time.h>


#define HASHMAP_CAPACITY 10

typedef int KeyType;
typedef int ValueType;

typedef struct node_s {
    int key;
    int val;
    struct node_s* next;
} KeyValueNode;

typedef struct {
    KeyValueNode* buckets[HASHMAP_CAPACITY];
    uint32_t hash_seed;
} HashMap;

int tmp[500] = { 0 };//用于存储哈希表结点的key值
int count = 0; //用于对哈希表结点计数

//哈希函数
static uint32_t hash(const void* key, int len, uint32_t seed) {
    const uint32_t m = 0x5bd1e995;
    const int r = 24;
    uint32_t h = seed ^ len;
    const unsigned char* data = (const unsigned char*)key;

    while (len >= 4) {
        uint32_t k = *(uint32_t*)data;
        k *= m;
        k ^= k >> r;
        k *= m;
        h *= m;
        h ^= k;
        data += 4;
        len -= 4;
    }

    switch (len) {
        case 3:
            h ^= data[2] << 16;
        case 2:
            h ^= data[1] << 8;
        case 1:
            h ^= data[0];
            h *= m;
    };

    h ^= h >> 13;
    h *= m;
    h ^= h >> 15;

    return h;
}
//创建哈希表
HashMap* hashmap_create() {
    HashMap* map = calloc(1, sizeof(HashMap));
    if (map == NULL) {
        printf("error: calloc failed in hashmap_create.\n");
        exit(-1);
    }
    map->hash_seed = time(NULL);
    return map;
}
//销毁哈希表
void hashmap_destroy(HashMap* map) {
    for (size_t i = 0; i < HASHMAP_CAPACITY; i++) {
        KeyValueNode* curr = map->buckets[i];
        while (curr != NULL) {
            KeyValueNode* tmp = curr->next;
            free(curr);
            curr = tmp;
        }
    }
    free(map);
}
//插入一个键值对
ValueType hashmap_put(HashMap* map, int key, int val) {
    char key_str[sizeof(int)];
    memcpy(key_str, &key, sizeof(int));
    int idx = hash(key_str, sizeof(int), map->hash_seed) % HASHMAP_CAPACITY;

    KeyValueNode* curr = map->buckets[idx];
    while (curr != NULL) {
        if (curr->key == key) {
            int old_val = curr->val;
            curr->val = old_val + val;
            return old_val;
        }
        curr = curr->next;
    }

    KeyValueNode* new_node = malloc(sizeof(KeyValueNode));
    if (new_node == NULL) {
        printf("Error: malloc failed in hashmap_put.\n");
        exit(1);
    }
    new_node->key = key;
    new_node->val = val;

    new_node->next = map->buckets[idx];
    map->buckets[idx] = new_node;

    return 0;
}

// 查询一个键值对
ValueType hashmap_get(HashMap* map, KeyType key) {
    char key_str[sizeof(int)];
    memcpy(key_str, &key, sizeof(int));
    int idx = hash(key_str, sizeof(int), map->hash_seed) % HASHMAP_CAPACITY;

    KeyValueNode* curr = map->buckets[idx];
    while (curr != NULL) {
        if (curr->key == key) {
            return curr->val;
        }
        curr = curr->next;
    }
    return 0; // 若不存在则返回0
}

// 快速排序的分区函数
static int partition(int arr[], int left, int right) {
    int pivot = arr[left];
    int low = left, high = right;

    while (low < high) {
        while (low < high && arr[high] >= pivot) {
            high--;
        }
        arr[low] = arr[high];
        while (low < high && arr[low] < pivot) {
            low++;
        }
        arr[high] = arr[low];
    }
    arr[low] = pivot;
    return low;
}

// 递归函数
void quick_sort_recursive(int arr[], int left, int right) {
    if (left < right) {
        int pivot_index = partition(arr, left, right);
        quick_sort_recursive(arr, left, pivot_index - 1);
        quick_sort_recursive(arr, pivot_index + 1, right);
    }
}

// 快速排序
void quick_sort(int arr[], int len) {
    quick_sort_recursive(arr, 0, len - 1);
}

int main(void) {
    HashMap* map = hashmap_create();
    if (map == NULL) {
        printf("哈希表创建失败。\n");
        return 1;
    }

    int sum;
    scanf("%d", &sum);
    int key[500] = { 0 }, value[500] = { 0 };
    for (int i = 0; i < sum; i++) {
        scanf("%d %d", &key[i], &value[i]);
    }

    for (int i = 0; i < sum; i++) {
        hashmap_put(map, key[i], value[i]);
    }

    for (int i = 0; i < HASHMAP_CAPACITY; i++) {
        KeyValueNode* curr = map->buckets[i];
        while (curr != NULL) {
            tmp[count++] = curr->key;
            curr = curr->next;
        }
    }

    quick_sort(tmp, count);
    for (int i = 0; i < count; i++) {
        printf("%d %d\n", tmp[i], hashmap_get(map, tmp[i]));
    }

    hashmap_destroy(map);
    return 0;
}

#include "stdio.h"
#include "string.h"
#include <ctype.h>
//思路：分成三个部分，求和，排序，输出。注意测试用例里给的数据是乱序所以必须排序。
//这个代码有一个问题，就是循环相加的部分只能处理index只有两个相同的部分，三个及以上就会漏，不知道怎么回事和怎么补救，还好例子里最多三个，因此用了两遍就过了。
void upper_bubble_sort_for_IA(int index[], int value[],int n)
{
    int i,j,tempv,tempi;
    for(i = 0; i <n; i++)
    {
        for(j = 0; j < n - 1- i; j++)
        {
            if(index[j] > index[j+1])
            {
                tempv = value[j];
                value[j] = value[j+1];
                value[j+1] = tempv;
                tempi = index[j];
                index[j] = index[j+1];
                index[j+1] = tempi;
            }
        }
    }
}
int main()
{
    //输入部分
    int n,i,a;
    //struct IA inva;
    scanf("%d",&n);
    int index[500] = {0},value[500] = {0};
    for(i = 0; i < n; i++)
    {
        scanf("%d",&index[i]);
        scanf(" %d", &value[i]);
    }
    //比较并求和部分
    
        for (i = 0; i < n; i++) 
        {
            for(a = 1; a < n - 1 -i; a++)
            {
                if(index[i] == index[i+a]&& value[i+a] !=0)
                {
                    value[i] = value[i] + value[i+a];
                    value[i+a] = 0;
                }
            }
        }
    
    //排序
    upper_bubble_sort_for_IA(index,value,n);
    for (i = 0; i < n; i++) 
        {
            for(a = 1; a < n -i; a++)
            {
                if(index[i] == index[i+a]&& value[i+a] !=0)
                {
                    value[i] = value[i] + value[i+a];
                    value[i+a] = 0;
                    //a = 1;
                    //i = 0;
                }
            }
        }
    //输出
    for(i = 0; i < n; i++)
    {
        if (value[i] !=0) 
        {
            printf("%d %d\n",index[i],value[i]);
        }
    }
}