Apakah tindanan dan timbunan dalam bahasa go?

Timbunan ialah struktur data, iaitu ruang memori yang dikhaskan untuk utas pelaksanaan; tindanan hanya membenarkan data dimasukkan ke dalam satu hujung jadual linear, dan kemudian data dikeluarkan pada hujung ini , iaitu mengikut masuk pertama, keluar terakhir, masuk terakhir, pertama Keluarkan elemen dari tindanan mengikut susunan ia dialih keluar. Timbunan ialah struktur data yang merupakan ruang memori yang dikhaskan untuk peruntukan dinamik tidak seperti timbunan, tidak ada corak tetap untuk memperuntukkan dan mengagihkan semula blok daripada timbunan itu;

Persekitaran pengendalian tutorial ini: sistem Windows 7, GO versi 1.18, komputer Dell G3.

Timbunan dan timbunan dalam bahasa Go

Terdapat dua konsep yang sangat penting dalam bahasa pengaturcaraan, timbunan dan timbunan

Timbunan dan timbunan ialah dua struktur data yang sangat penting yang sering digunakan semasa mengedit program, dan bahasa Go tidak terkecuali.

Mari kita lihat dua struktur data ini.

Timbunan

Timbunan hanya dibenarkan untuk meletakkan data ke dalam satu hujung jadual linear dan kemudian mengeluarkan data di hujung ini , iaitu, mengikut masuk pertama, keluar terakhir, Alih keluar elemen daripada timbunan dalam tertib keluar terakhir masuk dahulu.

Proses meletakkan elemen ke dalam tindanan dipanggil menolak. Menolak ke atas tindanan akan menambah bilangan elemen pada tindanan Elemen terakhir yang diletakkan pada tindanan berada di bahagian atas tindanan, dan unsur pertama yang diletakkan pada tindanan adalah di bahagian bawah tindanan.

Apabila mengeluarkan elemen daripada tindanan, ia hanya boleh dikeluarkan dari bahagian atas tindanan Selepas mengeluarkan elemen, bilangan tindanan akan menjadi lebih kecil terakhir, dan elemen yang dimasukkan terakhir akan sentiasa dikeluarkan.

Kami sering menggunakan tatasusunan untuk mensimulasikan penggunaan tindanan:

Kod pelaksanaan menolak dan meletuskan tindanan adalah seperti berikut:

package main
import (
   "fmt"
   "errors"
)

//使用数组来模拟一个栈的使用
type Stack struct {

   MaxTop int       // 表示我们栈最大可以存放数个数
   Top int          // 表示栈顶, 因为栈顶固定，因此我们直接使用Top
   arr [5]int       // 用一个数组模拟栈
}

//入栈函数
func (this *Stack) Push(val int) (err error) {

   //先判断栈是否满了
   if this.Top == this.MaxTop - 1 {
      fmt.Println("stack full")
      return errors.New("stack full")
   }
   this.Top++
   //放入数据
   this.arr[this.Top] = val
   return
}

//出栈函数
func (this *Stack) Pop() (val int, err error) {
   //判断栈是否空
   if this.Top == -1 {
      fmt.Println("stack empty!")
      return 0, errors.New("stack empty")
   }

   //先取值，再 this.Top--
   val =  this.arr[this.Top]
   this.Top--
   return val, nil
}

//遍历栈，注意需要从栈顶开始遍历
func (this *Stack) List() {
   //先判断栈是否为空
   if this.Top == -1 {
      fmt.Println("stack empty")
      return
   }
   fmt.Println("栈的情况如下：")
   for i := this.Top; i >= 0; i-- {
      fmt.Printf("arr[%d]=%d\n", i, this.arr[i])
   }
}

func main() {

   stack := &Stack{
      MaxTop : 5,    // 表示最多存放5个数到栈中
      Top : -1,      // 当栈顶为-1，表示栈为空
   }

   //入栈
   stack.Push(1)
   stack.Push(2)
   stack.Push(3)
   stack.Push(4)
   stack.Push(5)
   stack.List()//显示

   //出栈
   val, _ := stack.Pop()
   fmt.Println("出栈val=", val)    // 5
   stack.List()                    //显示
}

Timbunan

Timbunan dalam peruntukan memori adalah serupa dengan meletakkan pelbagai perabot di dalam bilik Saiz perabot boleh besar atau kecil. Apabila memperuntukkan memori, anda perlu Cari ruang yang cukup besar untuk memuatkan perabot dan kemudian letakkan perabot.

Setelah berulang kali meletakkan dan mengosongkan perabot, ruang di dalam bilik akan menjadi kucar-kacir Pada masa ini, jika anda meletakkan perabot di ruang ini, anda akan mendapati bahawa walaupun terdapat ruang yang mencukupi, setiap ruang diagihkan dalam keadaan yang berbeza. kawasan , tiada ruang berterusan untuk meletakkan perabot. Pada masa ini, pengagih memori perlu melaraskan dan mengoptimumkan ruang ini.

Berbanding dengan memori yang diperuntukkan tindanan, timbunan sesuai untuk peruntukan memori saiz yang tidak dapat diramalkan.

Peruntukan timbunan dan tindanan

Takrifan pembolehubah secara amnya diperuntukkan pada ruang timbunan dan tindanan, dalam ruang manakah ia wujud? Ia bergantung kepada sama ada terdapat peruntukan dinamik memori (baru/malloc).

Sebagai contoh, kes berikut

Kes 1

var p *int    //全局指针变量
func f(){
    var i int
    i = 1
    p = &i    //全局指针变量指向局部变量i
}

Kes 2

func f(){
    p := new(int) //局部指针变量，使用new申请的空间
    *p = 1
}

Dalam kes pertama, gunakan var untuk mentakrifkan setempat pembolehubah, Walau bagaimanapun, oleh kerana i ditugaskan kepada pembolehubah penunjuk global p, i tidak akan dikeluarkan apabila fungsi tamat, jadi pembolehubah tempatan i digunakan pada timbunan (dikeluarkan secara manual oleh pengaturcara).

• Pembolehubah setempat: pembolehubah yang ditakrifkan dalam fungsi Ia mempunyai kitaran hayat dinamik: entiti baharu dicipta setiap kali ia dilaksanakan dan bertahan sehingga tiada sesiapa menggunakannya (contohnya, tiada. penunjuk luaran Tuding kepadanya, tiada laluan untuk mengakses pembolehubah ini apabila fungsi keluar) Pada masa ini, ruang yang didudukinya akan dikitar semula

Dalam kes kedua, baharu digunakan untuk memohon ruang, kerana p akan hilang selepas keluar dari fungsi akan dikeluarkan, jadi p digunakan pada tindanan (dilepaskan secara automatik)

[Cadangan berkaitan: Pergi tutorial video, Tutorial pengaturcaraan]

Atas ialah kandungan terperinci Apakah tindanan dan timbunan dalam bahasa go?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!