数据结构与算法 on 映屿

4Key音游段位单曲成绩计算的程序实现

i@glowisle.me (五葉地錦) — Sat, 07 Jun 2025 13:08:07 +0000

前言

其实这个坑我很早以前就想开了，在我刚开始学编程那会就一直想写一个这个东西。但苦于数学进度没达到，要用到加权平均数，这东西我前两天才学到，之前对数学也一直是懒得学的状态，要不然几乎是看不懂那个算法的。

我手头有一个Special-Week写的网页版的单曲成绩计算器，就以这个为研究样本吧。以下简称原作者为sw（如有冒犯请联系修改）

数据结构设计

    // 基础的4k类
    class Dan4k {
        constructor(key1, key2, key3, key4, danName) {
            this.m_key1 = key1;
            this.m_key2 = key2;
            this.m_key3 = key3;
            this.m_key4 = key4;
            this.m_danName = danName;
        }
    }

每一个段（LN、Om），sw都单独写了一个内部类，继承Dan4k。

 // lnDan类
    class LnDan extends Dan4k {
        constructor(key1, lnKey1, key2, lnKey2, key3, lnKey3, key4, lnKey4, danName) {
            super(key1, key2, key3, key4, danName);
            this.m_lnKey1 = lnKey1;
            this.m_lnKey2 = lnKey2;
            this.m_lnKey3 = lnKey3;
            this.m_lnKey4 = lnKey4;
        }
    }
    // ma段
    class MaDan extends Dan4k {
        constructor(key1, key2, key3, key4, name1, name2, name3, name4, danName) {
            super(key1, key2, key3, key4, danName);
            this.m_name1 = name1;
            this.m_name2 = name2;
            this.m_name3 = name3;
            this.m_name4 = name4;
        }
    }
    // reform段
    class ReformDan extends Dan4k {
        constructor(key1, key2, key3, key4, name1, name2, name3, name4, danName) {
            super(key1, key2, key3, key4, danName);
            this.m_name1 = name1;
            this.m_name2 = name2;
            this.m_name3 = name3;
            this.m_name4 = name4;
        }

    }
    // om段
    class OmDan extends Dan4k {
        constructor(key1, key2, key3, key4, danName) {
            super(key1, key2, key3, key4, danName);
        }
    }

我打算重写的程序不带LN玩了，我自己也没玩过LN，不清楚是什么机制。那就来看看剩下的几个类。

Dan4k类定义了一个段位的基础属性，但是这个参数key1-4是用来做什么在当前上下文暂且不清楚，是第n首歌的物量吧。

那么由此可以推断，这些类都描述了一个谱面的基本属性：

物量
歌曲名称
段位名称然后分支匹配数据并计算。我也用C语言实现一个。

// 整个段位信息
typedef struct Dan {
    // 段位名字
    char* dan_name; 
    // 四首歌的名字，用于匹配数据
    char* song1_name;
    char* song2_name;
    char* song3_name;
    char* song4_name;
    // 四首歌的物量
    int song1_key;
    int song2_key;
    int song3_key;
    int song4_key;
}Dan;

