class Solution {
    public String minNumber(int[] nums) {
        PriorityQueue<String> queue = new PriorityQueue<>(new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return (s1 + s2).compareTo(s2 + s1);
            }
        });

        for (int i:nums) {
            queue.offer("" + i);
        }

        StringBuilder result = new StringBuilder();
//注意在取出元素时，不能直接遍历，而是要在取出的同时，让这个堆继续保持正确的字典序
        while(!queue.isEmpty()){
            result.append(queue.poll());
        }
        return result.toString();

    }
}

public static String minNumber(int[] nums){
    String[] strs = new String[nums.length];
    for (int i = 0; i < nums.length; i++) {
        strs[i] = nums[i]+"";
    }
    Arrays.sort(strs, (x,y)->(x + y).compareTo(y + x));
    StringBuilder result = new StringBuilder();
    for (String s: strs) {
        result.append(s);
    }
    return result.toString();
}

int majorityElement(int[] nums){
    //如果数组长度为0，返回-1
    if(nums.length()<=0){
        return -1;
    }
    //维护两个变量majority和count
    int majority = 0;
    int count = 0;
    //循环遍历所有元素
    for(int i = 0; i<nums.length; i++){
        if(count == 0){
            majority = nums[i];
            count++;
        }else{
            if(nums[i] == majority){
                count++;
            }else{
                cout--;
            }
        }
    }
    
    //此时已经获得了众数majority
    //接下来判断是否满足关键元素
    if(count == 0){
        return -1;
    }
    int identify = 0;
    for(int i = 0; i<nums.length; i++){
        if(nums[i] == majority){
            identify++;
        }
        if(identify>nums.length/2){
            return majority;
        }
    }
}

int result = 0;
for(int i = 0; i < nums.length; i++){
    result ^= nums[i];
}
return result;

//暴力解法
    public static int threeSumClosest(int[] nums, int target) {
        int sub = Integer.MAX_VALUE;
        int sum = 0;
        for(int i = 0; i<nums.length; i++){
            for(int j = i+1; j<nums.length; j++){
                for(int k = j+1; k<nums.length; k++){
                    int newSub = Math.abs(nums[i]+nums[j]+nums[k]-target);
                    if (newSub<sub){
                        sub = newSub;
                        sum = nums[i]+nums[j]+nums[k];
                    }
                }
            }
        }
        return sum;
    }

    //双指针法
    public static int threeSumClosest2(int[] nums, int target) {
        int best = 10000000;
        Arrays.sort(nums);
        for(int i = 0; i<nums.length; i++){
            int pb = i+1;
            int pc = nums.length-1;
            while(pb<pc){
                int sum = nums[i] + nums[pb] + nums[pc];
                if(sum == target){
                    return target;
                }
                if(Math.abs(best-target)>Math.abs(sum-target)){
                    best = sum;
                }
                if(sum < target){
                    pb++;
                    //如果当前位置和上一个位置相同，则继续前往下一个位置，直到当前位置的数和之前不同，
                    //所以需要判断的是当前位置和之前位置的数是否相同，
                    //如果判断条件是：nums[pb+1] == nums[pb]；则当前位置的数会被跳过，可能会导致指针pb和pc不能指向数值想同的不同位置
                    //比如下面的例子：{-1，0，1，1，55}；无法使得pb指向第一个1，pc指向第二个1
                    while(pb<pc && nums[pb] == nums[pb-1]){
                        pb++;
                    }
                }

                if(sum > target){
                    pc--;
                    while(pb<pc && nums[pc+1] == nums[pc]){
                        pc--;
                    }
                }
            }
        }
        return best;

    }


    public static void main(String[] args) {
        int[] nums = new int[]{-1,0,1,1,55};
        System.out.println(threeSumClosest2(nums, 3));
    }

class Solution {
    public int sumOddLengthSubarrays(int[] arr) {
        int maxOdd = arr.length%2 == 0 ? arr.length-1 : arr.length;
        int result = 0;
        while(maxOdd>0){
            int leftBound = 0; 
            int rightBound = leftBound+maxOdd-1;
            while(rightBound<arr.length){
                result += sum(arr, leftBound, rightBound);
                leftBound++;
                rightBound = leftBound+maxOdd-1;
            }
            maxOdd -= 2;
        }
        return result;
    }

