链表的创建 查找 排序 插入 删除 逆序 长度 显示

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <stdbool.h>
typedef int elementType;
typedef struct node
{
    int data;
    struct node1*next;
} LinkList;
FILE *fp;
LinkList*Creat(int length)
{
    LinkList*head,*p,*q;
    int i,j;
    int a[length];
    fp=fopen("D:\\SP\\sp.txt","r");
    if(fp==NULL)
    {
        printf("The file can not be opened!");
        exit(1);
    }
    for(i=0; i<length; i++)
    {
        fscanf(fp,"%d",&a[i]);
    }
    fscanf(fp,"\n");

fclose(fp);
    head=(LinkList*)malloc(sizeof(LinkList));
    head->next=NULL;
    q=head;
    for(j=0; j<length; j++)
    {
        p=(LinkList*)malloc(sizeof(LinkList));
        q->next=p;
        p->data=a[j];
        q=p;
    }
    p=(LinkList*)malloc(sizeof(LinkList));
        q->next=p;
        q->next=NULL;////////////////////////////////////////////////////q-next 而不是q
    return head;
}
LinkList*Sort(LinkList*head){
    if(head==NULL){
        return NULL;
    }
    LinkList*p=head->next;
    LinkList*p_pre=p;
    bool flag=false;
    while(p_pre!=NULL){
        int min=p_pre->data;
        p=p_pre->next;
        while(p){
            if(min<=p->data){
                p=p->next;
                flag=true;
                continue;
            }
            else
            {
                min=p->data;////////////////////////先赋值给min,不然后面的值是交换了的!
                int temp;
                temp=p_pre->data;
                p_pre->data=p->data;
                p->data=temp;

p=p->next;
                flag=true;
            }
            if(flag==false){
                return head;
            }

}
        p_pre=p_pre->next;
    }
    return head;
}
void Display(LinkList*head)
{
    LinkList*p;
    p=head->next;
    while(p!=NULL)
    {
        printf("%d ",p->data);
        p=p->next;
    }
    printf("\n");
}
int Search(LinkList*head,int x)
{
    int n=0;
    LinkList *p;
    p=head->next;
    while(p!=NULL&&(p->data!=x))
    {
        p=p->next;
        n++;
    }
    if(p==NULL)
    {
        return -1;
    }
    else
    {
        return n;
    }
}
LinkList*Insert(LinkList*head,int insertnum){
    LinkList*p,*q,*c,*d;
    c=(LinkList*)malloc(sizeof(LinkList));
    d=(LinkList*)malloc(sizeof(LinkList));
    p=head;
    q=p->next;
    if(q==NULL){
        printf("The list is empty!");
    }
    if(q->data>=insertnum){
        c->data=insertnum;
        c->next=head->next;
        return head;
    }
    else{
        p=q;
        q=p->next;
         while(q!=NULL){
        if((q->data)>=insertnum){
        c->data=insertnum;
        c->next=p->next;
        p->next=c;
        return head;
    }
    else{
        p=q;
        q=p->next;
    }
     if(q==NULL){
        c->data=insertnum;
        p->next=c;
        c->next=d;
        c->next=NULL;
        return head;
     }
    }

}

}
LinkList*Delete(LinkList*head,int deleteNum){
    LinkList*p,*q;
    p=head;//////////////////////////////////////////////////////////////////////////对此处不确定
    if(p==NULL){
        return NULL;
    }
    else{
        if(p->data==deleteNum){
            head=head->next;
            free(p);
            return head;
        }
        else{
            while(p!=NULL){
                q=p->next;
                if(q->data==deleteNum){
                    p->next=q->next;
                    free(q);
                    break;
                }
                p=p->next;
            }
            return head;
        }
    }
    }
int Count(LinkList*head){
    LinkList*p;
    int length=0;
    p=head->next;
    while(p!=NULL){
        length++;
        p=p->next;
    }
    return length;
}
LinkList*Reverse(LinkList*head){
    LinkList*p,*q;
    p=head->next;
    /*while(p!=NULL){
       q=p->next;
       p->next=q->next;
       q->next=head->next;
       head->next=q;

}
    */
    head->next=NULL;
    while(p){
        q=p->next;
        p->next=head->next;
        head->next=p;
        p=q;
    }
    return head;
}
int main()
{
    LinkList* head=(LinkList*)malloc(sizeof(LinkList));
    int length;
    int order;
    int deleteNum;
    int x;
    char c;
    int insertnum;
    int ListLength;
    int position;
    bool inputFlag;
    inputFlag=true;
    while(inputFlag)
    {
        printf("Please input number order:Create/0,Display/1,Sort/2,Search/3, Insert/4,Delete/5,Count/6,Revers/7\n");
    scanf("%d",&order);
    switch(order)
    {
    case 0:
        printf("Creat the List\n");
        printf("Please input the length:\n");
        scanf("%d",&length);
        head=Creat(length);
        printf("The LIST is created!\n");
        break;
    case 1:
        printf("Display the List:\n");
        Display(head);
        break;
    case 2:
        printf("Sort\n");
        head=Sort(head);
        break;
    case 3:
        printf("Search\n");
        printf("Please input the number you want to search:\n");
        scanf("%d",&x);
        position =Search(head,x);
        printf("The position of it is:%d\n",position);
        break;
    case 4:
        printf("Insert\n");
        printf("Please input the number you want to insert:\n");
        scanf("%d",&insertnum);
        head=Insert(head,insertnum);
        break;
    case 5:
        printf("Delete\n");
        printf("Please input the position of the number you want to delete:\n");
        scanf("%d",&deleteNum);
        head=Delete(head,deleteNum);
        break;
    case 6:
        printf("Count\n");
        ListLength=Count(head);
        printf("%d\n",ListLength);
        break;
    case 7:
        printf("Reverse\n");
        head=Reverse(head);
        break;
    default:
        break;
    }
    printf("Would you want to go on? Yes/Y or No/N\n");
    scanf(" %c",&c);
    if(c==‘Y‘)
    {
        inputFlag=true;
    }
    else if(c==‘N‘)
    {
        inputFlag=false;
    }
    else
    {
        printf("You input the wrong information!\n");
        inputFlag=false;
    }
    }

return 0;

}