来看看网页版中数据是如何存储的

    // MaDan数据
    let MaArr = [
        new MaDan(813, 955, 907, 654, "Glitch Nerds", "Borealis", "Niflheim", "Moon", "1dan"),
        new MaDan(1152, 850, 950, 969, "Follow Tomorrow", "Bronze Coffin", "Keigan no Zettaireido", "SakuraMirage", "2dan"),
        new MaDan(1169, 1143, 974, 1347, "Quon", "Genkyoku o Kirikizamu", "Gin no Kaze", "Adjudicatorz-Danzai-", "3dan"),
        new MaDan(1400, 1402, 1685, 1599, "Tenkuu no Yoake", "VALLISTA", "Crystal World ~Fracture~", "Zenithalize", "4dan"),
        new MaDan(1953, 2250, 2166, 1667, "Ten Thousand Tons of Anonymous Letters", "Chips of Notes", "Despair of Elferia", "Kamigami no Asobi", "5dan"),
        new MaDan(1487, 1424, 1381, 1587, "Sweet Cherry X", "Akasagarbha", "HELLO EveryOne", "DataErr0r", "6dan"),
        new MaDan(1909, 1814, 1777, 2681, "Fairy Stage", "Xross Infection", "Wave", "Blue Zenith", "7dan"),
        new MaDan(1962, 1067, 2388, 1772, "The Lost Dedicated", "The Party We Have Never Seen", "Finixe", "Ultimate Dream", "8dan"),
        new MaDan(1799, 2023, 2283, 1787, "Dusk", "Panic Popn Picnic", "Kick-ass Kung-Fu Carnival", "Yakusoku no kimi", "9dan"),
        new MaDan(2606, 2188, 2194, 2187, "Chaser", "Loli Fantasy", "Daydream", "Moon Gate", "10dan"),
        new MaDan(2160, 1952, 1821, 3249, "Border of Life", "Scorpion Dance", "The Island of Albatross", "beautiful loli thing", "ex1"),
        new MaDan(2871, 2024, 1871, 2452, "Hitsune no youmeiri", "紫阳花-AZISAI-", "love&justice", "message", "ex2"),
        new MaDan(2327, 1593, 2166, 2200, "Jumble Rumble", "End Time", "++", "Crow Solace", "ex3"),
        new MaDan(2731, 2653, 2033, 2761, "EDM Jumpers", "line-epsilon", "Contrapasso -paradiso-", "YELL!", "ex4"),
        new MaDan(3229, 2731, 2561, 2109, "Satori de Pon!", "Legend of Seeker", "Crystal World -Fracture-", "Wizdomiot", "ex5"),
        new MaDan(1766, 1861, 3171, 1680, "Sepia", "Nopea", "Satori Trisis", "Death", "ex6"),
        new MaDan(2339, 2461, 2511, 2177, "Paranoia", "Boulafacet", "Paraclete -Miracle-", "Yumemi no Shonen", "ex7"),
        new MaDan(1929, 2380, 2710, 4675, "Martail Arts", "Gene Disruption", "Paradigm Shift", "Death Melody", "ex8"),
        new MaDan(3468, 3335, 3698, 5061, "Only my railgun", "-Purgatorium-", "Blue Zenith", "Inner Universe", "exfin"),

        new MaDan(492, 529, 595, 681, "Ikitoshi Ikerumono", "Rambling Pleat", "Yi Meng Qian Xiao", "White Eternity", "0danv3"),
        new MaDan(695, 621, 718, 1279, "Rex Incoqnito", "Koiseyo Otome!", "Break", "KING", "1danv3"),
        new MaDan(1397, 1090, 805, 1212, "Stargazer", "Seyana", "Love Emotion", "Mermaid Girl", "2danv3"),
        new MaDan(1055, 1489, 1288, 1789, "Koi Kou Enishi", "Onegai!Kon Kon Oinari-sama", "The Last page", "Hoshi ga Furanai Machi", "3danv3"),
        new MaDan(1865, 1434, 1284, 1839, "Umiyuri Kaiteitan", "Fire in the sky", "Icyxis", "The Crimson Empire", "4danv3"),
        new MaDan(1282, 1706, 1473, 1939, "Platinum Disco", "Cute na Kanojo", "Reimei Sketchbook", "Joker", "5danv3"),
        new MaDan(1694, 1636, 1803, 2115, "Chocolate Disco", "Call Me, Beep Me (If You Wanna Reap Me)", "DIE IN THE SEA", "unhappy century", "6danv3"),
        new MaDan(1701, 1799, 2132, 1899, "Don't Stop The Music", "Six Acid Strings", "Arkadia [Illusion]", "Valkyrie Revolutia", "7danv3"),
        new MaDan(2237, 2081, 2280, 2000, "Don't let you down", "Yoru ni Kakeru", "Snow Veil -Shoujo to Kemono no Mori-", "Positive Dance Time", "8danv3"),
        new MaDan(2374, 1899, 2142, 1810, "Kikai Shoujo Gensou", "Cold Planet", "Stray Star", "Unleashed World", "9danv3"),
        new MaDan(2034, 1740, 2270, 2166, "Hiensou", "Rocky Buinne", "Yue Ai Yue Ye", "Spin Eternally", "10danv3"),
        new MaDan(1952, 2013, 1953, 2111, "Scorpion Dance", "Tailin no Soul", "Eiya no Parade", "Onsoku Uchuu Ryokou", "ex1v3"),
        new MaDan(2107, 1953, 2386, 2674, "Moments", "Towards the Horizon", "Torikago", "Frontier Explorer", "ex2v3"),
        new MaDan(2518, 2636, 2326, 2511, "Edison", "INTERNET OVERDOSE", "Euthanasia", "Fin.ArcDeaR", "ex3v3"),
        new MaDan(2634, 2212, 2336, 2602, "ZENITHALIZE", "Asymmetrical Grooves", "Pure Ruby", "EVERLASTING HAPPiNESS", "ex4v3"),
        new MaDan(2734, 2417, 3089, 2974, "Bring Our Ignition Back", "Unsan-musho", "Electric Angel", "Kegare Naki Bara Juuji", "ex5v3"),
        new MaDan(2483, 2276, 2921, 3194, "Defeat awaken battle ship", "Extraction", "Pastel Subliminal", "Synthesized Fortress", "ex6v3"),
        new MaDan(2846, 2260, 2333, 3347, "LiFE Garden", "Alpha", "Stay Alive", "Heaven's Fall", "ex7v3"),
        new MaDan(3789, 3663, 2424, 3255, "Hayabusa", "Shuu no hazama", "Amatsukami", "CRIMSON FIGHTER", "ex8v3"),
        new MaDan(3888, 3030, 3581, 3700, "crazy_tek (DJ Noriken Remix)", "Nhelv", "Shuuten", "Deadly force - Put an end", "ex9v3"),
        new MaDan(2828, 3362, 3393, 5100, "Infinity Heaven", "NEURO-CLOUD-9", "Kizuato", "Runengon", "exfinv3"),
    ]

