笔记：运算符，java基础排序算法

最新推荐文章于 2021-02-16 22:25:53 发布

Lz先生

最新推荐文章于 2021-02-16 22:25:53 发布

阅读量149

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/qq_42583216/article/details/108630744

版权

java 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

21.逻辑运算符(且或非)

逻辑运算符操作的都是boolean类型
&–逻辑与：都true为true
&&–短路与：
|–逻辑或：有true为true
||–短路或：
！–逻辑非：第一个true为false，第一个false为true
^–逻辑异或：俩个相同为false，不同为true
开发中用短路

22.位运算符

位运算符操作的是数值，整数
“<<” 左移：3<<2=12，3左移2位，二进制左移两位，末尾用0补齐，相当于×2的2次方。移几位×2的几次方。
“>>” 右移：3>>1=1，3右移1位，二进制右移两位，开头用0补齐，相当于除2的2次方。移几位除2的几次方。负数用1补齐。
“>>>” 无符号右移：3>>>1=1，3/2=1，不管是正数还是负数，都用0补齐，负数直接变正数
“&” 与：6&3=2，二进制；0为false，1为true。同1为1
“|” 或：6|3=7，有1则1.
^ 异或：6^3=5，相同为false，不同为true
~ 取反：~6=-7，1为0，0为1

23.三元运算符

(条件表达式)？表达式1：表达式2
true执行1，false执行2

24.带标签的for

	apple:for (int i = 0; i < 10; i++) {
            System.out.println(i);
            for (int j = 0; j < 10; j++) {
                if (j==3) {
                    break apple;
                }
                System.out.println(j);
            }
        }

没有apple标签，break结束内循环：输出为0012，1012，2012，3012，…
带有apple标签，break结束标签指定的循环：输出为0012；

26.内存

栈；局部变量
堆；new出来的对象，数组
方法区；静态域，常量池

27.内存解析(不准确)

new出来arr在堆里面的地址，给栈里面的名arr；
arr = new对象，堆里面新建一个对象，把地址给栈里面已经存在的的arr；
二维数组，

28.数组操作算法

数组复制；

   String[] arr = new String[]{"aa","bb","cc","dd","ee"};
	String[] arr1 = new String[arr.length];
	for (int i = 0; i < arr1.length; i++) {
    arr1[i] = arr[i];
}

数组的复制区别于数组变量的赋值；arr2=arr；
挨个元素的复制，指向元素的地址；
数组的反转

   for (int i = 0; i < arr.length / 2; i++) {		
       	    String tempString = arr[i];
       	    arr[i] = arr[arr.length - i -1];
       	    arr[arr.length - i -1] = tempString;
       	}

顺序颠倒
1. 容量，内存只需要开辟一个空间tempString。

29.查找

线性查找
1. 从前往后按顺序查找；
二分查找
1. 前提：有序；

int[] arr = new int[] {-99,-85,-4,0,1,59,87,159};
 		
 		//二分查找
 		int find = -99;//要找的数据
 		
 		int head = 0;//头尾
 		int end =arr.length-1;
 		boolean findFlag = true;
 		
 		while (head <= end) {		
 			int middle = (head+end)/2;
 			if (find == arr[middle]) {
 				System.out.println("要找的数据索引是："+middle);
 				findFlag=false;
 				break;//找到终止循环
 			}else if (find < arr[middle]) {
 				end = middle-1;
 			}else {
 				head = middle+1;
 			}			
 		}
 		
 		if (findFlag) {
 			System.out.println("没找到你要找的数据");
 		}

30.排序

衡量排序算法的优劣
1. 时间复杂度；关键字的比较次数和记录的移动次数；
2. 空间复杂度；算法中需要多少辅助内存；
3. 稳定性；记录A和B的关键值相等，排序后A，B的次序保持不变，则算法是稳定的。
十大排序算法
1. 选择排序
  1. 直接选择排序，堆排序
