2. 程式人生 > >單鏈表的插入，刪除，查詢，轉置

單鏈表的插入，刪除，查詢，轉置

阿新 • • 發佈：2018-11-11

單鏈表的定義

線性表的鏈式儲存又稱為單鏈表，它是指通過任意一組的儲存單元來儲存線性表中的資料元素。 在單鏈表中，每個節點包含一個指向連結串列下一節點的指標。連結串列最後一個節點的指標欄位的值為NULL，提示連結串列後面不再有其它節點。它是非隨機存取的儲存結構，操作時只能從表頭開始遍歷。

這裡寫圖片描述
通常用 “頭指標” 標識一個單鏈表，頭指標為“NULL“ 表示空表，為了操作上的方便，在單鏈表的第一個節點前附加一個節點，稱頭節點 ，引入頭節點的兩個優點：
1）由於開始節點的位置被存放被存放在頭節點的指標域，所以再連結串列第一個位置的操作和在表的其他位置上操作一致，無需特殊對待
2）無論連結串列是否空，其頭指標是指向頭節點的非空指標（空表中頭節點的指標域為空），因此空表的和非空表的處理也就統一了
因此以下討論基於帶有頭節點的單鏈表

採用資料結構：

typedef struct node{
    ElemType data;
    struct node * next;
}node;

1.建立

1）頭插法

node *creat(){
    node *head=new node,*p,*pre;
    head->next =NULL;  //original
    pre=head; 
    int x;
    scanf("%d",&x);
    while(x!=-1){    
        p=new node;
        p->data =x;
        p->next
 
 =pre->next ;  //每個節點插入O(1),總O(n) 
        pre->next =p;
        scanf("%d",&x); 
    }
    return head;
}

頭插法雖簡單，但生成連結串列中節點的次序與輸入順序不一致，若希望兩者次序一致，可採用頭插法。

2)尾插法

node *creat(){
    node *head=new node;
    head->next =NULL;
    int x;
    cin>>x;
    node *pre=head,*p;
    while
 
(x!=-1){
        p=new node;
        p->data =x;
        p->next=NULL;
        pre->next =p;
        pre=p;
        cin>>x;
    } 
    return head;
}

2.查詢

1）按序號查詢
2）按值查詢
這兩種都比較簡單，直接遍歷連結串列搜尋，符合條件時輸出，此不贅述

3.刪除節點

1）按序號刪除

關鍵點：遍歷查詢單鏈表中待刪除節點的前驅

node* Del_node_id( node *head,int i){
    node *p=head,*q;
    int count=0;
    while(p->next !=NULL){
        count++;
        q=p->next; // 找q前驅 
        if(count==i){
            p->next =q->next;
            delete q;
            return head;
        } 
        p=p->next;  
    }
      //i 不符合實際要求 
      printf("你的刪除元素位置有錯！\n");
    return head;
}

2）按元素值刪除

node *Del_node_value(node *head,int value){
    node *p=head,*q;
    while(p->next !=NULL){ 
        q=p->next ;  //找q前驅節點
        if(p->next->data==value  ){ 
            p->next =q->next ;
            delete q;
            return head; 
        }
        p=p->next ; //指標後移
    }
        printf("此連結串列沒有值為value的節點！\n");   
    return head;
}

刪除過程注意不要斷鏈即可

那麼問題來了：如何刪除單鏈表中的重複節點（保留第一個重複節點）

思路1：兩層迴圈，暴力列舉刪除，時間複雜度O（n^2),空房間複雜度O(1)

void Del_linklist(node * H){
    node *p,*q,*r;
    p=H->next; 
    if(p!=NULL) //非空連結串列
        while(p->next){  //外層，需大於1個節點
            q=p-next;
            while(q){ //內層，p的下一個節點開始遍歷
                if(q->next->data==p->data){ //刪除符合條件的節點
                    r=q->next;
                    q->next=r->next;
                    delete r;
                }
                q=q->next;
            }
            p=p->next;
        }
 }

思路2：改進第一種做法，採用空間換時間，使用輔助陣列記錄連結串列已出現的節點，從而只對連結串列進行一邊掃描，邊遍歷邊標記，符合刪除條件，則delete。時間複雜度O（n),空房間複雜度O(n)

node *delList(node *head){
    node *r,*p=head->next;
    r=p;
    if(p==NULL) return NULL;
    fill(vis,vis+1000,false);
    while(p!=NULL){
        if(vis[p->data]==true){
        r->next =p->next ;
        delete p;
        p=r->next ;
    }
    else{
        vis[p->data]=1;
        r=p;
        p=p->next ; 
      }
    }
    return head;
}