可以看到，简单地调用构造函数新建对象。继续实现：我们可以写一个init函数，根据需要创建结构体变量。

Dan* dan_data_init(Dan*, int* songs_key);

第二个参数是存放物量的数组，这样就实现了代码复用，减少重复代码的编写，定义一次所有物量即可。

// 常规段
int mld_1dan_total_keys[] = {813, 955, 907, 654};
int mld_2dan_total_keys[] = {1152, 850, 950, 969};
int mld_3dan_total_keys[] = {1169, 1143, 974, 1347};
int mld_4dan_total_keys[] = {1400, 1402, 1685, 1599};
int mld_5dan_total_keys[] = {1953, 2250, 2166, 1667};
int mld_6dan_total_keys[] = {1487, 1424, 1381, 1587};
int mld_7dan_total_keys[] = {1909, 1814, 1777, 2681};
int mld_8dan_total_keys[] = {1962, 1067, 2388, 1772};
int mld_9dan_total_keys[] = {1799, 2023, 2283, 1787};
int mld_10dan_total_keys[] = {2606, 2188, 2194, 2187};

这里目前把常规段都录入了，那要怎么按需匹配创建结构体变量呢？可以通过一个指针数组保存这些数据数组的地址，然后根据用户输入的数字直接作为索引，创建结构体变量并进行初始化赋值。

优点：避免if/switch分支判断逐个比较，时间复杂度为常数阶。

int* dan_total_keys_index[] = {mld_1dan_total_keys, mld_2dan_total_keys, mld_3dan_total_keys, mld_4dan_total_keys, mld_5dan_total_keys, mld_6dan_total_keys, mld_7dan_total_keys, mld_8dan_total_keys, mld_9dan_total_keys, mld_10dan_total_keys};

后续接着往这个数组里面装指针即可。

基本的数据结构实现了，就可以开始研究一下算法，后续再录入数据吧。

算法实现

曾经听群友讲过这个东西核心理念是加权平均数，最近才学到，那就来看看怎么做这个平均数吧。

直接看原作者是怎么实现的

 function normal_calculation(accArr, noteArr) {
            let score1 = accArr[0]
            let temp1 = (noteArr[0] + noteArr[1]) * accArr[1] - noteArr[0] * accArr[0]
            let score2 = temp1 / (noteArr[1])
            let temp2 = (noteArr[0] + noteArr[1] + noteArr[2]) * accArr[2] - (noteArr[0] + noteArr[1]) * accArr[1]
            let score3 = temp2 / (noteArr[2])
            let temp3 = (noteArr[0] + noteArr[1] + noteArr[2] + noteArr[3]) * accArr[3] - (noteArr[0] + noteArr[1] + noteArr[2]) * accArr[2]
            let score4 = temp3 / (noteArr[3])
            return [score1, score2, score3, score4]
        }