2. 交换排序
  1. 冒泡排序
  2. 快速排序
3. 插入排序
  1. 直接插入排序
  2. 折半插入排序
  3. Shell排序
4. 归并排序
5. 桶式排序
6. 基数排序
算法五大特征
- 输入
- 输出
- 有穷性
- 确定性
- 可行性

重要排序算法

冒泡排序(手写)

int[] arr = new int[] {49,38,65,9,79,16,27,49};
     			
     	for (int i = 0; i < arr.length; i++) {
     		for (int j = 0; j < arr.length - i - 1; j++) {
     			if (arr[j]>arr[j+1]) {
     				int temp = arr[j];
     				arr[j] = arr[j+1];
     				arr[j+1] = temp;
     			}
     		}
     	}
     	
     	for (int i = 0; i < arr.length; i++) {
     		System.out.print(arr[i] + " ");
     	}

快速排序(手写)

public static void main(String[] args) {
     		int[] arr = { 49, 38, 65, 97, 23, 22, 76, 1, 5, 8, 2, 0, -1, 22 };
     		
     		quickSort(arr, 0, arr.length - 1);
     		
     		System.out.println("排序后:");
     		for (int i : arr) {
     			System.out.print(i + " ");
     		}
     	}
     
     	private static void quickSort(int[] arr, int low, int high) {
     
     		if (low < high) {
     			// 找寻中间基准
     			int index = getIndex(arr, low, high);
     			//迭代基准之前和之后的数组，进行相同的操作使整个数组变成有序
     			quickSort(arr, low, index - 1);
     			quickSort(arr, index + 1, high);
     		}
     
     	}
     
     	private static int getIndex(int[] arr, int low, int high) {
     		// 基准数据
     		int tmp = arr[low];
     		while (low < high) {
     			// 当队尾的元素大于等于基准数据时,向前挪动high指针
     			while (low < high && arr[high] >= tmp) {
     				high--;
     			}
     			// 如果队尾元素小于tmp了,需要将其赋值给low
     			arr[low] = arr[high];
     			// 当队首元素小于等于tmp时,向前挪动low指针
     			while (low < high && arr[low] <= tmp) {
     				low++;
     			}
     			// 当队首元素大于tmp时,需要将其赋值给high
     			arr[high] = arr[low];
     
     		}
     		// 跳出循环时low和high相等,此时的low或high就是tmp的正确索引位置
     		// 由原理部分可以很清楚的知道low位置的值并不是tmp,所以需要将tmp赋值给arr[low]
     		arr[low] = tmp;
     		return low; // 返回tmp的正确位置
     	}

堆排序(熟悉)
- 堆是一种数据结构，一种叫做完全二叉树的数据结构。
- 大顶堆：每个节点的值都大于或者等于它的左右子节点的值。
- 对于大顶堆：arr[i] >= arr[2i + 1] && arr[i] >= arr[2i + 2]
- 小顶堆：每个节点的值都小于或者等于它的左右子节点的值。
- 对于小顶堆：arr[i] <= arr[2i + 1] && arr[i] <= arr[2i + 2]
- 堆排序的基本思想是：
  - 1、将带排序的序列构造成一个大顶堆，根据大顶堆的性质，当前堆的根节点（堆顶）就是序列中最大的元素；
  - 2、将堆顶元素和最后一个元素交换，然后将剩下的节点重新构造成一个大顶堆；
  - 3、重复步骤2，如此反复，从第一次构建大顶堆开始，每一次构建，我们都能获得一个序列的最大值，然后把它放到大顶堆的尾部。最后，就得到一个有序的序列了
归并排序(熟悉)
- 第一步：申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
- 第二步：设定两个指针，最初位置分别为两个已经排序序列的起始位置
- 第三步：比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
- 重复步骤3直到某一指针超出序列尾
- 将另一序列剩下的所有元素直接复制到合并序列尾