Go语言程序：按姓名排序员工

在某些情况下，您可能需要一个员工列表，并需要根据他们的姓名首字母以特定顺序显示他们。在这篇 Go 语言文章中，我们将使用冒泡排序、插入排序以及 Go 的排序包来对员工姓名进行排序。

算法

  • 在 Employee 结构体中创建一个名为“Name”的字段。

  • 将 Employee 对象数组作为“BubbleSortByEmployeeName”方法的输入。

  • 获取员工数组的长度并将其保存在变量 n 中。

  • 从 i = 0 到 n-1 开始外循环，从 j = 0 到 n-i-1 开始内循环。

  • 将 employees[j].Name 与 employees[j+1].Name 进行比较。

  • 函数“BubbleSortByEmployeeName”返回。

  • 在 main 方法中创建一个名为 employees 的 Employee 对象数组。

  • 通过遍历 employees 数组打印所有员工的姓名。

  • 使用 employees 数组作为使用 BubbleSortByEmployeeName 方法时的参数。

  • 通过遍历 employees 数组打印所有员工的姓名。

示例 1：冒泡排序

冒泡排序是一种简单的算法，它比较相邻的字母，如果它们顺序错误则交换它们。

package main
import "fmt"

type Employee struct {
   Name string
}

func BubbleSortByEmployeeName(employees []Employee) {
   n := len(employees)
   for i := 0; i < n-1; i++ {
      for j := 0; j < n-i-1; j++ {
         if employees[j].Name > employees[j+1].Name {
            employees[j], employees[j+1] = employees[j+1], employees[j]
         }
      }
   }
}

func main() {
   employees := []Employee{
      {Name: "Nitin"},
      {Name: "Akshay"},
      {Name: "Sahil"},
      {Name: "Akhil"},
   }

   fmt.Println("Before sorting:")
   for _, employee := range employees {
      fmt.Println(employee.Name)
   }

   BubbleSortByEmployeeName(employees)

   fmt.Println("\nAfter sorting:")
   for _, employee := range employees {
      fmt.Println(employee.Name)
   }
}

输出

Before sorting:
Nitin 
Akshay 
Sahil
Akhil 

After sorting: 
Akhil 
Akshay 
Nitin 
Sahil

示例 2：插入排序

插入排序也是一种简单的排序算法，它通过一次使用一个项目来构建最终的排序数组。它的工作原理是将一个元素从未排序的部分插入到排序数组中的正确位置。

package main
import "fmt"

type Employee struct {
   Name string
}

func InsertionSortByEmployeeName(employees []Employee) {
   n := len(employees)
   for i := 1; i < n; i++ {
      key := employees[i]
      j := i - 1
      for j >= 0 && employees[j].Name > key.Name {
         employees[j+1] = employees[j]
         j--
      }
      employees[j+1] = key
   }
}

func main() {
   employees := []Employee{
      {Name: "Krishan"},
      {Name: "Ram"},
      {Name: "Seeta"},
      {Name: "Radha"},
   }

   fmt.Println("Before sorting:")
   for _, employee := range employees {
      fmt.Println(employee.Name)
   }

   InsertionSortByEmployeeName(employees)

   fmt.Println("\nAfter sorting:")
   for _, employee := range employees {
      fmt.Println(employee.Name)
   }
}

代码

Before sorting: 
Krishan 
Ram 
Seeta 
Radha 

After sorting: 
Krishan 
Radha 
Ram 
Seeta

示例 3：使用 Go 排序包

Sort.sort() 是一个内置的 Go 语言函数，支持多种排序算法和接口。它提供了一种更有效、更灵活的数据结构排序方法。

package main

import (
   "fmt"
   "sort"
)

type Employee struct {
   Name string
}

type EmployeeSortByName []Employee

func (e EmployeeSortByName) Len() int {
   return len(e)
}

func (e EmployeeSortByName) Less(i, j int) bool {
   return e[i].Name < e[j].Name
}

func (e EmployeeSortByName) Swap(i, j int) {
   e[i], e[j] = e[j], e[i]
}

func main() {
   employees := []Employee{
      {Name: "Krishan"},
      {Name: "Ram"},
      {Name: "Radha"},
      {Name: "Seeta"},
   }

   fmt.Println("Before sorting:")
   for _, employee := range employees {
      fmt.Println(employee.Name)
   }

   sort.Sort(EmployeeSortByName(employees))

   fmt.Println("\nAfter sorting:")
   for _, employee := range employees {
      fmt.Println(employee.Name)
   }
}

输出

Before sorting: 
Krishan 
Ram 
Radha 
Seeta 

After sorting: 
Krishan 
Radha 
Ram 
Seeta

结论

在本文中，我们研究了三种不同的方法来根据 Go 中员工的姓名对一组 Employee 对象进行排序。虽然冒泡排序和插入排序算法的实现很简单，但对于大型数据集来说，它们可能不是最有效的。相比之下，Go 的排序包通过使用各种排序算法提供了更可靠、更有效的解决方案。

更新于: 2023年7月6日

138 次浏览

开启你的 职业生涯

通过完成课程获得认证

开始学习
广告