第一首的ACC不变，这个不说了。

这个temp算的是什么？？？

刚刚去看了一下引用，accArr存放着四首的玩家成绩Acc，noteArr存着这四首歌的Note总数量。

还是没搞明白这个temp在干什么，看这段代码是真想骂街啊。

用1dan举例子，Note和ACC：

813, 955, 907, 654
99   98   96   94

~~叠批来了~~

Malody的每一个判定都有不同的权重，都有对应不同的Acc衰减，所以每一首歌曲结束后都是一个加权平均数。程序要做的事情就是逆推出原本的Acc。

所以accArr是一个累计加权平均值数组。 noteArr是每批数据的权重。目标：计算每批数据的独立加权平均值。

数学逻辑

第一批数据：

let score1 = accArr[0]

直接使用第一个累计平均值a1，此时只有第一批数据。

第二批数据：

let temp1 = (noteArr[0] + noteArr[1]) * accArr[1] - noteArr[0] * accArr[0] 
let score2 = temp1 / noteArr[1]

累计平均值a2 = (n1s1 +n2s2) / (n1 + n2)
解得s2:(n1 +n2)a2 - n1s1 / n2 ……

额…这一顿推导，给我也整不会了。我数学奇烂，那就用一个简明易懂的例子来理解吧。

人话

假设参加了4次考试

第一次考了80分(score1)
第二次的平均分是93.3(accArr[1])
第三次的平均分是95(accArr[2])
第四次的平均分是97.5(accArr[3])

但是你忘了每次考试的重要程度（权重）：

第一次考试占10(noteArr[0] = 10)
第二次 20(noteArr[1] = 20)
第三次 30(noteArr[2] = 30)
第四次 40(noteArr[3] = 40)

你想知道每次考试单独的平均分是多少

第一次考试：直接用平均分（因为只有一次考试）
第二次考试：先算总分：前两次总分 = (10+20)*93.3 = 2800 减去第一次的分数：第二次分数 = 2800 - 10 * 80 = 2000 第二次平均分： score2 = 2000 / 20 = 100
第三次考试：总分：(10 + 20 + 30 )*95 = 5700 减去前两次：第三次分数 = 5700 - 2800 平均分：score3 = 2900 / 30 ≈ 96.7
第四次考试总分：(10+20+30+40)*97.5 = 9750 减去前3次：第四次分数 = 9750 - 5700 = 4050 平均分：score4 = 4050 / 40 = 101.25

写着写着突然发现

typedef struct Dan
{
    // 四首歌的物量
    int* songs_total_keys;
} Dan;

这个数据结构只需要一个数组。

人话说完了，该说说计算机的话了。

实现

double *common_calc(int *total_keys, double *player_acc)
{
    // 权重：total_keys
    // 分数：player_acc
    // 返回的数组，保存计算完成的Acc
    double *result = (double *)malloc(sizeof(double) * 4);
    if (result == NULL)
    {
        printf("[ERROR] 内存分配失败！");
        return NULL;
    }

    double song1_acc, song2_acc, song3_acc, song4_acc;

    // 第一首歌：直接取第一个累积平均值
    result[0] = player_acc[0];

    // 第二首歌：((n0 + n1)*a1 - n0*a0) / n1
    double sum2 = total_keys[0] + total_keys[1];
    result[1] = (sum2 * player_acc[1] - total_keys[0] * player_acc[0]) / total_keys[1];

    // 第三首歌：((n0 + n1 + n2)*a2 - (n0 + n1)*a1) / n2
    double sum3 = sum2 + total_keys[2];
    result[2] = (sum3 * player_acc[2] - sum2 * player_acc[1]) / total_keys[2];

    // 第四首歌：((n0 + n1 + n2 + n3)*a3 - (n0 + n1 + n2)*a2) / n3
    double sum4 = sum3 + total_keys[3];
    result[3] = (sum4 * player_acc[3] - sum3 * player_acc[2]) / total_keys[3];

    return result;
}

然后就是主函数处理用户输入了，没什么含金量，不水了。

【数据结构与算法】哈希表

