通过golang实现一些经典算法问题

最新推荐文章于 2024-05-12 16:18:46 发布
最新推荐文章于 2024-05-12 16:18:46 发布
阅读量507 收藏 1
点赞数
分类专栏： Golang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44373940/article/details/104586874
版权

1、sparsearray 稀疏数组

1.1、先看一个问题
在这里插入图片描述
1.2、基本介绍
在这里插入图片描述
在这里插入图片描述
1.3、举栗说明
在这里插入图片描述
1.4、应用实例
在这里插入图片描述
在这里插入图片描述
代码：

package main

import "fmt"

/**
 *  @Description：稀疏数组
 *  @Author: guai
 *  @Date：2020/3/1 9:06
**/

type valNode struct {
	row int
	col int
	val int
}

func main() {
	//1、创建一个原始数组
	var chessMap [11][11]int
	chessMap[1][2] = 1
	chessMap[2][3] = 2

	//2、输出原始数组
	for _, v := range chessMap {
		for _, v2 := range v {
			fmt.Printf("%d\t", v2)
		}
		fmt.Println()
	}

	//3、转换成系数数据  。思考->算法
	//1)遍历chessMap，如果我们发现一个元素的值不为0，创建一个node结构体
	//2）将其放入对应的切片
	var sparseArr []valNode
	//标准的一个稀疏数组应该还有一个记录元素的二维数组的模型（行/列/默认值）
	//创建一个valNode值节点
	valArr := valNode{
		row: 11,
		col: 11,
		val: 0,
	}
	sparseArr = append(sparseArr, valArr)
	for i, v := range chessMap {
		for j, v1 := range v {
			if v1 != 0 {
				valArr := valNode{
					row: i,
					col: j,
					val: v1,
				}
				sparseArr = append(sparseArr, valArr)
			}

		}
	}
	//输出稀疏数组
	for i, valArr := range sparseArr {
		fmt.Printf("%d:%d %d %d\n", i, valArr.row, valArr.col, valArr.val)
	}

	//4、将稀疏数组复原
	//创建原始数组
	var chessMap1 [11][11]int
	for i,valArr:=range sparseArr{
		if i!=0{
			chessMap1[valArr.row][valArr.col]=valArr.val
		}
	}

	for _,val:=range chessMap1{
		for _,val1:=range val{
			fmt.Printf("%d \t",val1)
		}
		fmt.Println()
	}
}

结果：
在这里插入图片描述

2、golang中队列的实现
2.1、应用场景
在这里插入图片描述
2.2、队列介绍
在这里插入图片描述
在这里插入图片描述

2.3、数组模拟队列 front前rear后
在这里插入图片描述
2.4、实现一个非环形的队列（数组来实现）
在这里插入图片描述
在这里插入图片描述
代码：

package main

import (
	"errors"
	"fmt"
	"os"
)

/**
*  @Description： golang中队列的实现
 *  @Author: guai
 *  @Date：2020/3/1 9:34
**/
//顶定义一个队列结构体
type queueType struct {
	array   [5]int
	maxSize int
	front   int
	rear    int
}

//添加数据
func (this *queueType) addQueue(val int) (err error) {
	//判断队列满否
	if this.rear == this.maxSize-1 {
		return errors.New("queue is full")
	}
	//rear 后移
	this.rear++
	this.array[this.rear] = val
	return
}

//取出数据
func (this *queueType) getQueue() (val int, err error) {
	//判断队列空否
	if this.rear == this.front {
		return 0, errors.New("queue is empty")
	}
	this.front++
	return this.array[this.front], nil
}