類似問題：如何刪除連結串列中重複元素（重複元素全部刪除）

提示：空間換時間，採用Hash[ ]雜湊,一遍掃描標記，一遍掃描刪除，只需兩次遍歷。時間複雜度O（n),空房間複雜度O(n)。

node *del(node *head){
    fill(hash,hash+maxn,0);
    node *r,*p=head->next;
    r=head;
    if(p==NULL) return NULL;
    while(p){ //一遍掃描標記
        hash[p->data]++;
        //cout<<p->data <<hash[p->data]<<endl; 
        p=p->next ;
    }
    //開始開始嘍
    p=r-next; 
    while(p!=NULL){ //一遍掃描刪除
        if(hash[p->data]>1){
            r->next =p->next ;
            delete p;
            p=r->next ;
        }else{
            r=p;
            p=p->next ; 
        }
    }
    return head;
}

4.插入節點

關鍵點：找到待插入節點位置的前驅

node* Insert_linklist(node *head,int i,int value){
    node *p=head,*q;
    int count=0;
    while(p->next !=NULL){
        count++;
        if(count==i) //找待插入節點的前驅指標 p 
        break; 
        p=p->next;
    } //開始插入
    q=new node;
    q->data =value;
    q->next =p->next ;
    p->next =q;
    return head;
}

5.逆置連結串列

關鍵點：不斷遍歷連結串列，將後一個節點的next指向前一個節點
最後頭節點掛到原連結串列的尾部

node* Transpose_linklist(node *H){
    node*p,*q,*pr;
    p=H->next ;
    H->next =NULL; //摘除頭節點 
    q=NULL;  
    while(p){
        pr=p->next;
        p->next=q; //後一個節點的next指向前一個節點
        q=p;   //尾指標為空 
        p=pr;  //指標後移 
     } 
     H->next =q; //頭節點掛到原連結串列的尾部
     printf("轉置後連結串列：\n");
 }

6.列印連結串列

void output_linklist(node* H){
    node *p=H->next ;
    while(p){
        printf("%2d",p->data );
        p=p->next ;
    }
}

7.程式碼

#include<cstdio>
#define ElemType int
struct node{
    ElemType data;
    node * next;
};
//尾插法建立單鏈表 
node *creat1( ){
    node*head,*pre,*p;
    int x;
    scanf("%d",&x);
    head=new node;
    head->next=NULL;
    pre=head;
    while(x!=-1){
        p=new node;     
        p->data=x;
        p->next=NULL;
        pre->next=p;
        pre=p;
        scanf("%d",&x); 
    }
    return head;
}
//頭插法建立單鏈表
/*  
node *creat2(){
 *  node *head=new node,*p,*pre;
 *  head->next =NULL;  //original
 *  pre=head; 
 *  int x;
 *  scanf("%d",&x);
 *  while(x!=-1){    
 *      p=new node;
 *      p->data =x;
 *      p->next =pre->next ;  //每個節點插入O(1),總O(n) 
 *      pre->next =p;
 *      scanf("%d",&x); 
 *  }
 *  return head;
}*
*/ 
//轉置單鏈表 
node* zhuanzhi_linklist(node *H)
{
    node*p,*q,*pr;
    p=H->next ;
    H->next =NULL; //摘除頭節點 
    q=NULL;  
    while(p)
    {
        pr=p->next;
        p->next=q;
        q=p;   //尾指標為空 
        p=pr;  //指標後移 
     } 
     H->next =q; 
     printf("轉置後連結串列：\n");
 } 
//刪除單鏈表中重複的節點,時間複雜度o(n^2)
//hash[]後刪除效率高 
void Del_linklist(node * H){
    node *p,*q,*r;
    p=H->next; 
    if(p!=NULL)
        while(p->next) {
            q=p;
            while(q->next)
            {
                if(q->next->data==p->data)
                {
                    r=q->next;
                    q->next=r->next;
                    delete r;
                }
                q=q->next;
            }
            p=p->next;
        }
 } 