i@glowisle.me (五葉地錦) — Wed, 28 May 2025 21:44:28 +0000

哈希表（Hash Table）是一种基于键（Key）直接访问数据的高效数据结构，其核心思想是通过哈希函数将键映射到数组的特定位置，从而实现平均时间复杂度为 O(1)O(1) 的插入、查找和删除操作。

结构定义

// 哈希表节点
typedef struct HashNode {
    int key;
    int value;
    struct Hashcode* next;
} HashNode;

// 哈希表
typedef struct {
    int size;
    HashNode** buckets;
} HashTable;

初始化

创建HashTable结构体变量，进行初始化赋值，分配桶的内存。

// 初始化哈希表
HashTable *creat_hash_table(int size)
{
    HashTable* table = (HashTable*)malloc(sizeof(HashTable));
    table->size = size;
    table->buckets = (HashNode**)malloc(size * sizeof(HashNode*));
    for(int i = 0; i < size; i++)
    {
        table->buckets[i] = NULL;
    }
    return table;
}

哈希函数

// 哈希函数
int hash(int key, int size)
{
    return key % size;
}

通过简单取模运算获得哈希值

插入

// 插入
void insert(HashTable *table, int key, int value)
{
    int index = hash(key, table->size);
    HashNode *newNode = (HashNode *)malloc(sizeof(HashNode));
    newNode->key = key;
    newNode->value = value;
    newNode->next = NULL;

    // 插入链表头部，避免遍历链表
    if (table->buckets[index] == NULL)
    {
        table->buckets[index] = newNode;
    }
    else
    {
        newNode->next = table->buckets[index];
        table->buckets[index] = newNode;
    }
}

头插法无需遍历到尾部。

查找

// 查找

int search(HashTable *table, int key)
{
    int index = hash(key, table->size);
    HashNode *current = table->buckets[index];
    while (current != NULL)
    {
        if (current->key == key)
        {
            return current->value;
        }
        current = current->next;
    }
    return -1;
}

删除

void deleate(HashTable* table, int key)
{
	int index = hash(key, table->size);
	HashNode* current = table->buckets[index];
	HashNode* prev = NULL;

	while(current != NULL)
	{
		if(current->key == key)
		{
			if(prev == NULL)
			{
				table->buckets[index] = current->next;
			}
			else
			{
				prev->next = current->next;
			}

			free(current);
			return;
		}
			prev = current;
			current = current->next;
	}
}

【数据结构与算法】众数、中位数

i@glowisle.me (五葉地錦) — Tue, 27 May 2025 19:41:53 +0000

今天学这个东西的时候，看到这种线性的数据结构加上排序步骤，很难不想写个程序来跑跑。

先来说说中位数，这个比较有思路。

中位数

具体的操作步骤应该是：排序 => 获得数据元素个数n => 是奇数 ? (n+1) / 2 : n / 2

那么排序就用之前学的冒泡排序，这种题目大概不会完全倒序给数据，编写sort函数：

void sort(int arr[], int n)
{
  for (int i = 0; i < n - 1; i++) {
    for (int j = 0; j < n - i - 1; j++) {
      if (arr[j] > arr[j + 1]) {
        int temp = arr[j];
        arr[j] = arr[j + 1];
        arr[j + 1] = temp;
      }
    }
  }
}

接下来是判断奇偶，奇偶的判断非常简单，对取模运算的值比对就可以，编写is_even函数，判断奇偶性。

int is_even(int data)
{
  if (data % 2 == 0) {
    return true;
  } else {
    return false;
  }
}

完成了奇偶判断，下一步就可以正式进行中位数的运算，编写get_median函数。

double get_median(int arr[], int length)
{
  // 获取索引
  double result = 0;
  sort(arr, length);
  if (is_even(length)) {
    int median_index_1 = arr[(length / 2) - 1];
    int median_index_2 = arr[length / 2];
    // 计算数据
    result = (median_index_1 + median_index_2) / 2.0;
  } else {
    result = arr[length / 2];
  }

  return result;
}

这个函数首先计算了中位数在数组的哪个索引，然后进行了计算。

众数

众数（Mode）是指在统计分布上具有明显集中趋势点的数值，代表数据的一般水平。也是一组数据中出现次数最多的数值，有时众数在一组数中有好几个。用M表示。

