Trung tâm cá nhân
sách gpt4 ai đã đi

Giải pháp Golang để sắp xếp các loại tùy chỉnh

In lại Tác giả:qq735679552 Thời gian cập nhật: 2022-09-29 22:32:09 27 4
mua khóa gpt4 Nike

CFSDN nhấn mạnh vào việc tạo ra giá trị thông qua mã nguồn mở. Chúng tôi cam kết xây dựng một nền tảng chia sẻ tài nguyên để mọi người làm CNTT có thể tìm thấy thế giới tuyệt vời của riêng mình tại đây.

Bài đăng trên blog CFSDN này về giải pháp sắp xếp các kiểu tùy chỉnh của Golang được tác giả thu thập và sắp xếp. Nếu bạn quan tâm đến bài viết này, hãy nhớ thích nó.

Lời nói đầu.

Ngôn ngữ Go hỗ trợ các kiểu tùy chỉnh. Trong các dự án thực tế, chúng ta thường cần sắp xếp theo một trường của một kiểu cấu trúc. Tôi đã gặp phải vấn đề này trước đây và không biết cách giải quyết. Sau đó, tôi đã tìm kiếm các vấn đề liên quan trên Internet và tìm thấy một số giải pháp tốt. Sau đây là tài liệu tham khảo và tóm tắt.

Vì gói golang sort tự cung cấp các hàm tương ứng nên không cần phải phát minh lại bánh xe. Hãy cùng xem cách sử dụng gói sort để đạt được điều đó.

Một cuộc thảo luận ngắn gọn về gói sắp xếp.

Golang cũng triển khai gói sort cho các thuật toán sắp xếp. Gói sort triển khai bốn thuật toán sắp xếp cơ bản bên trong: sắp xếp chèn (insertionSort), sắp xếp trộn (symMerge), sắp xếp đống (heapSort) và sắp xếp nhanh (quickSort); gói sort sẽ tự động chọn thuật toán sắp xếp tối ưu dựa trên dữ liệu thực tế.

Vì vậy, khi viết code, chúng ta chỉ cần cân nhắc triển khai kiểu sort.Interface.

Hãy xem nhanh gói sắp xếp.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
hai mươi mốt
hai mươi hai
hai mươi ba
hai mươi bốn
25
26
27
28
func Sort(giao diện dữ liệu) {
  // Chuyển sang heapsort nếu đạt đến độ sâu 2*ceil(lg(n+1)).
  n := dữ liệu. Len()
  Độ sâu tối đa := 0
  vì tôi := n; tôi > 0; tôi >>= 1 {
  Độ sâu tối đa++
  }
  Độ sâu tối đa *= 2
  quickSort(dữ liệu, 0, n, maxDepth)
}
loại Giao diện giao diện {
  // Len là số phần tử trong tập hợp.
  Len() số nguyên
  // Ít báo cáo liệu phần tử có
  // chỉ số i phải được sắp xếp trước phần tử có chỉ số j.
  Ít hơn(i, j số nguyên ) bool
  // Swap hoán đổi các phần tử có chỉ số i và j.
  Hoán đổi(i, j số nguyên )
}
// Bốn thuật toán sắp xếp được triển khai nội bộ
// Sắp xếp chèn
func insertSort(giao diện dữ liệu, a, b số nguyên )
// Sắp xếp đống
func heapSort(giao diện dữ liệu, a, b số nguyên )
// Sắp xếp nhanh
func quickSort(giao diện dữ liệu, a, b, maxDepth số nguyên )
// Sắp xếp hợp nhất
func symMerge(giao diện dữ liệu, a, m, b số nguyên )

Vì vậy, để gọi sort.Sort() để triển khai sắp xếp kiểu tùy chỉnh, chúng ta chỉ cần kiểu của mình để triển khai ba phương thức trong kiểu giao diện Interface.

Trước tiên chúng ta hãy xem cách gói sort sắp xếp kiểu []int.

?
1
2
3
4
5
6
7
8
9
10
11
// Đầu tiên, định nghĩa một bí danh kiểu []int được gọi là IntSlice
kiểu IntSlice[] số nguyên
// Lấy độ dài của lát cắt này
hàm (p IntSlice) Len() số nguyên   { trở lại dài(p) }
// So sánh kích thước của hai phần tử theo thứ tự tăng dần
func (p IntSlice) Ít hơn(i, j số nguyên ) bool { trở lại p[i] < p[j] }
// Trao đổi dữ liệu
func (p IntSlice) Swap(i, j số nguyên ) { p[i], p[j] = p[j], p[i] }
// sort.Ints() gọi phương thức Sort() bên trong để triển khai sắp xếp
// Lưu ý rằng trước tiên bạn phải chuyển đổi []int thành kiểu IntSlice vì kiểu này triển khai ba phương thức của Giao diện
hàm Ints(a [] số nguyên ) { Sắp xếp(IntSlice(a)) }