    public int sum(int[] nums, int leftBound, int rightBound){
        int sum = 0;
        for(int i = leftBound; i<=rightBound; i++){
            sum += nums[i];
        }
        return sum;
    }
}

leftOdd * rightOdd + leftEven * rightEven

class Solution {
    public int sumOddLengthSubarrays(int[] arr) {
        int result = 0;
        for(int i = 0; i<arr.length; i++){
            int leftOdd = (i+1)/2;
            int leftEven = (i/2)+1;
            int rightOdd = (arr.length-i)/2;
            int rightEven = (arr.length-1-i)/2+1;
            result += arr[i]*(leftOdd*rightOdd+leftEven*rightEven);
        }
        return result;
    }
}

给定一个二进制矩阵 A，我们想先水平翻转图像，然后反转图像并返回结果。

水平翻转图片就是将图片的每一行都进行翻转，即逆序。例如，水平翻转 [1, 1, 0] 的结果是 [0, 1, 1]。

反转图片的意思是图片中的 0 全部被 1 替换， 1 全部被 0 替换。例如，反转 [0, 1, 1] 的结果是 [1, 0, 0]。

示例 1:

输入: [[1,1,0],[1,0,1],[0,0,0]]
输出: [[1,0,0],[0,1,0],[1,1,1]]
解释: 首先翻转每一行: [[0,1,1],[1,0,1],[0,0,0]]；
     然后反转图片: [[1,0,0],[0,1,0],[1,1,1]]
示例 2:

输入: [[1,1,0,0],[1,0,0,1],[0,1,1,1],[1,0,1,0]]
输出: [[1,1,0,0],[0,1,1,0],[0,0,0,1],[1,0,1,0]]
解释: 首先翻转每一行: [[0,0,1,1],[1,0,0,1],[1,1,1,0],[0,1,0,1]]；
然后反转图片: [[1,1,0,0],[0,1,1,0],[0,0,0,1],[1,0,1,0]]

class Solution {
    public int[][] flipAndInvertImage(int[][] A) {
        int m = A.length;
        int n = A[0].length;
        for(int i = 0; i<m; i++){
            for(int j = 0; j<(n+1)/2; j++){ //注意这里，当列数为奇数的时候，中间的一位也需要和1异或，所以交换次数要+1
                swap(A[i], j, n-1-j);
            }
        }
        return A;

    }

    public void swap(int[] nums, int i, int j){
        int temp = nums[i]^1; //这里通过和1异或可以改变当前数的值
        nums[i] = nums[j]^1;
        nums[j] = temp;
    }
}

给你一份『词汇表』（字符串数组） words 和一张『字母表』（字符串） chars。

假如你可以用 chars 中的『字母』（字符）拼写出 words 中的某个『单词』（字符串），那么我们就认为你掌握了这个单词。

注意：每次拼写（指拼写词汇表中的一个单词）时，chars 中的每个字母都只能用一次。

返回词汇表 words 中你掌握的所有单词的 长度之和。

示例 1：

输入：words = ["cat","bt","hat","tree"], chars = "atach"
输出：6
解释： 
可以形成字符串 "cat" 和 "hat"，所以答案是 3 + 3 = 6。
示例 2：

输入：words = ["hello","world","leetcode"], chars = "welldonehoneyr"
输出：10
解释：
可以形成字符串 "hello" 和 "world"，所以答案是 5 + 5 = 10。

public int countCharacters(String[] words, String chars) {
        int[] cArr = new int[26];
        for (char c:chars.toCharArray()
             ) {
            cArr[c-'a']++;
        }
        int result = 0;
        for (String word:words
             ) {
            int[] wArr = new int[26];
            for (char w:word.toCharArray()
                 ) {
                wArr[w-'a']++;
            }
            boolean can = true;
            for (int i = 0; i < 26; i++) {
                if (wArr[i]>cArr[i]){
                    can = false;
                    break;
                }
            }
            if (can) {
                result += word.length();
            }
        }
        return result;
    }