//显示队列
func (this *queueType) showQueue() (err error) {
	if this.rear == this.front {
		return errors.New("queue is empty")
	}
	for i := this.front + 1; i <= this.rear; i++ {
		fmt.Printf("array[%d]:%d\n", i, this.array[i])
	}
	return nil
}
func main() {
	queueT := &queueType{
		maxSize: 5,
		front:   -1,
		rear:    -1,
	}

	var key string
	var val int
	for {
		fmt.Println("1、输入add表示添加数据到队列")
		fmt.Println("2、输入get表从队列获取数据")
		fmt.Println("3、输入show显示队列")
		fmt.Println("1、输入exit退出程序")

		fmt.Scan(&key)
		switch key {
		case "add":
			fmt.Println("请输入一个整数")
			fmt.Scan(&val)
			err := queueT.addQueue(val)
			if err != nil {
				fmt.Println("add err:", err.Error())
			} else {
				fmt.Println("add success")
			}
		case "get":
			val, err := queueT.getQueue()
			if err != nil {
				fmt.Println("get err:", err.Error())
			} else {
				fmt.Println("get val:", val)
			}
		case "show":
			err := queueT.showQueue()
			if err != nil {
				fmt.Println("show err:", err.Error())
			}
		case "exit":
			fmt.Println("exit")
			os.Exit(0)
		default:
			fmt.Println("input err,input again please!")
		}
	}
}

结果：
在这里插入图片描述
2.5、实现一个循环队列 （通过数据完成）
在这里插入图片描述

package main

import (
	"errors"
	"fmt"
	"os"
)

/**
 *  @Description： 通过数组实现循环队列  （ ctrl+r：查找替换）
 *  @Author: guai
 *  @Date：2020/3/1 10:26
**/

//定义一个循环队列
type circleQueue struct {
	array [5]int
	//最大值为4
	maxSize int
	//队列头
	head int
	//队列尾
	tail int
}

//判断队列满否
func (this *circleQueue) isFull() bool {
	return (this.tail+1)%this.maxSize == this.head
}

//判断队列空否
func (this *circleQueue) isEmpty() bool {
	return this.tail == this.head
}

//添加数据
func (this *circleQueue) push(val int) (err error) {
	//判断队列满否
	if this.isFull() {
		return errors.New("queue is full")
	}

	//分析this。tail在队尾但是包含最后的元素
	this.array[this.tail] = val
	// 当tail==4时 队尾重新回到 0的位置形成circle
	this.tail = (this.tail + 1) % this.maxSize
	return
}

//取出数据
func (this *circleQueue) pop() (val int, err error) {
	//判断队列空否
	if this.isEmpty() {
		return 0, errors.New("queue is empty")
	}
	//取出队列的值
	val = this.array[this.head]
	this.head = (this.head + 1) % this.maxSize
	return

}

//显示队列
func (this *circleQueue) show() (err error) {
	if this.isEmpty() {
		return errors.New("queue is empty")
	}
	tempHead := this.head
	for {
		if tempHead == this.tail {
			return
		}
		fmt.Printf("array[%d]:%d\n", tempHead, this.array[tempHead])
		tempHead = (tempHead + 1) % this.maxSize

	}
	return
}

//返回队列中元素个数
func (this *circleQueue) size() int {
	//这里可能 难理解 注意一点
	return (this.tail + this.maxSize - this.head) % this.maxSize
}
func main() {
	circleQ := &circleQueue{
		maxSize: 5,
		head:    0,
		tail:    0,
	}

	var key string
	var val int
	for {
		fmt.Println("1、输入add表示添加数据到队列")
		fmt.Println("2、输入get表从队列获取数据")
		fmt.Println("3、输入show显示队列")
		fmt.Println("4、输入size显示队列中的元素个数")
		fmt.Println("5、输入exit退出程序")

		fmt.Scan(&key)
		switch key {
		case "add":
			fmt.Println("请输入一个整数")
			fmt.Scan(&val)
			err := circleQ.push(val)
			if err != nil {
				fmt.Println("add err:", err.Error())
			} else {
				fmt.Println("add success")
			}
		case "get":
			val, err := circleQ.pop()
			if err != nil {
				fmt.Println("get err:", err.Error())
			} else {
				fmt.Println("get val:", val)
			}
		case "show":
			err := circleQ.show()
			if err != nil {
				fmt.Println("show err:", err.Error())
			}
		case "size":
			fmt.Println("size:", circleQ.size())
		case "exit":
			fmt.Println("exit")
			os.Exit(0)
		default:
			fmt.Println("input err,input again please!")
		}
	}
}