Theo cùng một mô hình, hãy sắp xếp loại cấu trúc tùy chỉnh theo thứ tự giảm dần.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
hai mươi mốt
hai mươi hai
hai mươi ba
hai mươi bốn
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
gói chính
nhập khẩu (
  "fmt"
  "loại"
)
loại Người cấu trúc {
  Chuỗi tên
  Tuổi số nguyên
}
loại Người []Người
// Lấy độ dài của lát cắt này
func (p Người) Len() số nguyên { trở lại dài(p) }
// Sắp xếp các phần tử theo thứ tự giảm dần theo độ tuổi của chúng (viết theo logic kinh doanh của riêng bạn)
func (p Người) Ít hơn(i, j số nguyên ) bool {
  trở lại p[i].Tuổi > p[j].Tuổi
}
// Trao đổi dữ liệu
func (p Người) Swap(i, j số nguyên ) { p[i], p[j] = p[j], p[i] }
hàm main() {
  người := Người{
  {
  Tên: "kiểm tra 1" ,
  Tuổi: 20,
  },
  {
  Tên: "kiểm tra 2" ,
  Tuổi: 22,
  },
  {
  Tên: "kiểm tra 3" ,
  Tuổi: 21,
  },
  }
  fmt.Println( "Trước khi phân loại" )
  vì _, người := phạm vi người {
  fmt.Println(người.Tên, ":" , người.Tuổi)
  }
  sort.Sắp xếp(người)
  fmt.Println( "Sau khi phân loại" )
  vì _, người := phạm vi người {
  fmt.Println(người.Tên, ":" , người.Tuổi)
  }
}

Trên thực tế, nhìn chung Len() và Swap() về cơ bản không thay đổi, chỉ có phương thức Less() liên quan đến việc so sánh phần tử là thay đổi.

Chúng ta nên làm gì khi sắp xếp nhiều trường trong một cấu trúc? Chúng ta có cần phải viết ra ba phương pháp này cho mỗi lần sắp xếp không? Tất nhiên là không. Chúng ta có thể sử dụng các cấu trúc lồng nhau để giải quyết vấn đề này. Bởi vì các cấu trúc lồng nhau có thể kế thừa tất cả các thuộc tính và phương thức của cấu trúc cha.

Ví dụ, nếu tôi muốn sắp xếp cặp trường Tên và Tuổi của Người ở trên, chúng ta có thể sử dụng các cấu trúc lồng nhau để cải thiện nó.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
hai mươi mốt
hai mươi hai
hai mươi ba
hai mươi bốn
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
gói chính
nhập khẩu (
  "fmt"
  "loại"
)
loại Người cấu trúc {
  Chuỗi tên
  Tuổi số nguyên
}
loại Người []Người
// Phương thức Len() và phương thức Swap() không cần phải thay đổi
// Lấy độ dài của lát cắt này
func (p Người) Len() số nguyên { trở lại dài(p) }
// Trao đổi dữ liệu
func (p Người) Swap(i, j số nguyên ) { p[i], p[j] = p[j], p[i] }
// Cấu trúc lồng nhau sẽ kế thừa tất cả các thuộc tính và phương thức của Person
// Vì vậy, nó tương đương với SortByName và cũng triển khai các phương thức Len() và Swap()
loại SortByName cấu trúc { Người }
// Sắp xếp theo thứ tự giảm dần theo độ dài của tên phần tử (viết theo logic kinh doanh của riêng bạn tại đây)
func (p SortByName) Ít hơn(i, j số nguyên ) bool {
  trở lại len(p. Người[i].Tên) > len(p. Người[j].Tên)
}
loại SortByAge cấu trúc { Người }
// Sắp xếp các phần tử theo thứ tự giảm dần theo độ tuổi của chúng (viết theo logic kinh doanh của riêng bạn)
func (p Sắp xếp theo độ tuổi) Ít hơn(i, j số nguyên ) bool {
  trở lại p.Người[i].Tuổi > p.Người[j].Tuổi
}
hàm main() {
  người := Người{
  {
  Tên: "kiểm tra123" ,
  Tuổi: 20,
  },
  {
  Tên: "kiểm tra 1" ,
  Tuổi: 22,
  },
  {
  Tên: "kiểm tra 12" ,
  Tuổi: 21,
  },
  }
  fmt.Println( "Trước khi phân loại" )
  vì _, người := phạm vi người {
  fmt.Println(người.Tên, ":" , người.Tuổi)
  }
  sort.Sort(SortByName{người})
  fmt.Println( "Sau khi phân loại" )
  vì _, người := phạm vi người {
  fmt.Println(người.Tên, ":" , người.Tuổi)
  }
}

Tóm tắt.

Trên đây là toàn bộ nội dung bài viết này, hy vọng nội dung bài viết này có giá trị tham khảo nhất định cho việc học tập hoặc công tác của bạn. Nếu có thắc mắc gì, bạn có thể để lại lời nhắn để trao đổi. Cảm ơn sự ủng hộ của bạn.

Liên kết gốc: http://www.itzh.org/2017/12/26/golang_sorts_the_custom_type/.

Cuối cùng, bài viết này về giải pháp sắp xếp kiểu tùy chỉnh của Golang kết thúc tại đây. Nếu bạn muốn biết thêm về giải pháp sắp xếp kiểu tùy chỉnh của Golang, vui lòng tìm kiếm các bài viết của CFSDN hoặc tiếp tục duyệt các bài viết liên quan. Tôi hy vọng bạn sẽ ủng hộ blog của tôi trong tương lai! .

27 4 0
Bài viết được đề xuất: Cách triển khai phiên bản MapReduce một tiến trình trong Golang
Bài viết được đề xuất: Giải thích chi tiết về tối ưu hóa đầu ra nhật ký của golang log4go
Bài viết được đề xuất: Nguyên lý cắt lát của hướng dẫn chung golang
Bài viết được đề xuất: Ví dụ về Beego để lấy dữ liệu ajax
qq735679552
Hồ sơ cá nhân

Tôi là một lập trình viên xuất sắc, rất giỏi!

Nhận phiếu giảm giá Didi Taxi miễn phí
Mã giảm giá Didi Taxi
Các bài viết nóng hổi trên toàn bộ trang web
Giấy chứng nhận ICP Bắc Kinh số 000000
Hợp tác quảng cáo: 1813099741@qq.com 6ren.com