public static int lengthOfLongestSubstring(String s) {//用map优化去重
       if(s.length() == 0){
           return 0;
       }
       int maxSize = 0;
       HashMap<Character, Integer> map = new HashMap<>();
       int l = 0;
       int r = 0;
       while(l<=r && r<s.length()){
           if(map.containsKey(s.charAt(r))){
               l = Math.max(l, map.get(s.charAt(r))+1);
           }
           map.put(s.charAt(r), r++);
           maxSize = Math.max(maxSize, (r-l));
       }
       return maxSize;
   }

   public static int lengthOfLongestSubstring2(String s){//用set去重
       int maxSize = 0;
       HashSet<Character> set = new HashSet<>();
       int l = 0;
       int r = 0;
       while(l<=r && r<s.length()){
           while(r<s.length() && (!set.contains(s.charAt(r)))){
               set.add(s.charAt(r++));
           }
           maxSize = Math.max(maxSize, r-l);
           if(r == s.length()-1){
               return maxSize;
           }
           set.remove(s.charAt(l));
           l++;
       }
       return maxSize;
   }

public int[] maxSlidingWindow(int[] nums, int k) {
       PriorityQueue<int[]> queue = new PriorityQueue<>(new Comparator<int[]>(){
           public int compare(int[] pair1, int[] pair2){
               return pair1[0] != pair2[0] ? pair2[0] - pair1[0] : pair2[1] - pair2[1];
           }
       });
       
       int[] result = new int[nums.length - k + 1];

       for(int i = 0; i<k; i++){
           queue.offer(new int[]{nums[i],i});
       }
       result[0] = queue.peek()[0];
       for(int i = 1; i+k-1<nums.length; i++){
           queue.offer(new int[]{nums[i+k-1], i+k-1});
           while(queue.peek()[1]<i){
               queue.poll();
           }
           result[i] = queue.peek()[0];
       }
       
       return result;
   }

public int[] maxSlidingWindow(int[] nums, int k) {
       if(nums == null || nums.length<k || k<1){
           return null;
       }
       LinkedList<Integer> queue = new LinkedList<>();
       int[] result = new int[nums.length - k + 1];
       int index = 0;
       for(int i = 0; i<nums.length; i++){
           while(!queue.isEmpty() && nums[i]>=nums[queue.peekLast()]){
               queue.pollLast();
           }
           queue.addLast(i);
           if(queue.peekFirst()<=(i-k)){//如果被窗口抛下了（在窗口左边界的左侧）
               queue.pollFirst();
           }
           if(i>=k-1){
               result[index++] = nums[queue.peekFirst()];
           }
       }
       return result;
   }

class Solution {
    public void rotate(int[] nums, int k) {
        reverse(nums, 0, nums.length-1);
        reverse(nums, 0, k%(nums.length)-1);
        reverse(nums, k%(nums.length), nums.length-1);
    }

    public void reverse(int[] nums, int left, int right){
        while(left<=right){
            int temp = nums[left];
            nums[left] = nums[right];
            nums[right] = temp;
            left++;
            right--;
        }
    }
}

class Solution {
    public int findRepeatNumber(int[] nums) {
        for(int i = 0; i<nums.length; i++){
            while(nums[i] != i){
                if(nums[nums[i]] != nums[i]){
                    swap(nums, i, nums[i]);
                }else{
                    return nums[i];
                }
            }
        }
        return -1;
    }
    public void swap(int[] nums, int i, int j){
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
}

class Solution {
    public int[] dailyTemperatures(int[] T) {
        Stack<Integer> stack = new Stack<>();
        int n = T.length;
        int[] res = new int[n];
        for(int i = 0; i<n; i++){
            while(!stack.isEmpty() && T[i]>T[stack.peek()]){
                res[stack.peek()] = i-stack.pop();//出栈，且将两个下标差存入出栈的下标的位置
            }
            stack.push(i);
        }
        return res;
    }
}

class Solution {
    public String convertToTitle(int n) {
        StringBuilder result = new StringBuilder();
        while(n>0){
            int rem = (n-=1) % 26;//注意在这里：关键点在于要对n减1，这样可以保证当n==26的时候，余数不会为0，导致插入的字母为A
            result.insert(0, (char)('A'+rem));
            n/=26;
        }
        return result.toString();
    }
}

public ListNode partition(ListNode head, int x) {
       if(head == null){
           return null;
       }
       ListNode less = new ListNode(0);//哑节点，用来防止nullPointer
       ListNode more = new ListNode(0);
       ListNode lessPtr = less;
       ListNode morePtr = more;
       while(head != null){
           if(head.val>=x){
               morePtr.next = new ListNode(head.val);
               morePtr = morePtr.next;
           }else{
               lessPtr.next = new ListNode(head.val);
               lessPtr = lessPtr.next;
           }
           head = head.next;
       }
       lessPtr.next = more.next;
       return less.next;
   }

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if(headA == null || headB == null){
            return null;
        }
        ListNode lA = headA;
        ListNode lB = headB;
        while(lA!=lB){
            lA = lA == null ? headB : lA.next;
            lB = lB == null ? headA : lB.next;
        }
        return lA;
    }
}