3、链表

3.1、链表是有序的列表，但它在内存中的存储不连续且无序，如下：

3.2、单链表示意图
链表：
通过节点中的next将多个节点连接起来 形成链表
在这里插入图片描述
3.3、单链表的应用案例

 package main

import (
	"fmt"
)

/**
 *  @Description：链表
 *  @Author: guai
 *  @Date：2020/3/1 12:20
**/
//定义节点类型
type vegetablesNode struct {
	name  string
	age   int
	skill string
	next  *vegetablesNode
}
//在末尾添加节点
func (list *vegetablesNode) add(newNode *vegetablesNode) {
	defer func() {
		err := recover()
		if err != nil {
			fmt.Println("err:", err)
		}
	}()
	//中间节点
	tempNode := list
	for {
		if tempNode.next == nil {
			break
		}
		tempNode = tempNode.next
	}
	tempNode.next = newNode

}
//显示所有节点
func (list *vegetablesNode) show() {
	tempNode := list
	for {
		if tempNode == nil {
			break
		}
		fmt.Println("node:", tempNode)
		tempNode = tempNode.next

	}
}
//在指定节点后添加节点
func (list *vegetablesNode) insertNode(name string,newNode *vegetablesNode){
	tempNode:=list
	for{
	    tempNode1:=tempNode.next

	    if tempNode==nil{
			fmt.Println("no found :",name)
			break
		}
		if tempNode.name==name{
			newNode.next=tempNode1
			tempNode.next=newNode
			fmt.Println("insert success")
			break
		}
	}
}

func main() {
	list:=vegetablesNode{
		name:"cabbage",
		age:12,
		skill:"eat",
	}

	list.add(&vegetablesNode{
		name:"radish",
		age:12,
		skill:"eat",
	})
	list.show()
	list.insertNode("cabbage",&vegetablesNode{
		name:"chives",
		age:12,
		skill:"eat",
	})
	list.show()
}

结果：
在这里插入图片描述

3.4、双向链表
每个节点中有指向前一个节点的 pre和指向后一个结点的next 形成双向的链表
在这里插入图片描述

package main

import "fmt"

/**
 *  @Description：双向链表
 *  @Author: guai
 *  @Date：2020/3/1 13:17
**/

//定义节点类型
type doublyLinkedNode struct {
	name  string
	age   int
	skill string
	pre   *doublyLinkedNode
	next  *doublyLinkedNode
}

//在末尾添加节点
func (list *doublyLinkedNode) add(newNode *doublyLinkedNode) {
	defer func() {
		err := recover()
		if err != nil {
			fmt.Println("err:", err)
		}
	}()
	//中间节点
	tempNode := list
	for {
		if tempNode.next == nil {
			break
		}
		tempNode = tempNode.next
	}
	newNode.pre=tempNode
	tempNode.next = newNode
}

//显示所有节点
func (list *doublyLinkedNode) show() {
	tempNode := list
	for {
		if tempNode == nil {
			break
		}
		fmt.Println("node:", tempNode)
		tempNode = tempNode.next

	}
}

//在指定节点后添加节点
func (list *doublyLinkedNode) insertNode(name string, newNode *doublyLinkedNode) {
	tempNode := list
	for {
		tempNode1 := tempNode.next

		if tempNode == nil {
			fmt.Println("no found :", name)
			break
		}
		if tempNode.name == name {

			newNode.next = tempNode1
			tempNode1.pre=newNode

			tempNode.next = newNode
			newNode.pre=tempNode
			fmt.Println("insert success")
			break
		}
	}
}

func main() {
	list := doublyLinkedNode{
		name:  "cabbage",
		age:   12,
		skill: "eat",
	}

	list.add(&doublyLinkedNode{
		name:  "radish",
		age:   12,
		skill: "eat",
	})
	list.show()
	list.insertNode("cabbage", &doublyLinkedNode{
		name:  "chives",
		age:   12,
		skill: "eat",
	})
	list.show()
}

结果：
在这里插入图片描述

