package com.test;
/*
* 1、鏈表類
* 2、一個構造方法，一個顯示方法
* */
public class Link {
public int iData;
public Link next;
public Link previous;
public Link(int id){
iData = id;
}
public void displayLink(){
System.out.println(iData+"---");
}
}雙向鏈表：
package com.test;
/*
* 雙向鏈表
*
* 3=current.pre 4=current 5=current.next
* *****************************
* | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
* *****************************
* */
public class DoublyLinkedList {
private Link firstLink;
private Link lastLink;
public DoublyLinkedList(){
firstLink = null;
lastLink = null;
}
public boolean isEmpty(){
return firstLink == null ;
}
public void insertFirst(int id){
Link newLink = new Link(id);
if(isEmpty()){
lastLink =newLink; //若if成立 則必須給lastLink 賦值
}else{
firstLink.previous = newLink; //讓第一個連接點的前一個連接點 等於 新的連接點
newLink.next = firstLink; //讓新的連接點的下一個連接點 等於 第一個連接點
}
firstLink = newLink; //給第一個連接點賦值
}
public void insertLast(int id){
Link newLink = new Link(id);
if(isEmpty()){
firstLink = newLink; //若鏈表爲空則讓新的連接點 等於 第一個連接點等於
}else{
lastLink.next = newLink;
newLink.previous = lastLink;
}
lastLink = newLink;
}
//在當前節點後面插入新的連接點
public boolean insertAfter(int key,int id){
Link current = firstLink;
while (current.iData != key) { //循環鏈表 當current = key時跳出循環
current = current.next;
if(current == null){
return false;
}
}
Link newLink = new Link(id);
if(current == lastLink){ //當current = lastLink時
newLink.next = null;
lastLink = newLink;
}else{ //否則
newLink.next = current.next; //新連接點的下一個 指向 當前連接點的下一個
current.next.previous = newLink;//當前連接點的前一個連接點 等於 新的連接點
}
newLink.previous = current; //新的連接點的前一個連接點 等於 當前連接點
current.next = newLink; //當前連接點的下一個 等於 新的連接點
return true;
}
public Link deleteFirst(){
Link tempLink = firstLink;
if(firstLink.next == null){
lastLink = null;
}else{
firstLink.next.previous = null;
firstLink = firstLink.next;
}
return tempLink;
}
public Link deleteLast(){
Link tempLink = lastLink;
if(lastLink.previous == null){
firstLink = null;
}else{
lastLink.previous.next = null;
lastLink = lastLink.previous;
}
return tempLink;
}
public Link deleteKey(int key){
Link current = firstLink;
while (current.iData!=key) {
current = current.next;
if(current == null){
return null;
}
}
if(current == firstLink){ //當刪除的等第一個連接點是
firstLink = current.next;
}else{
current.previous.next = current.next; //被刪除節點的前一個連接點指向被刪除連接點的後一個連接點
}
if(current == lastLink){
lastLink = current.previous;
}else{
current.next.previous = current.previous;//被刪除節點的下一個連接點節點指向被刪除節點的前一個連接點
}
return current;
}
public void displayForward(){
System.out.println("List---(first--->last)");
Link currentLink = firstLink;
while(currentLink != null) {
currentLink.displayLink();
currentLink = currentLink.next;
}
}
public void displayBackward(){
System.out.println("List---(last--->first)");
Link currentLink = lastLink;
while (currentLink != null) {
currentLink.displayLink();
currentLink = currentLink.previous;
}
}
public static void main(String[] args) {
DoublyLinkedList list = new DoublyLinkedList();
list.insertFirst(1);
list.insertFirst(2);
list.insertFirst(3);
list.insertLast(4);
list.insertLast(5);
list.insertLast(6);
list.displayForward();
list.displayBackward();
list.insertAfter(1, 7);
list.displayForward();
Link linkFirstLink = list.deleteFirst(); //在刪除的時候應該先判斷鏈表是否爲空，此處省略
System.out.println("deleteFirst--->"+linkFirstLink.iData);
Link linkLastLink = list.deleteLast();
System.out.println("deleteLast---->"+linkLastLink.iData);
Link linkDeleteKey = list.deleteKey(1);
System.out.println("delteKey------>"+linkDeleteKey.iData);
}
}雙端鏈表：
package com.test;
/*
* 雙端鏈表
* 1、刪除不掉最後一個連接點
* */
public class FirstLastList {
public Link first;
public Link last;
public FirstLastList(){
first = null;
last = null;
}
public boolean isEmpty(){
return first == null;
}
public void insertFirst(int id){
Link newLink = new Link(id);
if(isEmpty()){
last = newLink; ////若Link 爲空 則insertFirst 將last指向新的連接點
}
newLink.next = first;
first = newLink; // 將新插入的值賦給鏈表中的第一個數
}
public void insertLast(int id){
Link newLink = new Link(id);
if(isEmpty()){
first = newLink; //若Link 爲空 則insertLast 將first指向新的連接點
}else{
last.next = newLink;
}
last = newLink; //將新插入的值賦給鏈表中最後一個數
}
//插入排序
public void insert(Link k){
Link previous = null; //從表頭開始
Link current = first;
while (current!=null && k.iData < current.iData ) {
previous = current;
current = current.next;
}
if(previous == null){ //如果要插入的數在表頭
first = k;
}else{ //如果要插入的數不在表頭
previous.next = k;
}
k.next = current;
}
public Link deleteLink(){
Link temp = first;
if(first.next!=null){
last = null;
}
first.next = first;
return temp;
}
public void display(){
System.out.println("list :(first ---> last)");
Link current = first;
while (current != null) {
current.displayLink();
current = current.next;
}
}
public static void main(String[] args) {
FirstLastList fll = new FirstLastList();
fll.insertFirst(1);
//fll.insertFirst(2);
fll.insertFirst(3);
fll.insertLast(55);
fll.insertLast(77);
Link k = new Link(2);
fll.insert(k);
//fll.deleteLink(); //刪除不掉最後一個
fll.display();
//fll.deleteLink();
}
}鏈表的增刪查改
package com.test;
/*
* 1、鏈表的插入、刪除
* 2、查找鏈表中指定的連接點
* 3、刪除鏈表中指定的連接點
*
* */
public class LinkList {
private Link firstLink; //鏈表中第一個數
public LinkList(){
firstLink = null;
}
public boolean isEmpty(){
return (firstLink==null);
}
public void insertFirst(int id){
Link newLink = new Link(id);
newLink.next = firstLink; // 讓新創建的連接點的next指向原來（第一個）的連接點
firstLink = newLink; // 改變原來firstLink的值，讓他指向新的連接點
}
public Link deleteFirst(){
Link temp = firstLink; //在刪除之前將鏈表中第一個存在temp中,然後刪除firstLink（假設有刪除操作）
firstLink = firstLink.next;//將firstLink指向原來firstLink的下一個（next）
return temp; //返回刪除後的這個數
}
public void displayList(){
Link current = firstLink;
while (current != null) {
current.displayLink();
current = current.next;
}
}
/*
* currentLink 的變量開始指向第一個連接點（即，firstLink）
* 然後通過不斷的把自身的值賦值給 currentLink.next，沿着鏈表向前移動
* 檢查每個連接點的key 是否與 參數（id）相等
* 若找到匹配的，則返回此連接點的引用，否則返回 null
* */
public Link find(int id){
Link currentLink = firstLink; //保存第一個連接點（即 currentLink 引用第一個練級點）
while (currentLink.iData!= id) { //若連接點的key 與參數是否相等
if(currentLink.next == null){ //若連接點的的下一個爲空
return null;
}else{
currentLink = currentLink.next; //否則讓此連接點等於下一個連接點，繼續循環
}
}
return currentLink;
}
public Link deleteLink(int id){
Link beforLink = firstLink; //被刪除數的前一個數
Link tempLink = firstLink; //被刪除的數
while (tempLink.iData!=id) {
if(tempLink == null){
return null;
}else{
beforLink = tempLink; //beforLink 始終等於 被刪除數（tempLink） 的前一個數
tempLink = tempLink.next;
}
}
if(tempLink == firstLink){ //若 被刪除數（tempLink） 爲 鏈表中的第一個數，則讓firstLink 等於他的下一個
firstLink = firstLink.next;
}else{
beforLink.next = tempLink.next; //否則 讓被刪除數（tempLink） 的後一個數等於 被刪除數的位置 （即beforLink.next）
}
return tempLink;
}
public static void main(String[] args) {
LinkList theLinkList = new LinkList();
theLinkList.insertFirst(1);
theLinkList.insertFirst(2);
theLinkList.insertFirst(3);
theLinkList.displayList();
//循環刪除 鏈表裏面的值
while (!theLinkList.isEmpty()) {
Link aLink = theLinkList.deleteFirst();
System.out.println("Delete");
aLink.displayLink();
}
theLinkList.displayList();
//找到指定的連接點
Link find = theLinkList.find(2);
if(find!=null){
System.out.println("find link with key--->"+find.iData);
}else{
System.out.println("can't find "+find.iData);
}
//刪除指定的連接點
Link delet = theLinkList.deleteLink(2);
if(delet!=null){
System.out.println("delete link with key--->"+find.iData);
}else{
System.out.println("can't find "+find.iData);
}
}
}