那么，在程序中，想要计算一个值出现的次数并比对，可拆分为两步。

计算出每一个数据出现的次数
结果排序比对
找出最大值

我没学过什么高级的数据结构，就用这个复制数组的笨办法吧。

int get_mode(int arr[], int length)
{
  int *copy_arr = malloc(length * sizeof(int));
  memcpy(copy_arr, arr, length * sizeof(int));
  sort(copy_arr, length);

  int max_count = 0;
  int current_count = 1;
  int mode = copy_arr[0];

  for (int i = 1; i < length; i++) {
    if (copy_arr[i] == copy_arr[i - 1]) {
      current_count++;
    } else {
      if (current_count > max_count) {
        max_count = current_count;
        mode = copy_arr[i - 1];
      }
      current_count = 1;
    }
  }

  if (current_count > max_count) {
    mode = copy_arr[length - 1];
  }

  free(copy_arr);
  return mode;
}

这个函数干了以下几件事：

复制数组
排序复制好的数组
对比数组元素，如果array[i] == array[i - 1]，出现次数+1
如果遇到新元素，检查是否需要更新最大值
动态更新众数值

测试跑一把，输出如下

int main()
{
  int arr[] = {1, 1, 1, 1, 2, 2, 4, 5, 7, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2};
  int length = sizeof(arr) / sizeof(arr[0]);
  int result = get_mode(arr, length);
  printf("result = %d\n", result);
}

result = 4

~~这个办法实在是有点蠢，找时间仔细学学哈希表，应该能更快。~~

【数据结构与算法】二叉树

i@glowisle.me (五葉地錦) — Sun, 25 May 2025 18:46:37 +0000

定义

二叉树（binary tree）是指树中节点的度不大于2的有序树，它是一种最简单且最重要的树。二叉树的递归定义为：二叉树是一棵空树，或者是一棵由一个根节点和两棵互不相交的，分别称作根的左子树和右子树组成的非空树；左子树和右子树又同样都是二叉树。

实现

结构定义

~~尝试了一下C语言，各种指针乱指，各种bug，暂时放自己一马，跟自己和解一下用js写写吧。~~

class TreeNode {
  constructor(data) {
    this.data = data;
    this.left = null;  // 左节点
    this.right = null; // 右边节点
  }
}

创建对象并绑定节点

// 手动绑定节点
let root = new TreeNode(1)
root.left = new TreeNode(2)
root.right = new TreeNode(3)
root.left.left = new TreeNode(4)
root.right.right = new TreeNode(5)

此时树的结构：

遍历二叉树

前序遍历（DFS）

function preOrder(node) {
  if(node) {
    console.log(node.data)
    preOrder(node.left)
    preOrder(node.right)
  }
}

这里用递归调用，遍历到左右元素

层序遍历（BFS）

function levelOrder(root) {
  const queue = [];
  queue.push(root);
  while (queue.length) {
    const node = queue.shift();
    console.log(node.data);
    if (node.left) queue.push(node.left);
    if (node.right) queue.push(node.right);
  }
}

【数据结构与算法】栈

i@glowisle.me (五葉地錦) — Sun, 11 May 2025 10:09:21 +0000

基本概念

栈（Stack）是一种后进先出（LIFO）原则的线性数据结构。核心操作包括：

压栈（Push）：将元素添加到栈顶
出栈（Pop）：移除并返回栈顶元素
查看栈顶（Check）获取但移除栈顶元素
判空（is_empty）检查栈是否为空

结构定义

使用动态数组实现栈，包含三个核心属性：

typedef struct Stack {
    int* data; // 存储元素的数组
    int top;   // 栈顶指针（当前元素位置）
    int capacity; // 栈的最大容量
}

data：动态分配的数组指针
top：初始值为-1，表示空栈，压栈时递增，出栈时递减
capacity：栈的容量上限

功能实现

初始化

// 初始化栈
void init_stack(Stack *s, int capacity) {
  // 计算最大容量
  s -> data = (int*)malloc(sizeof(int) * capacity)
  if(!s -> data) {
    printf("内存分配失败！\n");
    exit(1);
  }
  // 初始化栈顶为-1，表空
  s -> top = -1;
  // 把当前计算的最大容量赋值给传进来的栈
  s -> capacity = capacity;
}

