第一章基础知识（运算符进制转换排序和查找）-CSDN博客

本文链接：https://blog.csdn.net/qq_41110793/article/details/136024612

内容简写有的是之前写的C语言笔记摘抄的

一、运算符

        1) 算术运算符
        2) 赋值运算符
        3) 比较运算符/关系运算符
        4) 逻辑运算符
        5) 位运算符
        6) 其它运算符

1.1 算术运算符

1.2 关系运算符(比较运算符)

1.3逻辑运算符

1.4 赋值运算符

① 运算顺序从右往左

② 赋值运算符的左边只能是变量,右边可以是变量、表达式、常量值

1.5 位运算符

>>、<< 右移和左移,运算规则:
                右移运算符>>：低位溢出,符号位不变,并用符号位补溢出的高位
                左移运算符<<:
                符号位不变,低位补 0

案例演示
a := 1 >> 2 // 0000 0001 =>0000 0000 = 0

c := 1 << 2 // 0000 0001 ==> 0000 0100 = 4

1.6 其他运算符

1.7 运算符优先级

一个大概的优先级
1：括号，++, --
2: 单目运算
3：算术运算符
4：移位运算
5：关系运算符
6：位运算符
7：逻辑运算符
8：赋值运算符
9：逗号

二、进制

1KB=1024字节 1M=1024KB 1G=1024M

十进制0-9 八进制0-7 十六进制0-9 a-f

2.1 进制转换

十进制转其他进制:

十进制转换为任意进制，方法都大同小异，本质都是采用求余法

其他进制转十进制:

基数（数值）乘以指数（进制数）的n次方法。从右往左，n从0开始。依次相加。

二进制转其他进制：

二进制转八进制，三合一法，每三位二进制数合成一位八进制数

二进制转十六进制，四合一法，每四位二进制数合成一位十六进制

八进制转其他进制：

八进制转换为二进制，一分三法，每一位八进制分成三位二进制

八进制转换为十六进制：

①先转化为二进制，再转换为十六进制

②先转化为十进制，再转换为十六进制

十六进制转其他进制：

十六进制转换为二进制，一分四法，每一位十六进制分成四位二进制

十六进制转换为八进制：

①先转换为二进制，再转换为八进制（简单做法）

②先转换为十进制，再转换为八进制

2.2 原码、反码、补码

三、排序和查找

3.1 排序介绍

3.2 冒泡排序

1、一共经过 arr.length-1次的轮数比较，每一轮将会确定一个数的位置
2、每一轮的比较次数在逐渐减少
3、当发现前面的一个数比后面的一个数大的时候，就进行了交换

package main
import "fmt"
//冒泡排序
func BubbleSort(arr *[5] int) {
	//交换
	fmt.Println("排序前arr=", *arr)
		temp := 0
		for j:=0; j < len(arr)-1; j++ {
			for i := 0; i < len(arr)-1-j; i++ {
				if arr[i] > arr[i + 1] {
					//交换
					temp = arr[i + 1]
					arr[i + 1] =arr[i]
					arr[i] = temp
				}
			}
		}
}

func main() {
	arr :=[5] int {24, 69, 80, 57, 13}
	BubbleSort(&arr)
	fmt.Println("排序后arr=", arr)
}

3.3 查找

在 Golang 中，我们常用的查找有两种:
1) 顺序查找
2) 二分查找(该数组是有序)

3.4 二分查找

二分查找的思路: 比如我们要查找的数是 findVal
        1. arr 是一个有序数组，并且是从小到大排序
        2.先找到中间的下标 middle = (leftIndex + rightIndex) / 2, 然后让中间下标的值和 findVal 进行比较
                2.1 如果 arr[middle] > findVal ,就应该向leftIndex ---- (middle - 1)
                2.2 如果 arr[middle] < findVal ,就应该向middel+1---- rightIndex
            2.3 如果 arr[middle] == findVal ，就找到
                2.4 上面的 2.1 2.2 2.3 的逻辑会递归执行

        3. 想一下，怎么样的情况下，就说明找不到
        if leftIndex > rightIndex {
        // 找不到..
        return ..
        }

package main

import "fmt"
//二分查找的函数
func BinaryFind (arr *[6]int, leftIndex int, rightIndex int, findVal int ) {
	//判断 leftIndex 是否大于 rightIndex
	if leftIndex > rightIndex {
		println("找不到")
		return
	}
	//先找到 中间的下标
	middle :=(leftIndex + rightIndex)/2

	if (arr[middle]) > findVal {
		BinaryFind(arr, leftIndex, middle-1 , findVal )
	} else if (arr[middle]) < findVal {
		BinaryFind(arr, middle + 1, rightIndex , findVal )
	} else {
		fmt.Println("找到了，下标为", middle)
	}
}
func main() {
	arr := [6] int {1, 8, 10, 89, 1000, 1234}
	BinaryFind(&arr, 0, len(arr) - 1, 1234)
}

四、面向对象编程

① Golang 仍然有面向对象编程的继承，封装和多态的特性
② Golang 面向对象(OOP)很优雅，OOP 本身就是语言类型系统(type system)的一部分，通过接口(interface)关联，耦合性低，也非常灵活。后面同学们会充分体会到这个特点。也就是说在 Golang 中面向接口编程是非常重要的特性。

4.1 面向对象编程三大特性

4.1.1 封装

1) 对结构体中的属性进行封装
2) 通过方法，包实现封装

4.1.2 继承

1) 继承可以解决代码复用,让我们的编程更加靠近人类思维。
2) 当多个结构体存在相同的属性(字段)和方法时,可以从这些结构体中抽象出结构体(比如刚才的Student),在该结构体中定义这些相同的属性和方法。
3) 其它的结构体不需要重新定义这些属性(字段)和方法，只需嵌套一个 Student 匿名结构体即可。