//刪除某位置節點
node* Del_node_id( node *head,int i){
    node *p=head,*q;
    int count=0;
    while(p->next !=NULL){
        count++;
        q=p->next; // 找q前驅 
        if(count==i){
            p->next =q->next;
            delete q;
            return head;
        } 
        p=p->next;  
    }
      //i不符合實際要求 
      printf("你的刪除元素位置有錯！\n");
    return head;
} 
//刪除值為value的節點
node *Del_node_value(node *head,int value){
    node *p=head,*q;
    while(p->next !=NULL){
        q=p->next ;
        if(p->next->data==value  ){
            p->next =q->next ;
            delete q;
            return head; 
        }
        p=p->next ;
    }
        printf("此連結串列沒有值為value的節點！\n");   
    return head;
}
//新增 n 個節點
node *Add_linklist(node *head){
    node *p=head,*q;
    while(p->next!=NULL){   //此處的 p 應指向尾節點，方便新增新的節點 
        p=p->next ;
    }
    int x;
    scanf("%d",&x);
    while(x!=-1){
        q=new node;
        q->data =x;
        q->next =NULL;
        p->next =q;
        p=q;
        scanf("%d", &x );
        }
    return head;
} 
//插入節點
node* Insert_linklist(node *head,int i,int value){
    node *p=head,*q;
    int count=0;
    while(p->next !=NULL){
        count++;
        if(count==i) //找帶插入節點位置的前驅指標 p 
        break; 
        p=p->next;
    } 
    q=new node;
    q->data =value;
    q->next =p->next ;
    p->next =q;
    return head;
} 
//列印節點 
void output_linklist(node* H)
{
    node *p=H->next ;
    while(p)
    {
        printf("%2d",p->data );
        p=p->next ;
    }
}
int main(){
    node*head=creat1();
    printf("列印連結串列:\n"); 
    output_linklist(head);
    printf("\n");
    Transpose_linklist(head);
    output_linklist(head);
    printf("\n");
    Del_linklist(head);
    printf("刪除重複節點，保留第一個:\n");
    output_linklist(head);
    printf("\n");
    printf("輸入尾部要新增節點，-1表示結束:\n");
    head=Add_linklist(head);
    output_linklist(head);
    printf("\n");
    int i,value;
    printf("輸入要插入的元素位置及元素值:\n");
    scanf("%d%d",&i,&value);
    Insert_linklist(head, i, value);
    output_linklist(head);
    printf("\n");               
    printf("please input del posttion:\n");
    int j;
    scanf("%d",&j);
    Del_node_id(head, j);
    output_linklist(head);
    printf("\nplease input del value:\n");
    scanf("%d",&value);
    Del_node_value(head, value);
    output_linklist(head);
    return 0;
}

6.執行截圖

這裡寫圖片描述

持續更新中~~

相關推薦

單鏈表插入和刪除結點c語言的實現