3.5、循环链表
在这里插入图片描述
循环链表介绍
在这里插入图片描述
循环列表练习：

package main

import (
	"fmt"
)

/**
 *  @Description：循环列表
 *  @Author: guai
 *  @Date：2020/3/1 12:20
**/

//定义节点类型
type circleNode struct {
	name  string
	age   int
	skill string
	next  *circleNode
}

//在末尾添加节点
func (list *circleNode) add(newNode *circleNode) {
	defer func() {
		err := recover()
		if err != nil {
			fmt.Println("err:", err)
		}
	}()

	//中间节点
	tempNode := list
	for {
		if tempNode.next == list {
			break
		}
		tempNode = tempNode.next
	}
	newNode.next = list
	tempNode.next = newNode

}

//显示所有节点
func (list *circleNode) show() {
	tempNode := list
	for {
		fmt.Println("node:", tempNode, list)

		if tempNode.next == list {
			break
		}
		tempNode = tempNode.next
	}
}

//删除节点
func (list *circleNode) del(name string) {

	if list == nil {
		fmt.Println("list is empty")
		return
	}
	tempNode := list
	//当只有一个节点时
	if tempNode.next == list {
		if tempNode.name == name {
			tempNode = nil
			fmt.Println("del success")
			return
		}
	}
	//将endNode定位到链表最后
	endNode := list
	for {
		if endNode.next == list {
			break
		}
		endNode = endNode.next
	}
	fmt.Println("flagq")

	for {
		if tempNode.next == list {
			break
		}

		if tempNode.name == name {
			//删除的是头节点
			if tempNode == list {
				 *list = *list.next
			//	list.show()
				endNode.next=list
				fmt.Println("del success")
				return
			} else {
				  *endNode.next= *tempNode.next
				fmt.Println("del success1")
				return
			}
		}
		endNode = endNode.next
		tempNode = tempNode.next
	}

	fmt.Println("del fail case by name not found")
}

//在指定节点后添加节点
func (list *circleNode) insertNode(name string, newNode *circleNode) {
	tempNode := list
	if tempNode == nil {
		fmt.Println("no found :", name)
		return
	}
	for {
		tempNode1 := tempNode.next
		if tempNode.name == name {
			newNode.next = tempNode1
			tempNode.next = newNode
			fmt.Println("insert success")
			return
		}
		if tempNode.next == list {
			fmt.Println("no found ",name)
			return
		}
		tempNode=tempNode.next
	}
}

func main() {
	list := circleNode{
		name:  "cabbage",
		age:   12,
		skill: "eat",
	}
	list.next = &list

	list.add(&circleNode{
		name:  "radish",
		age:   12,
		skill: "eat",
	})
	//list.show()
	list.add(&circleNode{
		name:  "radish1",
		age:   12,
		skill: "eat",
	})

	list.show()
	list.insertNode("cabbage", &circleNode{
		name:  "chives",
		age:   12,
		skill: "eat",
	})
	list.show()

	//list.del("cabbage")
	//fmt.Println(list)
	//list.show()

	list.del("radish")
	fmt.Println(list)
	list.show()
}

结果：
在这里插入图片描述