public int eraseOverlapIntervals(int[][] intervals) {
       if(intervals == null || intervals.length <= 1){
           return 0;
       }

       //排序，自己重写比较器
       Arrays.sort(intervals, new Comparator<int[]>(){
           public int compare(int[] arr1, int[] arr2){
               return arr1[1] - arr2[1];
           }
       });

       int count = 1;
       int index = 0;//指向（左边界）>=前者（有边界的区间）的
       for(int i = 1; i<intervals.length; i++){
           if(intervals[i][0]>=intervals[index][1]){
               count++;
               index = i;//因为当前区间满足要求，index就指向了当前区间
           }
       }
       return intervals.length - count;
   }

public int[][] reconstructQueue(int[][] people) {
       //按照身高从大到小排序，相同身高按照前面的人数从小到大排序
       Arrays.sort(people, new Comparator<int[]>(){
           public int compare(int[] arr1, int[] arr2){
               return arr1[0] == arr2[0] ? arr1[1] - arr2[1] : arr2[0] - arr1[0];
           }
       });

       LinkedList<int[]> list = new LinkedList<>();
       for(int[] p:people){
           list.add(p[1],p);
       }
       return list.toArray(new int[list.size()][]);
   }

public int maxProfit(int[] prices) {
       if(prices.length <= 1){
           return 0;
       }
       int result = 0;
       for(int i = 1; i<prices.length; i++){
           if(prices[i]>prices[i-1]){
               result+=prices[i]-prices[i-1];
           }
       }
       return result;
   }

public boolean isSubsequence(String s, String t) {
       int index = -1;
       char[] letters = s.toCharArray();
       for(char c:letters){
           index = t.indexOf(c, index+1);//从index+1开始查找当前字符所在的位置，如果没有当前字符，返回-1
           if(index == -1){
               return false;
           }
       }
       return true;
   }

//方法2，利用数组，桶计数
    public static int longestPalindrome2(String s){
        //将所有的字符按照ASCII码装到对应的bucket中
        int[] letters = new int[128];
        for (int i = 0; i < s.length(); i++) {
            letters[s.charAt(i)]++;
        }

        int count = 0;
        for (int n:letters
             ) {
            if (n>1){
                count+=(n/2*2);
            }
            if (n%2==1&&count%2==0){
                count++;
            }
        }

        return count;
    }

public static boolean isPalindrome(String s){
        if (s.length()==0){
            return true;
        }
        int p1 = 0;
        int p2 = s.length()-1;
        while(p1<p2){
            while(p1<p2&&!Character.isLetterOrDigit(s.charAt(p1))){
                p1++;
            }
            while(p1<p2&&!Character.isLetterOrDigit(s.charAt(p2))){
                p2--;
            }
            if (p1<p2) {
                if (Character.toLowerCase(s.charAt(p1)) == Character.toLowerCase(s.charAt(p2))) {
                    p1++;
                    p2--;
                }else {
                    return false;
                }
            }
        }
        return true;
    }

/**
 * Return the length of the shortest path between root and target node.
 */
int BFS(Node root, Node target) {
    Queue<Node> queue;  // store all nodes which are waiting to be processed
    int step = 0;       // number of steps neeeded from root to current node
    // initialize
    add root to queue;
    // BFS
    while (queue is not empty) {
        step = step + 1;
        // iterate the nodes which are already in the queue
        int size = queue.size();
        for (int i = 0; i < size; ++i) {
            Node cur = the first node in queue;
            return step if cur is target;
            for (Node next : the neighbors of cur) {
                add next to queue;
            }
            remove the first node from queue;
        }
    }
    return -1;          // there is no path from root to target
}

