JAVA 線性表、棧、佇列和優先佇列
線性表、棧、佇列和優先佇列
資料結構是以某種形式將資料組織在一起的合集。資料結構不僅儲存資料，還支援訪問和處理資料的操作。
JAVA的合集框架如下圖所示
合集
JAVA合集框架支援兩種型別的容器： 一種是儲存一個元素合集，簡稱合集。 另一種是為了儲存鍵、值對，稱為對映表。
- Set用於儲存一組不重複的元素。
- List用於儲存一個有序的元素合集。
- Stack用於儲存採用後進先出方式處理的物件
- Queue用於儲存採用後進先出方式處理的物件。
- Priority Queue 用與儲存按照優先順序順序處理的物件。
Collection介面
Collection 介面為線性表、向量、棧、佇列、優先佇列以及合集定義了共同的操作。
1.Collection介面通用方法
boolean add (Object obj):新增一個元素 boolean addAll (Collection c):將集合c中的所有元素新增到該集合中。 void clear();//清空集合中所有元素。 boolean contains (Object o)：判斷集合中是否包含指定的元素 boolean containsAll (Collection c)：判斷集合中是否包含指定的集合的所有元素。 boolean equals(Object o) 比較此集合 與指定物件是否相等。 boolean isEmpty() 如果此集合為空，則返回 true。 boolean remove(Object o) 從此集合中移除指定元素 boolean removeAll(Collection<?> c) 從集合從移除中的所有元素 boolean retainAll(Collection<?> c) 保留同時位於c和該集合中的元素。 int size() 返回此集合中的元素個數。 Object[] toArray() 返回包含此 集合中所有元素的陣列。 T[] toArray(T[] a) 返回包含此 集合中所有元素的陣列；返回陣列的執行時型別與指定陣列的執行時型別相同。
public class MyDemo {
public static void main(String[] args) {
Collection<String> collection = new ArrayList<>();
//add() 往 集合中新增元素
collection.add("林黛玉");
collection.add("賈寶玉");
collection.add("史湘雲");
collection.add("薛寶釵");
System. 2.迭代器
每種合集都是可迭代的(Iterable)。 可以獲得集合的Iterator 物件來遍歷合集中的所有元素。 terator是一種經典的設計模式，用於在不需要暴露資料是如何儲存在資料結構的細節的情況下，來遍歷一個數據結構。 Collection介面繼承自Iterable介面。 使用集合的terator()方法來返回一個迭代器。 boolean hasNext () 如果仍有元素可以迭代，則返回 true。 E next () 返回迭代的下一個元素。 void remove() 移除使用next方法獲取的上一個元素。
public class MyIteratorDemo {
public static void main(String[] args) {
Collection<String> list = new ArrayList<>();
list.add("令狐沖");
list.add("嶽靈珊");
list.add("嶽不群");
list.add("任盈盈");
list.add("任我行");
list.add("田伯光");
//遍歷集合中的元素
Iterator iterator = list.iterator();
while (iterator.hasNext()){
Object o = iterator.next();
System.out.println(o);//令狐沖 嶽靈珊 嶽不群 任盈盈 任我行 田伯光
}
}
}
3.List介面
List介面繼承自Collection介面，定義了一個用於順序儲存元素的合集。 List集合特點:元素有序,每個元素都有索引,允許儲存重複元素.
1).List介面
boolean add(:int index,Object element) 在指定索引位置加入一個指定元素 boolean addAll(:int index ，Collection<？extends E> c) 在指定位置處新增c的所有元素。 int indexOf(Object element) 返回第一個匹配元素的索引 int lastIndexOf(Object element) 返回最後一個匹配元素的索引 E get(int index) 返回指定索引處的元素 Object set(int index,Object elements) 設定指定索引處的元素 E remove(int index)移除指定索引處元素 list subList(int fromIndex,int toIndex) 返回從fromIndex到toIndex-1的子線性表。
public class ListDemo {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
//add()
list.add(200);
list.add(300);
list.add(0,100);
System.out.println(list);//[100, 200, 300]
//addAll()
List<Integer> list2 = new ArrayList<Integer>();
list2.add(100);
list2.add(500);
list.addAll(2,list2);
System.out.println(list);//[100, 200, 100, 500, 300]
//indexOf() lastIndexOf()
System.out.println(list.indexOf(100));//0
System.out.println(list.lastIndexOf(100));//2
//get()
System.out.println(list.get(2));//100
//set
list.set(1,500);
System.out.println(list);//[100, 500, 100, 500, 300]
//remove()
list.remove(0);
System.out.println(list);//[500, 100, 500, 300]
//subList
List list3= list.subList(1,3);
System.out.println(list3);//[100, 500]
}
}
2).list迭代器ListIterator
ListIterator介面繼承了Iterator介面 void add(E element) 新增一個指定物件到線性表中。 boolean hasPrevious()當往回遍歷時，如果還有更多元素，則返回true int nextIndex()返回下一個元素的索引 E previous()返回線性表遍歷器的前一個元素。 int previousIndex() 返回前一個元素索引 void set（E element）使用指定元素替換previous或者next方法返回的最後一個元素
可以使用List的listIterator(int star)方法獲得從star開始的元素迭代器
public class listIteratorDemo {
public static void main(String[] args) {
List<Character> list = new ArrayList<>();
list.add('a');
list.add('c');
list.add('e');
ListIterator<Character> ite = list.listIterator(list.size());
while(ite.hasPrevious()){
System.out.println(ite.previousIndex());//依次2 1 0
System.out.println(ite.previous());//依次 e c a
}
ite.set('o');//注意新增到上一次遍歷的地方
list.add('p');
System.out.println(list);//[o, c, e, p]
}
}
3.)ArrayList 類
ArrayList使用大小可變的陣列實現List介面 每個Arraylist例項都有它的容量，這個容量是指儲存線性表中元素的陣列的大小。它–定不小於所儲存的線性表的大小。向ArrayList中新增元素時，其容量會自動增大。ArrayList 不能自動減小。可以使用方法trimToSizeO將陣列容量減小到線性表的大小。 構造方法： ArrayList() 建立一個空的線性表 ArrayList(Collection<? extends > c)從已經存在的合集中建立線性表 ArrayList(int initialCapacity ) 建立一個指定容量的容器。
public class ArrayListDemo {
public static void main(String[] args) {
ArrayList arrayList = new ArrayList();
arrayList.add(400);
arrayList.add(500);
arrayList.add(600);
arrayList.add(100);
arrayList.add(200);
arrayList.add(100);
arrayList.add(200);
arrayList.add(300);
int i = arrayList.indexOf(100);
i=arrayList.lastIndexOf(100);
System.out.println(i);//5
//排序集合中的元素
arrayList.sort(new Comparator() {
@Override
public int compare(Object s1, Object s2) {
Integer a= (Integer) s1;
Integer b= (Integer) s2;
return -(a-b);
}
});
System.out.println(arrayList);//[600, 500, 400, 300, 200, 200, 100, 100]
//根據索引擷取集合中的元素
List list = arrayList.subList(0, 3);
System.out.println(list);//[600, 500, 400]
System.out.println(arrayList);//[600, 500, 400, 300, 200, 200, 100, 100]
}
}
4).LinkedList類
linkedList類使用連結串列實現List介面。除了實現List介面外，這個類還提供了從線性表兩端提取、插入和刪除元素的方法。 void addFirst (E e)在此列表的開始處插入指定的元素。 void addLast (E e)將指定的元素列表的結束。 E getFirst ()返回此列表中的第一個元素。 E getLast ()返回此列表中的最後一個元素。 E pollFirst ()檢索並移除此列表的第一個元素， E pollLast ()檢索並移除此列表的最後一個元素，
public class LinkedListDemo {
public static void main(String[] args) {
LinkedList<Integer> linkedList = new LinkedList<>();
linkedList.add(100);
linkedList.add(800);
linkedList.addLast(500);
linkedList.addFirst(600);
for (int i = 0; i < linkedList.size(); i++) {
Object o = linkedList.get(i);
System.out.println(o);//依次600 100 800 500
}
System.out.println("---------------------------");
System.out.println(linkedList.getFirst());//600
System.out.println(linkedList.pollFirst());//600
System.out.println(linkedList);//[100, 800, 500]
}
}
連結串列可以使用get(i)方法，但非常耗時。
5)Vector與Stack
void addElement (E obj)新增指定的元件到這個向量的結束，增加其大小由一個。 E elementAt ( int index)返回指定索引處的元件。 Enumeration elements ()返回此向量的元件的列舉。 boolean equals (Object o)將指定的物件與此向量進行比較，以進行相等性。 E firstElement ()返回第一個元件（在指數 0 專案）這個載體。 E lastElement ()返回向量的最後一個元件。 void removeElementAt ( int index) 在指定的索引中刪除元件
public class VectorDemo {
public static void main(String[] args) {
Vector vector = new Vector();
vector.addElement(100);
vector.addElement(200);
vector.addElement(300);
Vector vector2 = new Vector();
vector2.addElement(100);
vector2.addElement(200);
vector2.addElement(300);
vector2.addElement(500);
//返回一個迭代器
Enumeration elements = vector.elements();
while (elements.hasMoreElements()){
Object o = elements.nextElement();
System.out.println(o);//依次 100 200 300
}
//對比兩個集合當中元素是否一模一樣
boolean equals = vector.equals(vector2);
System.out.println(equals);//flase
Object o = vector2.firstElement();
System.out.println(o);//100
vector2.removeElementAt(vector2.size()-1);
System.out.println(vector2);//[100, 200, 300]
}
}
stack是作為Vector類的擴充套件來實現的。 Stack()建立一個空棧 boolean empty() 判斷棧空 E peek() 返回棧頂元素 E pop()返回並移除棧頂元素 E push(E o)增加新元素到棧頂 int search(Object:o)返回棧中指定元素的位置
3.Queue介面
Queue介面繼承自Collection、加入了插入、提取和檢驗等操作。
1).Queue介面方法
boolean offer(E elements）插入一個元素到佇列中 E poll()返回並移除佇列頭元素 若空返回null E remove()返回並移除佇列頭元素 若空丟擲異常 E peek()獲取但不移除佇列頭元素若空返回null E element() 獲取但不移除佇列頭元素若空丟擲異常
public class QueueDemo{
public static void main(String[] args){
Queue<String> queue = new Queue<>();
queue.offer("aaa");
queue.offer("bbb");
queue.offer("ccc");
queue.offer("ddd");
while(queue.size()>0){
System.out.println(queue.remove());
}
}
}
2).雙端佇列Deque和連結串列LinkedList
Deque支援在兩端插人和刪除元素。deque是(double-endedqueue),雙端佇列的簡稱。Deque介面繼承自Queue,增加了從佇列兩端插人和刪除元素的方法。方法addFirst(e)、removeFirstO、addLast(e)、 removeLastO、 getFirst() 和getLastO都在Deque介面中定義。 LinkedList也實現了Deque。
3).Priorityqueue優先佇列
PriorityQueue類實現了一個優先佇列。預設情況下，優先佇列使用Comparable以元素的自然順序進行排序。擁有最小數值的元素被賦予最高優先順序，因此最先從佇列中刪除。如果幾個元素具有相同的最高優先順序，則任意選擇一個。也可以使用構造方法PriorityQueue(initialCapacity , comparator)中的Comparator來指定一個順序。 PriorityQueue() 建立一個初始容量為11的預設優先佇列 PriorityQueue(int initialCapacity)建立一個初始容量為指定值的預設優先佇列 PriorityQueue(Collection <? extends E> c)建立一個具有指定集合的優先佇列 PriorityQueue(int initialCapacity，Comparator<? super E>comparator) 建立一個初始容量為指定值並且具有比較器的優先佇列。
public class Priori tyQueueDemo{
public static void main(String[] args){
PriorityQueue<String> queuel = new PriorityQueue<>()
queuel.offer("oklahoma");
queuel.offer("Indiana");
queuel.offer("Georgia");
queue1.offer("Texas");
while(queue1.size() > 0){
System. out .println(queuel.remove());
PriorityQueue<String> queue2 = new PriorityQueue(4,Collections.reverseOrder());
queue2.offer("Okl ahoma");
queue2.offer("Indiana");
queue2.
相關推薦
JAVA 線性表、棧、佇列和優先佇列
線性表、棧、佇列和優先佇列
資料結構是以某種形式將資料組織在一起的合集。資料結構不僅儲存資料，還支援訪問和處理資料的操作。
JAVA的合集框架如下圖所示
合集
JAVA合集框架支援兩種型別的容器：
一種是儲存一個元素合集，簡稱合集。
另一種是為了儲存鍵、值對，稱
FIFO佇列和優先佇列
FIFO佇列
定義：先進先出的儲存結構(刪除時先刪最後一個元素)
queue<型別> q;
增：
q.push(元素值); //在隊尾加入一個元素 void
刪：
q.pop(); //刪除
合併果子（佇列和優先佇列）
有兩種方法 一種是佇列 一種是優先佇列（priority_queue） 這兩種方法的區別是佇列定義時沒有自動排序 所以只能在輸入的時候按順序才能輸出正解（所以佇列的方法不被認為是正解） 下面是程式碼 比較簡便：
#include<bits/stdc++.h>
using na
C++之佇列和優先佇列
C++ queue（佇列）Priority queue（優先佇列）
【queue】
C++佇列是一種容器介面卡，它給予程式設計師一種先進先出(FIFO)的資料結構。1.back() 返回一個引用，指向最後一個元素2.empty() 如果佇列空則返回真3.front()
資料結構和演算法精講版（陣列、棧、佇列、連結串列、遞迴、排序、二叉樹、紅黑樹、堆、雜湊表）Java版
查詢和排序是最基礎也是最重要的兩類演算法，熟練地掌握這兩類演算法，並能對這些演算法的效能進行分析很重要，這兩類演算法中主要包括二分查詢、快速排序、歸併排序等等。我們先來了解查詢演算法! 順序查詢: 順序查詢又稱線性查詢。它的過程為：從查詢表的最後一個元素開始逐個與給定關鍵字比較，若某個記錄的關鍵字和給定值比較
第二章之線性表、棧、佇列和線性表
線性表的儲存結構（主要有兩種）：
1、定長的順序儲存結構，也稱順序表或向量型的一維陣列結構。資料結點之間的邏輯關係是通過資料結點的儲存位置來反映的。
2、邊長的線性結構儲存結構、大多實現為連結式儲存結構。資料結點之間的邏輯關係是以指標來表示的。
兩者的比較
1、順序表的主要優點體現在沒有使用指標，節省
線性表、棧、佇列的的順序儲存和鏈式儲存
先概括一下線性表順序儲存和鏈式儲存。
線性表的順序儲存是用一組地址連續的儲存單元依次儲存線性表的資料元素。
線性表的鏈式儲存是用指標將儲存線性表中的資料元素的那些單元依次串聯在一起。
接下來圖片說明。
資料結構 1 線性表詳解 連結串列、 棧 、 佇列 結合JAVA 詳解
## 前言
其實在學習資料結構之前，我也是從來都沒了解過這門課，但是隨著工作的慢慢深入，之前學習的東西實在是不夠用，並且太皮毛了。太淺，只是懂得一些淺層的，我知道這個東西怎麼用，但是要優化、或者是解析，就不知道該咋弄了。比如JAVA 最有名的幾個容器:
- List
- Set
- MAP
- Queue
第二章之線性表、棧、隊列和線性表
根據 取出 指針 插入 特殊性 邏輯 排序 存儲結構 mar 線性表的存儲結構（主要有兩種）：
1、定長的順序存儲結構，也稱順序表或向量型的一維數組結構。數據結點之間的邏輯關系是通過數據結點的存儲位置來反映的。
2、邊長的線性結構存儲結構、大多實現為鏈接式存儲結構。數據結點
線性表、連結串列、棧、佇列的關係
一、前言
程式設計師在程式設計實戰操作面前有兩個攔路虎，第一個是用遞迴的思想去解決問題，第二個是資料結構與演算法的應用。對於遞迴，由於其神奇的薄面紗總是然我們覺得難以理解，而大多數遞迴解法還是需要承擔一定的計算負擔的，因此我覺得能理解其思想與用法固然好，但是實在無法
線性表、棧、佇列的鏈式儲存結構
一、順序儲存結構與鏈式儲存結構的區別
順序儲存就是從記憶體中取出一段連續地址的空間，將資料依次連續的儲存在這段空間中。而鏈式儲存結構是指資料儲存在記憶體中的地址是離散的，以資料節點為單
資料結構：表、棧、和佇列（1）——抽象資料型別
引子：程式設計的基本法則之一是模組化，即每個模組是一個邏輯單位，並能實現某個特定的功能。其優點有三點：一、模組化的程式，在除錯上較為容易。二、模組化程式程式設計，更容易實現多人可以同時工作。三、一個好的模組化程式把某些依賴關係只侷限在一個例程中，這樣使得修改起
JavaScript 資料結構與演算法之美 - 線性表（陣列、棧、佇列、連結串列）
前言
基礎知識就像是一座大樓的地基，它決定了我們的技術高度。
我們應該多掌握一些可移值的技術或者再過十幾年應該都不會過時的技術，資料結構與演算法就是其中之一。
棧、佇列、連結串列、堆 是資料結構與演算法中的基礎知識，是程式設計師的地基。
筆者寫的 JavaScript 資料結構與演算法之美 系列用
java實現單鏈表、棧、佇列三種資料結構
#一、單鏈表
1、在我們資料結構中，單鏈表非常重要。它裡面的資料元素是以結點為單位，每個結點是由資料元素的資料和下一個結點的地址組成，在java集合框架裡面
LinkedList、HashMap（陣列加連結串列）等等的底層都是用連結串列實現的。
2、下面是單鏈表的幾個特點：
資料元
線性表——連結串列、佇列、堆疊
主要內容
連結串列
連結串列相加/連結串列部分翻轉/連結串列去重
連結串列劃分/連結串列公共結點
佇列
數據結構之線性表、棧、隊列
remove const rpo end delet get amp list etop 溫故而知新~~~~
一、線性表
順序表實現（C++）
1 template<typename E>
2 class AList
3 {
4 private:
資料結構(1) 線性表技巧及應用:字首和、排序（逆序對求法之一）
雖然線性表實在過於簡單，幾乎不會有大佬寫它的應用 但是作為一個菜雞的我還是打算歸納總結一下線性表一些應用和技巧
1.字首和
emmmm 我們來看這樣一個問題 已知一個序列s[ i ] (1<=i<=n)，有m個請求，每個請求為兩個整數a,b（1<=a<=b&l
程式設計實現順序儲存結構和鏈式儲存結構線性表的建立、查詢、插入、刪除等基本操作
#include <stdio.h>
#include <stdlib.h>
typedef struct LNode{
int data; //連結串列資料
struct LNode* next; //連結串列指標
}LNode,*L
JAVA SE篇--05 棧、佇列、HashMap
1.佇列 java.util.Queue 佇列可以存放一組元素，但是存取元素必須遵循，先進先出的原則。public class QueueDemo {
public static void main(String[] args) {
/*
* LinkedL
陣列、連結串列、棧、佇列和STL【轉】
陣列
陣列是一種最基本的資料結構，它是記憶體上的一塊連續儲存空間。正因如此陣列的隨機訪問很方便。但陣列也有其固有的限制，大小分配後不能改變。
STL中的陣列
STL中的Array是靜態陣列模板，就是我們所說的陣列。使用方法如下。
std::arra