插入節點的方法比較簡單，只需宣告一個索引的指標p和宣告一個記錄p下一個指標的next。實現過程就是，申請記憶體的指標pNew.讓p->next = pNew, pNew->next = next. 如此一來就實現了往p後面插入一個數據。 /* ========

Java鏈接HBASE數據庫，創建一個表，刪除一張表，修改表，輸出插入，修改，數據刪除，數據獲取，顯示表信息，過濾查詢，分頁查詢，地理hash

can charat nfa true 目錄結構 dfa byte sin extra 準備工作 1、創建Java的Maven項目 創建好的目錄結構如下： 另外註意junit的版本，最好不要太高，最開始筆者使用的junit4.12的，發現運行的時候會報錯。最後把Junit

單鏈表的基本操作（增加，查詢，刪除，修改）-- C 語言

#include <stdio.h> #include <stdlib.h> typedef struct Link { // 資料域 int data; // 指標

程式設計師面試寶典（第三版）——單鏈表的基本操作：建立，求長度，輸出，排序，插入，刪除，逆置

程式設計實現一個單鏈表的建立，求單鏈表的長度，列印輸出單鏈表，對單鏈表進行排序，插入元素，刪除元素，對單鏈表進行逆置。 我是借鑑參考資料，然後自己寫規範，對函式都進行了呼叫，每一次呼叫，都有輸出單鏈表。程式完整，已除錯執行。 源程式： #include<iostrea

Java連線HBASE資料庫，建立一個表，刪除一張表，修改表，輸出插入，修改，資料刪除，資料獲取，顯示錶資訊，過濾查詢，分頁查詢，地理hash

準備工作 1、建立Java的Maven專案 建立好的目錄結構如下： 另外注意junit的版本，最好不要太高，最開始筆者使用的junit4.12的，發現執行的時候會報錯。最後把Junit的版本改成4.7的之後，問題解決了。 編寫POM檔案 <

鏈表插入和刪除，判斷鏈表是否為空，求鏈表長度算法的，鏈表排序算法演示——C語言描述

如果 回收站 data 再次 http span 自己 getc tchar 關於數據結構等的學習，以及學習算法的感想感悟，聽了郝斌老師的數據結構課程，其中他也提到了學習數據結構的或者算法的一些個人見解，我覺的很好，對我的幫助也是很大，算法本就是令人頭疼的問題，因為自己並沒

C語言單鏈表的3種排序演算法，插入排序，氣泡排序，選擇排序

//插入排序 stu *view_sort_math(stu *head)   {       struct student *first;     struct student *t;       struct student *p;        struct student *q;        fi

自己寫的順序表的基本操作，插入、刪除、修改，給出完整程式碼，其中運用到goto語句

#include<iostream> using namespace std; #define MAXSIZE 100 typedef int DataType; typedef struct {DataType data[MAXSIZE]; //通常用一位陣列

Oracle 觸發器 插入，更新，刪除,資料同步，兩表同步

create or replace trigger UserToTemp after insert or update or delete on user_info for each row declare     integrity_error exception;     errno           

DB2 建表，添加字段，刪除字段，修改字段等常用操作

varchar 查看 ble col har 同時 int 添加 建數據庫 轉載：http://blog.sina.com.cn/s/blog_67aaf4440100v01p.html，稍作修改。 --創建數據庫 create database Etp; --連接數據庫

Oracle數據庫（三）表操作，連接查詢，分頁

enc 解決辦法 oracl 主鍵 con sequence tno 插入 通過 復制表 --復制表 create table new_table as select * from Product --復制表結構不要數據 create table new

67 orm13查詢語句，外鍵查詢，多對多查詢 單表查詢雙下劃線方法

ever tle 基礎 lte ron -s 執行流程 first 什麽 主要內容：https://www.cnblogs.com/maple-shaw/articles/9403501.html 註意: 如果想要文件中運行整個django項目: 　　需要在文件中寫入:

題目9  單鏈表中儲存M個整數，設計一個時間複雜度儘可能高效的演算法

單鏈表中儲存M個整數，設計一個時間複雜度儘可能高效的演算法，對於連結串列中絕對值相等的元素（|data|<n），只保留第一次出現的節點，刪除其餘的節點。如：15->(-3)->(-15)->3  得：15->(-3) 

MySQL優化分庫分表，為什麼要分表，分表以後如何進行排序查詢，業務如何設計？

MySQL優化分庫分表，為什麼要分表，分表以後如何進行排序查詢，業務如何設計？ 昨天面試新人的時候，遇到了這麼一個問題，按照自己的想法大體聊了一些，但大多是感性的，並沒有完整的瞭解why and how. 今天查了一些相關的資料，包括《MySQL效能調優與架構設計》、《高效能Mysql》，慢慢的整

oracle 根據系統表自動生成簡單的查詢，修改，新增語句

執行環境：pl/sql。主要適用於java/ibatis。 建立測試表 create table task.nayi_180904_01 ( login_id varchar2(50), user_name varchar2(50), age number, create_tim

以面向對象的思想實現數據表的添加和查詢，JDBC代碼超詳細

test 消息 his too ktr lose jdb sstream close 以面向對象的思想編寫JDBC程序，實現使用java程序向數據表中添加學生信息，並且可以實現給定×××號查詢學生信息或給定準考證號查詢學生信息。 創建的數據表如下： CREATE TABLE

mybatis插入更新刪除資料時，成功但是不能寫入資料庫

mybatis進行查詢select操作時 session.select("statement", "parament“); 成功，可以獲取到結果。 但是增刪改時僅僅一句sesseion.[操作

C語言 ，單鏈表實現佇列（初始化，入隊，出隊，元素個數，隊首元素，是否為空）

單鏈表實現佇列： 連結串列為空的判斷條件：pQueue->pFront==pQueue->pRear或者若結構體中存在數的個數時，判斷pQueue->size==0,即元素個數為0 標頭檔案：佇列.h #pragma once #include<

hibernate的關聯，一對多（級聯新增，級聯查詢，普通刪除）

一、什麼是關聯(association) 1、關聯指的是類之間的引用關係。如果類A與類B關聯，那麼被引用的類B將被定義為類A的屬性。 2、關聯的分類：關聯可以分為一對一、一對多/多對一、多對多關聯 關聯是有方向的 關聯的關鍵點都在外來鍵上 二、如何建立一對多雙向

一對多（級聯新增，級聯查詢，刪除）

1. 什麼是關聯(association)   1.1 關聯指的是類之間的引用關係。如果類A與類B關聯，那麼被引用的類B將被定義為類A的屬性。例如:       public class A{         private B b = new B;         publ