/**
 * Return the length of the shortest path between root and target node.
 */
int BFS(Node root, Node target) {
    Queue<Node> queue;  // store all nodes which are waiting to be processed
    Set<Node> used;     // store all the used nodes
    int step = 0;       // number of steps neeeded from root to current node
    // initialize
    add root to queue;
    add root to used;
    // BFS
    while (queue is not empty) {
        step = step + 1;
        // iterate the nodes which are already in the queue
        int size = queue.size();
        for (int i = 0; i < size; ++i) {
            Node cur = the first node in queue;
            return step if cur is target;
            for (Node next : the neighbors of cur) {
                if (next is not in used) {
                    add next to queue;
                    add next to used;
                }
            }
            remove the first node from queue;
        }
    }
    return -1;          // there is no path from root to target
}

public int process(int[] nums, int i){
    if(i == 0){
        return nums[0];
    }

    if(i == 1){
        return Math.max(nums[0], nums[1]);
    }

    int A = process(nums, i-1); //不偷当前房子
    int B = process(nums, i-2)+nums[i]; //偷当前房子
    return Math.max(A, B); //选择两者中最大的值
}

public int rob(int[] nums) {
       if(nums == null || nums.length == 0){
           return 0;
       }
       if(nums.length == 1){
           return nums[0];
       }
       int[] dp = new int[nums.length]; //动态规划迭代法需要的数组
       dp[0] = nums[0]; //先将第0位和第1位填好
       dp[1] = Math.max(nums[0], nums[1]);
       for(int i = 2; i<nums.length; i++){
           int A = dp[i-1];
           int B = dp[i-2]+nums[i];
           dp[i] = Math.max(A,B);
       }
       return dp[nums.length-1];
   }

public class HeapSort {
    public static void main(String[] args) {
        int[] nums = {3, 5, 6, 1, 2, 7, 9, 8, 0, 4};
        sort(nums);
        System.out.println(Arrays.toString(nums));

    }

    /*
    1. 让数组整体形成大根堆
    2. 最后一个位置和堆顶位置交换， size-1
    3. 重新调整为大根堆
    4. 重复2-3步骤
    5. 直到 size == 0
     */
    public static void sort(int[] nums){
        if (nums == null || nums.length<2){
            return;
        }
        for (int i = 0; i < nums.length; i++) {
            insert(nums, i);
        }
        int size = nums.length;
        while (size>0){
            swap(nums, 0, size-1);
            heapify(nums, 0, --size);
        }

    }
    /**
     * 每当顶部元素发生了改变，就进行一次堆化，将最大的值推到堆顶
     * @param nums
     * @param index
     * @param size
     */
    public static void heapify(int[] nums, int index, int size){
        int left;
        while((left = index*2+1)<size){
            int largestPos = (left+1)<size&&nums[left+1]>nums[left]?left+1:left;
            largestPos = nums[largestPos]>nums[index]?largestPos:index;
            if (largestPos == index){
                break;
            }
            swap(nums, largestPos, index);
            index = largestPos;
        }
    }
    /**
     * 每插入一个新的元素，都调整成大根堆
     * @param nums
     * @param index
     */
    public static void insert(int[] nums, int index){
        while(nums[index]>nums[(index-1)/2]){
            swap(nums, index, (index-1)/2);
            index = (index-1)/2;
        }
    }

    public static void swap(int[] nums, int i, int j){
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
}

public class MergeSort {
    public static void main(String[] args) {
        int[] nums = {3, 5, 6, 1, 2, 7, 9, 8, 0, 4};
        sort(nums, 0, nums.length-1);
        System.out.println(Arrays.toString(nums));
    }

    public static void sort(int[] nums, int L, int R){
        if (R == L){
            return;
        }

        int mid = (R+L)/2;
        sort(nums, L, mid);
        sort(nums, mid+1, R);
        merge(nums, L, R, mid);
    }

