数据结构-数组与链表
数组特点：
1. 线性表，数据排成像线一样的数据结构，数据只有前后俩个方向，数组，链表，队列，栈都是线性表
2. 连续的内存空间，让它支持随机访问，根据下标随机访问的时间复杂度为o（1）,随机访问的公式
3. 相同类型的数据结构
4. 随机访问公式，a[i]_address = base_address + i * data_type_size，其中data_type_size为数据类型大小，eg:int四字节
数组删除和插入效率低的原因
1. 插入或者删除；都会导致后续的数据大规模移动
2. 如果进行优化 1. 比如删除的时候，将要删除的数据和最后一位调换位置，在删除；
2. 或者类似jvm的标记删除发，先标记，等数组空间不够了，在真正删除，
3. 以上都是减少了大规模数据移动问题
数组越界问题
1. 并非所有的语言都会对数组越界进行检查，比如c，即使越界，但只要偏移计算后的内存可访问，那么程序就不会报错，所以病毒就可以利用这点进行非法访问
数组与容器
1. 拿Java来说 int[] 对应的容器是 arraylist,由于 arraylist 无法存储基础类型 ，所以需要int转化成Integer ,这个转化的就是装箱和拆箱，有一定的性能消耗
2. arraylist，可以自动扩容，封装了很多方法，隐藏了操作细节，使用也更方便
3. 如果仅仅是业务开发，容器就很好，那点性能消耗相较于系统整体性能无上大雅
4. 但是如果是底层，就需要用数组，毕竟这种性能，能扣一点是一点
5. 另外，如果刷算法题，建议用数组，这样可以更直观感受数组的变化，操作的细节。
数组为什么下标从0开始
1. 下标，也可以叫偏移，a[]中，a是首地址，a[0]代表偏移为0个size的地址
链表的定义：
1. 不同于数组，链表需要的可以不是连续的内存空间，只要总大小够即可
2. 链表中每一个节点之间是通过指针链接
3. 链表分为 单向链表，双向链表，双向链表
4. 说一种简单的链表结构，如单向链表，
```
-> data,next ->....;
```
5. 链表的插入和删除只需要更改一个节点
数组和链表的对比
1. 内存大小，链表每个节点需要额外的空间存储指向下一个节点的指针，多以同等数据规模下，数组内存消耗小
2. 插入和删除的性能， 数组 o(n),链表o(1)
3. 随机访问， 数组 o(1),链表o(n)
4. 内存的申请上，数组需要连续的空间，链表可以是零散的空间
5. 内存碎片，链表频繁申请释放内存，会导致内存碎片，容易频繁出发gc
leetcode上数组经典题目
//给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复
//的三元组。
//
// 注意：答案中不可以包含重复的三元组。
//
//
//
// 示例：
//
// 给定数组 nums = [-1, 0, 1, 2, -1, -4]，
//
//满足要求的三元组集合为：
//[
// [-1, 0, 1],
// [-1, -1, 2]
//]
//
// Related Topics 数组 双指针
package leetcode.editor.cn;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
//Java：三数之和
public class P15ThreeSum {
public static void main(String[] args) {
Solution solution = new P15ThreeSum().new Solution();
// TO TEST
int[] nums = {-1, 0, 1, 2, -1, -4};
List<List<Integer>> res = solution.threeSum(nums);
res.forEach(n -> {
n.forEach(m -> {
System.out.print(m + " ");
});
});
}
//leetcode submit region begin(Prohibit modification and deletion)
class Solution {
public List<List<Integer>> threeSum(int[] nums) {
if (nums == null || nums.length == 0) {
return new ArrayList<>();
}
Arrays.sort(nums);
List<List<Integer>> res = new ArrayList<>();
for (int i = 0; i < nums.length; i++) {
if (i == 0 || (i > 0 && nums[i] != nums[i - 1])) {
int l = i + 1;
int r = nums.length - 1;
while (l < r) {
int temp = nums[i] + nums[l] + nums[r];
if (temp == 0) {
res.add(Arrays.asList(nums[i], nums[l], nums[r]));
while (l < r && nums[l] == nums[l + 1]) l++;
while (l < r && nums[r] == nums[r - 1]) r--;
l++;
r--;
} else if (temp < 0) {
while(l<r && nums[l] == nums[l+1]) l++;
l++;
} else {
while(l<r && nums[r] == nums[r-1]) r--;
r--;
}
}
}
}
return res;
}
}
//leetcode submit region end(Prohibit modification and deletion)
}
leetcode链表经典题目
//合并 k 个排序链表，返回合并后的排序链表。请分析和描述算法的复杂度。
//
// 示例:
//
// 输入:
//[
// 1->4->5,
// 1->3->4,
// 2->6
//]
//输出: 1->1->2->3->4->4->5->6
// Related Topics 堆 链表 分治算法
package leetcode.editor.cn;
import com.example.demo.ListNode;
//Java：合并K个排序链表
public class P23MergeKSortedLists{
public static void main(String[] args) {
Solution solution = new P23MergeKSortedLists().new Solution();
// TO TEST
}
//leetcode submit region begin(Prohibit modification and deletion)
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
class Solution {
public ListNode mergeKLists(ListNode[] lists) {
ListNode res = null;
for (int i = 0; i < lists.length; i++) {
res = merge(res,lists[i]);
}
return res;
}
//依次合并链表
private ListNode merge(ListNode l1, ListNode l2){
if(l1==null){
return l2;
}
if(l2==null){
return l1;
}
if(l1.val<l2.val){
l1.next = merge(l1.next,l2);
return l1;
}else{
l2.next =merge(l1,l2.next);
return l2;
}
}
}
//leetcode submit region end(Prohibit modification and deletion)
}
链表还有一个经典的例子 LRU
package com.example.demo;
/**
* 有序单链表实现lru
* 思路：1.如果此数据之前已经被缓存在链表中了，我们遍历得到这个数据对应的结点，并将其从原来的位置删除，然后再插入到链表的头部。
* 2.如果此数据没有在缓存链表中，又可以分为两种情况：
* 如果此时缓存未满，则将此结点直接插入到链表的头部；
* 如果此时缓存已满，则链表尾结点删除，将新的数据结点插入链表的头部。
*/
public class Lc_LRU {
public static class LinkList {
int node;
LinkList next;
public LinkList() {
}
public LinkList(int node, LinkList next) {
this.node = node;
this.next = next;
}
public LinkList(int node) {
this.node = node;
}
public int getNode() {
return node;
}
public void setNode(int node) {
this.node = node;
}
public LinkList getNext() {
return next;
}
public void setNext(LinkList next) {
this.next = next;
}
}
//链表最大长度
int size = 10;
//遍历链表
private boolean traversal(LinkList newNode, LinkList linkList) {
LinkList curr = linkList;
while (curr != null) {
if (curr.node != newNode.node) {
curr = curr.next;
} else {
return true;
}
}
return false;
}
//遍历链表是否存在新插入的值,存在则删除
private LinkList delete(LinkList head, LinkList toRemove) {
if(head.node == toRemove.node){
return head.next;
}
LinkList pre = head;
LinkList curr = head;
while(curr!=null){
if(curr.node == toRemove.node){
pre.next = curr.next;
return pre;
}else{
pre = curr;
}
curr = curr.next;
}
return null;
}
//删除最后一个节点
private void deleteLastNode(LinkList linkList) {
LinkList curr = linkList;
int position = 0;
while (curr != null && position != 8) {
position++;
curr = curr.next;
}
curr.next = null;
}
//遍历链表长度
private int count(LinkList linkList) {
LinkList curr = linkList;
int count = 0;
while (curr != null) {
count++;
curr = curr.next;
}
return count;
}
//插入新节点，检查是否存在该节点，若存在删除原来位置的节点，插入到头,如果不存在，直接插入到头
private LinkList insert(LinkList newNode, LinkList linkList) {
if (count(linkList) < 10) {
//go on
} else {
deleteLastNode(linkList);
}
linkList = delete(linkList,newNode);
LinkList head = newNode;
head.next = linkList;
return head;
}
private void sysoLinkList(LinkList linkList) {
StringBuffer stringBuffer = new StringBuffer();
LinkList curr = linkList;
while (curr != null) {
stringBuffer.append(curr.node);
curr = curr.next;
}
System.out.println(stringBuffer.toString());
}
public static void main(String[] args) {
LinkList linkList = new LinkList(2);
LinkList newNode = new LinkList(1);
linkList.next = newNode;
LinkList newNode1 = new LinkList(1);
Lc_LRU lc_lru = new Lc_LRU();
linkList = lc_lru.insert(newNode1, linkList);
lc_lru.sysoLinkList(linkList);
}
}
不恋尘世浮华，不写红尘纷扰
