hello-algo/ko/codes/zig/chapter_hashing/array_hash_map.zig

// File: array_hash_map.zig
// Created Time: 2023-01-15
// Author: codingonion ([email protected])

const std = @import("std");
const inc = @import("include");

// 키-값 쌍
const Pair = struct {
    key: usize = undefined,
    val: []const u8 = undefined,

   pub fn init(key: usize, val: []const u8) Pair {
        return Pair {
            .key = key,
            .val = val,
        };
    }
};

// 배열로 구현한 해시 테이블
pub fn ArrayHashMap(comptime T: type) type {
    return struct {
        bucket: ?std.ArrayList(?T) = null,
        mem_allocator: std.mem.Allocator = undefined,

        const Self = @This();
        
        // 생성자
        pub fn init(self: *Self, allocator: std.mem.Allocator) !void {
            self.mem_allocator = allocator;
            // 길이가 100인 버킷(배열)을 초기화한다
            self.bucket = std.ArrayList(?T).init(self.mem_allocator);
            var i: i32 = 0;
            while (i < 100) : (i += 1) {
                try self.bucket.?.append(null);
            }
        }

        // 소멸자
        pub fn deinit(self: *Self) void {
            if (self.bucket != null) self.bucket.?.deinit();
        }

        // 해시 함수
        fn hashFunc(key: usize) usize {
            var index = key % 100;
            return index;
        }

        // 조회 연산
        pub fn get(self: *Self, key: usize) []const u8 {
            var index = hashFunc(key);
            var pair = self.bucket.?.items[index];
            return pair.?.val;
        }

        // 추가 연산
        pub fn put(self: *Self, key: usize, val: []const u8) !void {
            var pair = Pair.init(key, val);
            var index = hashFunc(key);
            self.bucket.?.items[index] = pair;
        }

        // 삭제 연산
        pub fn remove(self: *Self, key: usize) !void {
            var index = hashFunc(key);
            // null로 설정하여 삭제를 나타낸다
            self.bucket.?.items[index] = null;
        }       

        // 모든 키-값 쌍 반환
        pub fn pairSet(self: *Self) !std.ArrayList(T) {
            var entry_set = std.ArrayList(T).init(self.mem_allocator);
            for (self.bucket.?.items) |item| {
                if (item == null) continue;
                try entry_set.append(item.?);
            }
            return entry_set;
        }  

        // 모든 키 반환
        pub fn keySet(self: *Self) !std.ArrayList(usize) {
            var key_set = std.ArrayList(usize).init(self.mem_allocator);
            for (self.bucket.?.items) |item| {
                if (item == null) continue;
                try key_set.append(item.?.key);
            }
            return key_set;
        }  

        // 모든 값 반환
        pub fn valueSet(self: *Self) !std.ArrayList([]const u8) {
            var value_set = std.ArrayList([]const u8).init(self.mem_allocator);
            for (self.bucket.?.items) |item| {
                if (item == null) continue;
                try value_set.append(item.?.val);
            }
            return value_set;
        }

        // 해시 테이블 출력
        pub fn print(self: *Self) !void {
            var entry_set = try self.pairSet();
            defer entry_set.deinit();
            for (entry_set.items) |item| {
                std.debug.print("{} -> {s}\n", .{item.key, item.val});
            }
        }
    };
}

// 실행 코드
pub fn main() !void {
    // 해시 테이블 초기화
    var map = ArrayHashMap(Pair){};
    try map.init(std.heap.page_allocator);
    defer map.deinit();

    // 추가 연산
    // 해시 테이블에 (key, value) 키-값 쌍을 추가한다
    try map.put(12836, "小哈");
    try map.put(15937, "小啰");
    try map.put(16750, "小算");
    try map.put(13276, "小法");
    try map.put(10583, "小鸭");
    std.debug.print("\n추가한 후의 해시 테이블:\n키 -> 값\n", .{});
    try map.print();

    // 조회 연산
    // 해시 테이블에 키 key를 입력하여 값 value를 얻는다
    var name = map.get(15937);
    std.debug.print("\n학번 15937로 조회한 이름: {s}\n", .{name});

    // 삭제 연산
    // 해시 테이블에서 (key, value) 키-값 쌍을 삭제한다
    try map.remove(10583);
    std.debug.print("\n10583을 삭제한 후의 해시 테이블:\n키 -> 값\n", .{});
    try map.print();
    
    // 해시 테이블 순회
    std.debug.print("\n키-값 쌍(키->값) 순회\n", .{});
    var entry_set = try map.pairSet();
    for (entry_set.items) |kv| {
        std.debug.print("{} -> {s}\n", .{kv.key, kv.val});
    }
    defer entry_set.deinit();
    std.debug.print("\n키 Key만 순회\n", .{});
    var key_set = try map.keySet();
    for (key_set.items) |key| {
        std.debug.print("{}\n", .{key});
    }
    defer key_set.deinit();
    std.debug.print("\n값 value만 순회\n", .{});
    var value_set = try map.valueSet();
    for (value_set.items) |val| {
        std.debug.print("{s}\n", .{val});
    }
    defer value_set.deinit();

    _ = try std.io.getStdIn().reader().readByte();
}