    public static void merge(int[] nums, int L, int R, int mid){
        int[] temp = new int[R-L+1];
        int p = 0;
        int p1 = L;
        int p2 = mid + 1;
        while(p1<=mid&&p2<=R){
            temp[p++] = nums[p1]<nums[p2]?nums[p1++]:nums[p2++];
        }

        //如果p2遍历完了
        while(p1<=mid){
            temp[p++] = nums[p1++];
        }
        //如果p1遍历完了
        while(p2<=R){
            temp[p++] = nums[p2++];
        }

        //将temp拷贝回nums中
        System.arraycopy(temp, 0, nums, L, temp.length);
    }
}

public class QuickSort {
    public static void main(String[] args) {
        int[] nums = {3,5,6,1,2,7,9,8,0,4};
        quickSort(nums, 0, nums.length-1);
        System.out.println(Arrays.toString(nums));
    }

    public static void quickSort(int[] nums, int leftBound, int rightBound){
        if (leftBound>=rightBound){
            return;
        }
        int partition = partition(nums, leftBound, rightBound);
        quickSort(nums, leftBound, partition-1);
        quickSort(nums, partition+1, rightBound);

    }

    public static int partition(int[] nums, int leftBound, int rightBound){
        int pivot = rightBound;
        int p1 = leftBound;
        int p2 = rightBound-1;
        while (p1<=p2){
            while(p1<=p2&&nums[p1]<=nums[pivot]) p1++;
            while(p1<=p2&&nums[p2]>nums[pivot]) p2--;
            if (p1<p2){
                swap(nums, p1, p2);
            }
        }
        swap(nums, p1, pivot);
        return p1;
    }

    public static void swap(int[] nums, int i, int j){
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
}

import java.util.LinkedList;
import java.util.Queue;

public class TwoQueueStack {
    private Queue<Integer> data;
    private Queue<Integer> help;

    public TwoQueueStack() {
        this.data = new LinkedList<>();
        this.help = new LinkedList<>();
    }

    public void push(int num){
        data.add(num);
    }

    public int peek(){
        if (data.isEmpty()){
            throw new RuntimeException("Stack is empty");
        }
        while(data.size()>1){
            help.add(data.poll());
        }
        int res = data.poll();
        help.add(res);
        swap();
        return res;

    }

    public int pop(){
        if (data.isEmpty()){
            throw new RuntimeException("Stack is empty");
        }
        while (data.size()>1){
            help.add(data.poll());
        }
        int res = data.poll();
        swap();
        return res;
    }

    public void swap(){
        Queue<Integer> temp = data;
        data = help;
        help = temp;
    }

    public String toString(){
        return data.toString();
    }

    public static void main(String[] args) {
        TwoQueueStack stack = new TwoQueueStack();
        stack.push(1);
        stack.push(2);
        stack.push(3);
        stack.push(4);
        stack.push(5);
        stack.push(6);
        //按顺序弹出栈顶
        for (int i = 0; i < 6; i++) {
            System.out.println(stack.pop());
            System.out.println(stack);
            System.out.println("--------------");
        }
    }
}   

import java.util.Stack;

public class TwoStackQueue {
    private Stack<Integer> pushStack;
    private Stack<Integer> popStack;

    public TwoStackQueue() {
        this.pushStack = new Stack<>();
        this.popStack = new Stack<>();
    }

    public void add(int num){
        pushStack.push(num);
    }

    public int pull(){
        pour();
        if (popStack.isEmpty()){
            throw new RuntimeException("The queue is empty");
        }
        return popStack.pop();
    }

    public int peek(){
        pour();
        if (popStack.isEmpty()){
            throw new RuntimeException("The queue is empty");
        }
        return popStack.peek();
    }

    /**
     * 将push栈中的元素加入pop栈中
     */
    public void pour(){

        //如果pop栈不为空，则一定不能将push栈中的元素加进来
        if (!popStack.isEmpty()){
            return;
        }
        while(!pushStack.isEmpty()){
            popStack.push(pushStack.pop());
        }
    }

    public String toString(){
        return popStack.toString();
    }


    public static void main(String[] args) {
        TwoStackQueue queue = new TwoStackQueue();
        queue.add(1);
        queue.add(2);
        queue.add(3);
        queue.add(4);
        queue.add(5);

        for (int i = 0; i < 5; i++) {
            System.out.println(queue.pull());
            System.out.println(queue);
            System.out.println("-------------");
        }
    }
    /*
    1
    [5, 4, 3, 2]
    -------------
    2
    [5, 4, 3]
    -------------
    3
    [5, 4]
    -------------
    4
    [5]
    -------------
    5
    []
    -------------
     */
}