这个函数中进行了动态分配内存计算最大容量，初始化赋值和异常处理。

压栈（Push）

// 压栈（Push）
void push(Stack *s, int value) {
  if (s -> top = s -> capacity -1) {
    printf("栈已满！\n");
    return;
  }
  s -> data[++s->top] = value;
}

检查栈是否已满，先递增指针再存入数据

出栈（Pop）

// 出栈（Pop）
int pop(Stack *s) {
  if(is_empty(s)) {
    printf("栈为空！\n");
    return -1;
  }
  return s->data[s->top--];
}

检查栈是否为空，返回当前栈顶元素后移动指针

辅助功能

// 判空
int is_empty(Stack *s) {
  return s-> top == -1
}

// 查看栈顶元素
int peek(Stack *s) {
  return is_empty(s) ? -1 : s->data[s->top];
}

// 销毁
void destory_stack(Stack *S) {
  free(s->data);
  s -> top = -1;
  s -> capacity = 0;
}

【数据结构与算法】冒泡排序

i@glowisle.me (五葉地錦) — Sat, 10 May 2025 20:06:05 +0000

核心思想

通过相邻元素的两两比较，将较大的元素逐步“冒泡”到数组末尾，每轮排序确定一个最大元素的最终位置。

代码实现

void bubble_sort(int arr[], int n) {
  // 最外层控制循环轮数 n-1轮
  for (int i = 0; i < n - 1; i++) {
    // 内层循环处理相邻元素比较和交换
    for(int j = 0; j < n-i-1; j++) {
      if (arr[j] > arr[j+1]) {
        int temp = arr[j];
        arr[j] = arr[j+1];
        arr[j+1] = temp;
      }
    }
  }
}

// 调用
void print_array(int arr[], int size) {
  for (int i = 0; i < size; i++) {
    printf("%d,", arr[i]);
  }
  printf("\n");
}

int main() {
  int arr[] = {23, 232, 55, 2, 7, 0, 576, 342};
  int n = sizeof(arr) / sizeof(arr[0]);

  printf("排序前：");
  print_array(arr, n);
  bubble_sort(arr, n);

  printf("排序后");
  print_array(arr, n);
}

原理分析

外层循环的 i < n - 1

n个元素的数组最多需要n-1轮冒泡，如5元素数组需要4轮排序
数学依据：每轮将一个最大值“沉底”，当完成n-1轮时，最后一个元素必然有序

示例验证：

原始数组：[3, 1, 4, 2]
第一轮：[1, 3, 2, 4] （确定最大值4）
第二轮：[1, 2, 3, 4]

用文字解释上面的函数，原理就是在循环中对比数组第i个元素和i+1（即后一位）元素的大小，若i > i +1 则把两者交换位置，随着循环的进行，数组就会被排序。

内层循环的 j < n - i - 1

动态缩小范围：每轮结束后末尾i个元素已有序
比较次数：第i轮需要比较(n-1)-i次相邻元素

想象一下数组的线性结构，实际上就是在计算排序后的一位的前一位，这样就不会处理已经排序好的元素，进入下一轮循环时可正常排序。

数组长度n的计算机制

在main函数中，对于n的计算，采用了sizeof(arr) / sizeof(arr[0])的方式。可以这么理解。

int arr[] = {6,4,8,2};
假设int占用4字节，计算整个数组的内存占用
sizeof(arr) = 5 * 4 = 20
sizeof(arr[0]) = 4
n = 20 / 4 = 5

计算出数组的总占用，再除以单个占用，就可以得到元素个数了。

参数n的作用

循环控制：确定外层循环次数n-1次
边界保护，防止越界
效率优化：避免无效比较，如j<n-i-1

最坏情况

冒泡排序的最坏情况发生在输入数组完全逆序情况下，此时算法需要进行最大次数的比较和交换操作，时间复杂度达到最高。

当待排序数组的初始状态为完全逆序，如[5,4,3,2,1]，每一轮外层循环都要将当前为排序部分的最大元素冒泡到正确位置，而且每次比较都会发生交换，此时：

比较次数：共需要进行*(n - 1) + (n - 2) + …*（等差数列求和）。
交换次数：每次比较均需要交换，总交换次数也为上式结果。