任性的萝卜
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
golang经典编程题30题（带答案）golang基础算法30题
疯狂的鸭血
10-18 1万+
1.打印出九九乘法表并统计耗时 package main import ( "fmt" "time" ) func main() { start := time.Now() var i, j int for i = 1; i <= 9; i++ { for j = 1; j <= i; j++ { fmt.Printf("%d*%d=%d\t", i, j, i...
Golang精编100题-搞定golang面试
热门推荐
尹成的技术博客
05-26 10万+
Golang精编100题能力模型级别 模型 初级 primary 熟悉基本语法，能够看懂代码的意图；在他人指导下能够完成用户故事的开发，编写的代码符合CleanCode规范； 中级 intermediate 能够独立完成用户故事的开发和测试；能够嗅出代码的坏味道，并知道如何重构达成目标； 高级 senior 能够开发出高质量高性能的代码；能够熟练使用高级特性，开发编程框架或测试框...
Leetcode面试算法题（Golang版）
07-10
用来记录我们刷LeetCode题目时候的心酸历史。我们保证，这些代码一定通过了当时LeetCode的测试，虽然后续可能因为LeetCode测试条件的改变导致某些解题无法通过，但我们会实时的跟进。 编程语言使用Golang，代码风格上面并没有强制的采用什么编码规范，毕竟是算法解题，只需要代码清晰易懂就可以了。 鉴于个人精力时间有限，可能并不会完全最优解，请多多见谅。
golang常见算法题
weixin_38385580的博客
01-11 672
1、 翻转一个字符串 2、 字符串对位交换 3、 返回一个数组所有可能排列 4、 交替打印字母数字
Go最全2024最新-精选基础算法100题（面试必备）_算法题(1)，【绝对干货】
最新发布
2401_84911309的博客
05-12 903
容器类的算法题一般需要根据一些容器的特点来解决响应的问题，还有需要选择合适的容器进行新的数据结构的设计，掌握它们的使用，非常重要。树也是一种非常重要的数据结构，因为很多容器的底层都设计到树，所以树也成了面试常问的重点了，你需要对他们的一些基本算法题，非常熟练。数学思维类的题由于需要很强大的数学思维，但是这又不是一天可以练成的，所以，也常常在面试中会被问到，只有慢慢的积累，才是王道。数组类的算法题也是，说难不难，说简单不简单，而且数组是平时编码用的最多的结构了，所以，需要对它的一些基本算法引起重视。
500道Golang 常⻅⾯试题⽬解析
技术Q君样：202432010的博客
07-28 1058
文章目录1.交替打印数字和字⺟2.判断字符串中字符是否全都不同3.翻转字符串4.判断两个给定的字符串排序后是否⼀致5.字符串替换问题6.机器⼈坐标问题常⻅语法题 一1、下⾯代码能运⾏吗？为什么。2、请说出下⾯代码存在什么问题。3、写出打印的结果。4、下⾯的代码是有问题的，请说明原因。5、请找出下⾯代码的问题所在。6、请说明下⾯代码书写是否正确。7、下⾯的程序运⾏后为什么会爆异常。8、请说出下⾯代码哪⾥写错了9、请说出下⾯代码，执⾏时为什么会报错10、请说出下⾯的代码存在什么问题？11、下⾯这段代码为什么会卡
golang实现算法题合集一
weixin_42278305的博客
12-08 526
1. 找到一个数组中第二大的数 思路： 定义一个最大值和第二大值变量，遍历一次数组。需要注意的是最大值可能有多个。 func getMax(arr []int) int { // 初始化 maxNum := arr[0] secondMaxNum := arr[1] if maxNum < secondMaxNum { maxNum, secondMaxNum = secondMaxNum, maxNum } for i := 0; i < len(arr); i++ { i
Golang排列组合算法问题之全排列实现方法
09-21
下面我们将深入探讨如何使用Golang实现全排列算法。 首先，我们定义了一个名为`outOrder`的函数，该函数接收一个字符串切片`trainsNums`作为参数，这个切片包含了待排列的数字。函数首先检查输入的长度是否在1到9...
GoLang中实现的算法-Golang开发
05-26
算法-Go中使用的Go算法（用于教育）这些算法仅用于演示目的。 Go标准库中有许多排序实现可能具有更好的性能。 F算法-Go中使用的Go算法（用于教育）这些算法仅用于演示目的。 Go标准库中有许多排序实现可能具有更好的...
Golang算法之田忌赛马问题实现方法分析
09-21
主要介绍了Golang算法之田忌赛马问题实现方法,结合具体实例形式分析了基于Go语言的田忌赛马问题原理与算法实现技巧,需要的朋友可以参考下
golang实现分页算法实例代码
09-20
在本文中，我们将深入探讨如何在Golang中实现分页算法。分页是网页或应用程序中常见的功能，它允许用户按页浏览大量的数据，而无需一次性加载所有内容，从而提高用户体验。Golang作为一门强大的静态类型语言，非常...
golang精选100题带答案
weixin_33805743的博客
04-28 2010
能力模型 级别模型 初级 primary 熟悉基本语法，能够看懂代码的意图； 在他人指导下能够完成用户故事的开发，编写的代码符合CleanCode规范； 中级 intermediate 能够独立完成用户故事的开发和测试； 能够嗅出代码的坏味道，并知道如何重构达成目标； 高级 senior 能够开发出高质量高性能的代码；...
golang几道算法面试题
qq_39272466的博客
06-29 291
【代码】golang几道算法面试题。
go算法题
zhaoliang831214的专栏
12-27 863
=================================================== //**冒泡排序 func BubbleSort(arr *[5]int){ n :=len(*arr) temp := 0 for i := 0; i < n-1; i++ { for j :=i+1; j < n; j++ { ...
达梦初学习（安装）
weixin_43655261的博客
09-18 237
达梦，国内知名的关系型数据库厂商，以其自主原创的内核、完善的体系而享誉业界。 近日来，因为工作涉及，开始对达梦数据库进行学习。此文起，便是记录我学习过程的点滴记录，先从软件的初接触和安装开始。 一、收集软件、硬件信息（本文已中标麒麟操作系统环境为例） 查看软件：系统发行版本、内核版本、位数、安装包，要与DM版本对应 发行版本：cat /etc/issue 内核版本：uname -r...
【2024届秋招】Golang后端面试场景题面经
qq_56924476的博客
10-17 1093
Golang后端面试场景题、智力题，面经
Golang算法题目小计
gotaotao的博客
09-24 1251
1 请符合两数之和的索引 给定一个整数数组和一个目标值，找出数组中和为目标值的两个数。 你可以假设每个输入只对应一种答案，且同样的元素不能被重复利用。 示例: 给定 nums = [2, 7, 11, 15], target = 9 因为 nums[0] + nums[1] = 2 + 7 = 9 所以返回 [0, 1] 第一种实现：暴力破解法 func twoSum(nums []int, ta...
算法题-golang实现第一章
ac123321123321的博客
01-25 239
算法题-golang实现第一章1.无重复字符的最长子串2.最长公共前缀3.字符串的排列4.字符串相乘5.翻转字符串里的单词6.简化Linux路径7.复原IP地址 第一章 题目来源于Leetcode题库 1.无重复字符的最长子串 给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。 示例 1: 输入: “abcabcbb” 输出: 3 解释: 因为无重复字符的最长子串是 “abc”，所以其长度为 3。 示例 2: 输入: “bbbbb” 输出: 1 解释: 因为无重复字符的最长子串是 “b”，所以
leetcode：算法题golang
qq_33690342的博客
11-29 793
1、在一个字符串里面找出最长的不重复子串 2、数组中的重复数字 第一种解法：先排序再扫描。从排好序的数组进行遍历，记录当前位置与其之前位置的数进行比较，若相等则输出该数。 时间复杂度：O（nlogn）;空间复杂度O（1） 第二种解法：对数组进行遍历，每次判断哈希表中是否含有该元素，若有，输出此元素。若最后哈希表中的元素数量与数组中的相同，表面无重复数据。 时间复杂度：O（n）;空间复杂度O（n） 3、给定一个数组代表股票每天的价格，请问买卖多次的情况下，最大化利润是多少？（日期不重...
使用golang实现冒泡排序算法
05-14
好的，下面是使用golang实现冒泡排序算法的代码： ```go package main import "fmt" func bubbleSort(arr []int) { n := len(arr) for i := 0; i < n-1; i++ { for j := 0; j < n-i-1; j++ { if arr[j] > arr[j+1] { arr[j], arr[j+1] = arr[j+1], arr[j] } } } } func main() { arr := []int{64, 34, 25, 12, 22, 11, 90} bubbleSort(arr) fmt.Println("排序后的数组:", arr) } ``` 这个程序定义了一个 `bubbleSort` 函数来执行冒泡排序算法，然后在 `main` 函数中使用它来对一个数组进行排序。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值