时间: 2024-10-29 19:10:52

链表的创建 查找 排序 插入 删除 逆序 长度 显示的相关文章

数据结构:链表的基本操作(创建,删除,插入,逆序,摧毁)

代码注释比较详细: #include <iostream> #include <cstdlib> using namespace std; struct Node{ int data; Node* next; }; Node* head = NULL; bool create() { head = (Node*)malloc(sizeof(Node)); if(NULL == head) return false; head->data = 0; head->next

【数据结构】用C++实现双链表的各种操作(包括头删,尾删,插入,逆序,摧毁,清空等等)

//[数据结构]用C++实现双链表的各种操作(包括头删,尾删,插入,逆序,摧毁,清空等等) //头文件 #ifndef _LIST_H #define _LIST_H #include<iostream> using namespace std; template<class Type> class DList; template<class Type> class ListNode { friend class DList<Type>; public: L

【数据结构】用C++实现双循环链表的各种操作(包括头删,尾删,插入,逆序,摧毁,清空等等)

//[数据结构]用C++实现单循环链表的各种操作(包括头删,尾删,插入,逆序,摧毁,清空等等) //头文件 #ifndef _CDLIST_H #define _CDLIST_H #include<iostream> using namespace std; template<class Type> class CDList; template<class Type> class ListNode { friend class CDList<Type>; p

静态链表 初始化 定位 Malloc Free 插入 删除

#include <stdio.h> #include <stdlib.h> #define OK 1 #define TRUE 1 #define ERROR -1 #define FALSE -1 #define OVERFLOW -2 #define ElemType int #define Status int typedef int ElemType typedef int Status #define MAX_SIZE 1000;//表最大空间 /* //线性表的基本操

【数据结构】用C++实现顺序表的各种操作(包括头删,尾删,插入,逆序,摧毁,清空等等)

//顺序表的各种操作(包括头删,尾删,插入,逆序,摧毁,清空等等) //头文件 #pragma once #include <iostream> using namespace std; template<class Type> class SeqList { public: SeqList(size_t sz = INIT_SIZE); ~SeqList(); public: bool isfull() const {return size >= capacity; } b

【数据结构】用C语言实现顺序表的各种操作(包括头删,尾删,插入,逆序,摧毁,清空等等)

//顺序表的各种操作(包括头删,尾删,插入,逆序,摧毁,清空等等) //头文件 #ifndef _SEQLIST_H #define _SEQLIST_H #include<stdio.h> typedef int ElemType; #define INIT_SIZE 8 typedef struct SeqList { ElemType *base; size_t capacity; size_t size; }SeqList; int isempty(SeqList *list); in

栈和队列----将单链表的每K个节点之间逆序

将单链表的每K个节点之间逆序 给定一个单链表的头节点head,实现一个调整链表的函数,使得每K 个节点之间逆序,如果最后剩下不够K 个节点,则不调整最后几个. 例如: 链表:1->2->3->4->5->6->7->8->null,k=3. 调整好后:3->2->1->6->5->4->7->8->null,其中7.8不调整,因为不够一组. [解析] 1. 首先从左到右遍历链表,如果栈的大小不等于k ,则不断的

【数据结构】用C++实现单链表的各种操作(包括头删,尾删,插入,逆序,摧毁,清空等等)

//头文件 #ifndef _LIST_H #define _LIST_H #include<iostream> using namespace std; template<class Type> class List; template<class Type> class ListNode { friend class List<Type>; public: ListNode() :data(Type()), next(NULL) {} ListNode(

【数据结构】用C++实现单循环链表的各种操作(包括头删,尾删,插入,逆序,摧毁,清空等等)

//头文件 #ifndef _LIST_H #define _LIST_H #include<iostream> using namespace std; template<class Type> class CList; template<class Type> class ListNode { friend class CList<Type>; public: ListNode() :data(Type()), next(NULL) { } ListNo